/// <summary>
/// Create the mtl file with the given lines
/// </summary>
/// <param name="mtlLines"></param>
/// <param name="mtlFilename"></param>
/// <returns></returns>
public static bool WriteMtl(List <string> mtlLines, string mtlFilename)
{
try
{
using (StreamWriter mtl = new StreamWriter(mtlFilename)) // Make the .mtl file
{
mtl.WriteLine(GenericUtils.GetCreditsFile());
foreach (string line in mtlLines)
{
mtl.WriteLine(line); // Add the data to the mtl file
}
}
}
catch
{
return(false);
}
return(true);
}
/// <summary>
/// Create the obj and mtl files with the given data
/// </summary>
/// <param name="objData">Data parsed from the obj file</param>
/// <param name="mtlData">Data parsed from the mtl file</param>
/// <param name="objFilename">Output path</param>
/// <param name="makeMtl">Create a mtl file</param>
/// <param name="useExistingMtl">Use the mtlData to create the mtl file</param>
/// <returns></returns>
public static bool WriteObj(ObjData objData, MtlData mtlData, string objFilename, bool makeMtl, bool useExistingMtl)
{
// objFilename has the .obj extension
string directory = System.IO.Path.GetDirectoryName(objFilename);
string noExtension = System.IO.Path.GetFileNameWithoutExtension(objFilename);
string mtlRelative = string.Format("{0}.mtl", noExtension);
string mtlFilename = System.IO.Path.Combine(directory, mtlRelative);
List <string> mtlLines = new List <string>(); // To store the lines to append to the mtl file
try
{
using (StreamWriter obj = new StreamWriter(objFilename))
{
// mtllib, o, v, vt, g, usemtl, s, f
obj.WriteLine(GenericUtils.GetCreditsFile());
if (makeMtl)
{
obj.WriteLine(ObjUtils.GetNewMtlLib(mtlRelative));
}
LocalIndexesObj indexesObj = new LocalIndexesObj();
foreach (ObjectObj objectObj in objData.ObjectsList)
{
if (objectObj.ObjectName != null)
{
obj.WriteLine(ObjUtils.GetNewObject(objectObj.ObjectName)); // o
}
foreach (Point p in objectObj.VerticesList)
{
obj.WriteLine(ObjUtils.GetNewCoord(p.ToString())); // v
}
foreach (UVCoordinates uv in objectObj.UVsList)
{
obj.WriteLine(ObjUtils.GetNewTexCoord(uv.ToString())); // vt
}
foreach (Vector v in objectObj.NormalsList)
{
obj.WriteLine(ObjUtils.GetNewVertNormal(v.ToString())); // vn
}
if (objectObj.GroupName != null)
{
obj.WriteLine(ObjUtils.GetNewGroup(objectObj.GroupName)); // g
}
if (objectObj.MaterialName != null)
{
obj.WriteLine(ObjUtils.GetNewUseMtl(objectObj.MaterialName)); // usemtl
// Store lines in the mtl array to append to the file later
mtlLines.Add(MtlUtils.GetMtlData(objectObj.MaterialName, objectObj.TextureName));
}
if (objectObj.Smooth == -1)
{
obj.WriteLine(ObjUtils.GetNewSmoothGroup()); // s
}
else
{
obj.WriteLine(ObjUtils.GetNewSmoothGroup(objectObj.Smooth)); // s
}
foreach (VertIndexesObj vertIndexes in objectObj.VertIndexesList)
{
obj.WriteLine(ObjUtils.GetNewF(GetDataF(vertIndexes, indexesObj))); // f
}
indexesObj.vIndex += objectObj.VerticesList.Count;
indexesObj.vtIndex += objectObj.UVsList.Count;
indexesObj.vnIndex += objectObj.NormalsList.Count;
}
}
}
catch
{
return(false);
}
if (makeMtl) // If we dont delete materials
{
if (useExistingMtl && mtlData != null) // Use the parsed mtl
{
return(MtlExporter.WriteMtl(mtlData, mtlFilename));
}
else // Create a mtl from the data obtained in the obj
{
return(MtlExporter.WriteMtl(mtlLines, mtlFilename));
}
}
return(true);
}
/// <summary>
/// Create the obj and mtl files with the given data
/// </summary>
/// <param name="wrlData">Data parsed from the wrl file</param>
/// <param name="objFilename">Output file</param>
/// <returns></returns>
public static bool WriteObj(WrlData wrlData, string objFilename)
{
// objFilename has the .obj extension
string directory = System.IO.Path.GetDirectoryName(objFilename);
string noExtension = System.IO.Path.GetFileNameWithoutExtension(objFilename);
string mtlRelative = $"{noExtension}.mtl";
string mtlFilename = System.IO.Path.Combine(directory, mtlRelative);
List <string> mtlLines = new List <string>(); // To store the lines to append to the mtl file
try
{
using (StreamWriter obj = new StreamWriter(objFilename))
{
// mtllib, o, v, vt, g, usemtl, s, f
obj.WriteLine(GenericUtils.GetCreditsFile());
obj.WriteLine(ObjUtils.GetNewMtlLib(mtlRelative));
int i_coordIndex = 0;
int i_texCoordIndex = 0;
int index = 0;
foreach (Transform transform in wrlData.TransformsList)
{
foreach (Shape shape in transform.ShapesList)
{
string groupName = "";
string urlTexture = null;
string diffuseColor = null;
if (shape.Appearance != null)
{
if (shape.Appearance.Material != null)
{
if (shape.Appearance.Material.DiffuseColor != null)
{
diffuseColor = shape.Appearance.Material.DiffuseColor.ToString();
}
}
if (shape.Appearance.Texture != null)
{
urlTexture = shape.Appearance.Texture.Url;
if (urlTexture != null)
{
groupName = ObjUtils.GetGroupName(index, urlTexture);
}
else
{
groupName = ObjUtils.GetGroupName(index);
}
}
else
{
groupName = ObjUtils.GetGroupName(index);
}
}
mtlLines.Add(MtlUtils.GetMtlData(groupName, urlTexture, diffuseColor));
obj.WriteLine(ObjUtils.GetNewObject(groupName)); // o
int sizeCoord = 0; int sizeTexCoord = 0;
if (shape.Geometry != null)
{
if (shape.Geometry.Coord != null)
{
sizeCoord = shape.Geometry.Coord.PointsList.Count;
foreach (Point point in shape.Geometry.Coord.PointsList)
{
obj.WriteLine(ObjUtils.GetNewCoord(point.ToString())); // v
}
}
if (shape.Geometry.TexCoord != null)
{
sizeTexCoord = shape.Geometry.TexCoord.UVList.Count;
foreach (UVCoordinates uv in shape.Geometry.TexCoord.UVList)
{
obj.WriteLine(ObjUtils.GetNewTexCoord(uv.ToString())); // vt
}
}
}
obj.WriteLine(ObjUtils.GetNewGroup(groupName)); // g
obj.WriteLine(ObjUtils.GetNewUseMtl(groupName)); // usemtl
obj.WriteLine(ObjUtils.GetNewSmoothGroup()); // s
if (shape.Geometry != null)
{
CoordIndexesWrl coordIndexes = shape.Geometry.CoordIndexes;
CoordIndexesWrl texCoordIndexes = shape.Geometry.TexCoordIndexes;
if (coordIndexes != null)
{
List <CoordIndexWrl> coordIndexesList = coordIndexes.IndexesList;
if (texCoordIndexes != null)
{
List <CoordIndexWrl> texCoordIndexesList = texCoordIndexes.IndexesList;
for (int i = 0; i < coordIndexesList.Count; i++)
{
string strIndexesF = GetIndexesF(coordIndexesList[i], texCoordIndexesList[i], i_coordIndex, i_texCoordIndex);
obj.WriteLine(ObjUtils.GetNewF(strIndexesF)); // f
}
}
else
{
foreach (CoordIndexWrl coordIndex in coordIndexesList)
{
string strIndexesF = GetIndexesF(coordIndex, i_coordIndex);
obj.WriteLine(ObjUtils.GetNewF(strIndexesF)); // f
}
}
}
}
i_coordIndex += sizeCoord;
i_texCoordIndex += sizeTexCoord;
index++;
}
}
}
}
catch
{
return(false);
}
return(MtlExporter.WriteMtl(mtlLines, mtlFilename)); // Create the mtl file
}
/// <summary>
/// Create the mtl file with the given data
/// </summary>
/// <param name="mtlData">Data parsed from the mtl file</param>
/// <param name="mtlFilename">Output path</param>
/// <returns></returns>
public static bool WriteMtl(MtlData mtlData, string mtlFilename)
{
try
{
using (StreamWriter mtl = new StreamWriter(mtlFilename))
{
mtl.WriteLine(GenericUtils.GetCreditsFile());
// newmtl, Ns, Ka, Kd, Ks, Ni, d, illum, map_Kd, map_Ka, map_Ks, map_d
foreach (MaterialMtl material in mtlData.MaterialsList)
{
mtl.WriteLine(MtlUtils.GetNewNewMtl(material.NewMtl));
mtl.WriteLine(MtlUtils.GetNewNs(material.Ns));
if (material.Ka != null)
{
mtl.WriteLine(MtlUtils.GetNewKa(material.Ka.ToString()));
}
else
{
mtl.WriteLine(MtlUtils.GetNewKa());
}
if (material.Kd != null)
{
mtl.WriteLine(MtlUtils.GetNewKd(material.Kd.ToString()));
}
else
{
mtl.WriteLine(MtlUtils.GetNewKd());
}
if (material.Ks != null)
{
mtl.WriteLine(MtlUtils.GetNewKs(material.Ks.ToString()));
}
else
{
mtl.WriteLine(MtlUtils.GetNewKs());
}
if (material.Ke != null)
{
mtl.WriteLine(MtlUtils.GetNewKe(material.Ke.ToString()));
}
else
{
mtl.WriteLine(MtlUtils.GetNewKe());
}
mtl.WriteLine(MtlUtils.GetNewNi(material.Ni));
mtl.WriteLine(MtlUtils.GetNewD(material.D));
mtl.WriteLine(MtlUtils.GetNewIllum(material.Illum));
if (material.MapKd != null)
{
mtl.WriteLine(MtlUtils.GetNewMapKd(material.MapKd));
}
if (material.MapKa != null)
{
mtl.WriteLine(MtlUtils.GetNewMapKa(material.MapKa));
}
if (material.MapKs != null)
{
mtl.WriteLine(MtlUtils.GetNewMapKs(material.MapKs));
}
if (material.MapD != null)
{
mtl.WriteLine(MtlUtils.GetNewMapD(material.MapD));
}
mtl.WriteLine(); // Empty line
}
}
}
catch
{
return(false);
}
return(true);
}