private void objectSelected(ThreeDModel sel)
{
if (Control.ModifierKeys == Keys.Shift)
{
if (!sel.Selected)
{
listSTLObjects.SelectedItems.Add(sel);
}
}
else
if (Control.ModifierKeys == Keys.Control)
{
if (sel.Selected)
{
listSTLObjects.SelectedItems.Remove(sel);
}
else
{
listSTLObjects.SelectedItems.Add(sel);
}
}
else
{
listSTLObjects.SelectedItems.Clear();
listSTLObjects.SelectedItem = sel;
}
}
public void WriteModel(ThreeDModel m3d, Stream stream)
{
this.ostream = stream;
this.tw = new FormattedStreamWriter(this.ostream, new UTF8Encoding(false), 4096, false, CultureInfo.InvariantCulture);
this.tw.NewLine = "\n";
this.WriteInternal(m3d);
}
private void objectSelected(ThreeDModel sel)
{
if (Control.ModifierKeys == Keys.Shift)
{
if (!sel.Selected)
{
SetObjectSelected((PrintModel)sel, true);
}
}
else
if (Control.ModifierKeys == Keys.Control)
{
if (sel.Selected)
{
SetObjectSelected((PrintModel)sel, false);
}
else
{
SetObjectSelected((PrintModel)sel, true);
}
}
else
{
listObjects.SelectedItems.Clear();
SetObjectSelected((PrintModel)sel, true);
}
}
private void objectSelected(ThreeDModel sel)
{
if (Control.ModifierKeys == Keys.Shift)
{
if (!sel.Selected)
{
SetObjectSelected((PrintModel)sel, true);
}
}
else
if (Control.ModifierKeys == Keys.Control)
{
if (sel.Selected)
{
SetObjectSelected((PrintModel)sel, false);
}
else
{
SetObjectSelected((PrintModel)sel, true);
}
}
else
{
foreach (ListViewItem test in listObjects.Items)
{
if (test.Selected && (PrintModel)test.Tag != (PrintModel)sel)
{
test.Selected = false;
}
}
//listObjects.SelectedItems.Clear();
SetObjectSelected((PrintModel)sel, true);
}
}
private void WriteMtl(ThreeDModel m3d, string mtlfn)
{
var opts = Program.Options;
var clr = opts.OverrideColor;
var dn = this.fi.Directory.FullName;
var p = Path.Combine(dn, string.Concat(mtlfn, ".mtl"));
var mtlfi = new FileInfo(p);
using (var fs = mtlfi.Create())
using (var sw = new StreamWriter(fs, new UTF8Encoding(false)))
{
sw.NewLine = "\n";
sw.WriteLine("# Generated using MSET Converter by John Cena of PTF");
sw.WriteLine("# mset Version: {0}", Program.GetAssemblyVersion());
sw.WriteLine("# mset-obj Version: {0}", this.VersionID);
sw.WriteLine();
sw.WriteLine("# Default MSET material");
sw.WriteLine("newmtl JCMSet");
sw.WriteLine("Kd {0:0.000000} {1:0.000000} {2:0.000000}", clr.RFloat, clr.GFloat, clr.BFloat);
sw.WriteLine("d {0:0.000000}", clr.AFloat);
sw.WriteLine("Tr {0:0.000000}", 1F - clr.AFloat);
sw.WriteLine();
sw.Flush();
}
if (opts.VerboseMode)
{
ULogger.W("OBJMTL", "Written MTL: {0}", mtlfi.FullName);
}
}
public void WriteModel(ThreeDModel m3d, Stream stream)
{
this.ostream = stream;
this.tw = new FormattedStreamWriter(this.ostream, new ASCIIEncoding(), 4096, true, CultureInfo.InvariantCulture);
this.bw = new BinaryWriter(this.ostream, new ASCIIEncoding(), true);
this.tw.NewLine = "\n";
this.WriteInternal(m3d);
}
private void gl_MouseDown(object sender, MouseEventArgs e)
{
lastX = xDown = e.X;
lastY = yDown = e.Y;
startRotX = rotX;
startRotZ = rotZ;
startViewCenter = viewCenter;
startUserPosition = userPosition;
if (e.Button == MouseButtons.Right)
{
ThreeDModel sel = Picktest(e.X, e.Y);
if (sel != null && eventObjectMoved != null)
{
eventObjectSelected(sel);
}
//computeRay();
}
}
private void objectSelected(ThreeDModel sel)
{
listSTLObjects.SelectedItem = sel;
}
public void WriteRawMesh(ThreeDModel m3d, FileInfo msetf, FileInfo m3drf, Encoding enc)
{
using (var fs = m3drf.Create())
using (var tw = new FormattedStreamWriter(fs, enc, 4096, false, CultureInfo.InvariantCulture))
using (var xw = new XmlTextWriter(tw))
{
xw.Formatting = Formatting.Indented;
xw.WriteStartDocument();
var sb = new StringBuilder();
sb.AppendLine()
.AppendLine("3D Model imported from MSET")
.AppendLine("Using John Cena's MSET Converter")
.AppendFormat("Converter version: {0}", Program.GetAssemblyVersion()).AppendLine()
.AppendLine()
.AppendLine("Mesh information:")
.AppendFormat("Vertex count: {0}", m3d.VertexCount).AppendLine()
.AppendFormat("Face count: {0}", m3d.FaceCount).AppendLine();
xw.WriteComment(sb.ToString());
xw.WriteStartElement("3dmesh");
xw.WriteStartElement("mesh-info");
xw.WriteStartElement("model-name");
xw.WriteStartAttribute("value");
xw.WriteValue(m3d.ModelName);
xw.WriteEndAttribute();
xw.WriteEndElement();
xw.WriteStartElement("source-file");
xw.WriteStartAttribute("value");
xw.WriteValue(msetf.Name);
xw.WriteEndAttribute();
xw.WriteEndElement();
xw.WriteStartElement("vertex-count");
xw.WriteStartAttribute("value");
xw.WriteValue(m3d.VertexCount);
xw.WriteEndAttribute();
xw.WriteEndElement();
xw.WriteStartElement("face-count");
xw.WriteStartAttribute("value");
xw.WriteValue(m3d.FaceCount);
xw.WriteEndAttribute();
xw.WriteEndElement();
xw.WriteStartElement("data-contained");
if (m3d.Vertices != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("vertices");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.Faces != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("faces");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.Normals != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("normals");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.Binormals != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("binormals");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.Tangents != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("tangents");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.TextureCoordinates != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("texture-coordinates");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.Colors != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("vertex-colors");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.TextureCoordinates3 != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("texture-coordinates-3");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.Vertices2 != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("vertices-2");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
if (m3d.Normals2 != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("normals-2");
xw.WriteEndAttribute();
xw.WriteEndElement();
}
xw.WriteEndElement(); // data-contained
xw.WriteEndElement(); // mesh-info
xw.WriteStartElement("mesh-data");
if (m3d.Vertices != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("vertices");
xw.WriteEndAttribute();
foreach (var vertex in m3d.Vertices)
{
xw.WriteStartElement("vertex");
xw.WriteStartAttribute("x");
xw.WriteValue(vertex.X.ToString("0.000000"));
xw.WriteEndAttribute(); // x
xw.WriteStartAttribute("y");
xw.WriteValue(vertex.Y.ToString("0.000000"));
xw.WriteEndAttribute(); // y
xw.WriteStartAttribute("z");
xw.WriteValue(vertex.Z.ToString("0.000000"));
xw.WriteEndAttribute(); // z
xw.WriteEndElement(); // vertex
}
xw.WriteEndElement(); // data
}
if (m3d.Faces != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("faces");
xw.WriteEndAttribute();
foreach (var face in m3d.Faces)
{
xw.WriteStartElement("face");
xw.WriteStartAttribute("v1");
xw.WriteValue(face.Vertex1);
xw.WriteEndAttribute(); // v1
xw.WriteStartAttribute("v2");
xw.WriteValue(face.Vertex2);
xw.WriteEndAttribute(); // v2
xw.WriteStartAttribute("v3");
xw.WriteValue(face.Vertex3);
xw.WriteEndAttribute(); // v3
xw.WriteEndElement(); // face
}
xw.WriteEndElement(); // data
}
if (m3d.Normals != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("normals");
xw.WriteEndAttribute();
foreach (var normal in m3d.Normals)
{
xw.WriteStartElement("normal");
xw.WriteStartAttribute("x");
xw.WriteValue(normal.X.ToString("0.000000"));
xw.WriteEndAttribute(); // x
xw.WriteStartAttribute("y");
xw.WriteValue(normal.Y.ToString("0.000000"));
xw.WriteEndAttribute(); // y
xw.WriteStartAttribute("z");
xw.WriteValue(normal.Z.ToString("0.000000"));
xw.WriteEndAttribute(); // z
xw.WriteEndElement(); // normal
}
xw.WriteEndElement(); // data
}
if (m3d.Binormals != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("binormals");
xw.WriteEndAttribute();
foreach (var binormal in m3d.Binormals)
{
xw.WriteStartElement("binormal");
xw.WriteStartAttribute("x");
xw.WriteValue(binormal.X.ToString("0.000000"));
xw.WriteEndAttribute(); // x
xw.WriteStartAttribute("y");
xw.WriteValue(binormal.Y.ToString("0.000000"));
xw.WriteEndAttribute(); // y
xw.WriteStartAttribute("z");
xw.WriteValue(binormal.Z.ToString("0.000000"));
xw.WriteEndAttribute(); // z
xw.WriteEndElement(); // binormal
}
xw.WriteEndElement(); // data
}
if (m3d.Tangents != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("tangents");
xw.WriteEndAttribute();
foreach (var tangent in m3d.Tangents)
{
xw.WriteStartElement("tangent");
xw.WriteStartAttribute("x");
xw.WriteValue(tangent.X.ToString("0.000000"));
xw.WriteEndAttribute(); // x
xw.WriteStartAttribute("y");
xw.WriteValue(tangent.Y.ToString("0.000000"));
xw.WriteEndAttribute(); // y
xw.WriteStartAttribute("z");
xw.WriteValue(tangent.Z.ToString("0.000000"));
xw.WriteEndAttribute(); // z
xw.WriteEndElement(); // tangent
}
xw.WriteEndElement(); // data
}
if (m3d.TextureCoordinates != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("texture-coordinates");
xw.WriteEndAttribute();
foreach (var texcoord in m3d.TextureCoordinates)
{
xw.WriteStartElement("texcoord");
xw.WriteStartAttribute("u");
xw.WriteValue(texcoord.U.ToString("0.000000"));
xw.WriteEndAttribute(); // u
xw.WriteStartAttribute("v");
xw.WriteValue(texcoord.V.ToString("0.000000"));
xw.WriteEndAttribute(); // v
xw.WriteEndElement(); // texcoord
}
xw.WriteEndElement(); // data
}
if (m3d.Colors != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("colors");
xw.WriteEndAttribute();
foreach (var color in m3d.Colors)
{
xw.WriteStartElement("color");
xw.WriteStartAttribute("r");
xw.WriteValue(color.R);
xw.WriteEndAttribute(); // r
xw.WriteStartAttribute("g");
xw.WriteValue(color.G);
xw.WriteEndAttribute(); // g
xw.WriteStartAttribute("b");
xw.WriteValue(color.B);
xw.WriteEndAttribute(); // b
xw.WriteStartAttribute("a");
xw.WriteValue(color.A);
xw.WriteEndAttribute(); // a
xw.WriteEndElement(); // color
}
xw.WriteEndElement(); // data
}
if (m3d.TextureCoordinates3 != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("texture-coordinates-3");
xw.WriteEndAttribute();
foreach (var texcoord3 in m3d.TextureCoordinates3)
{
xw.WriteStartElement("texcoord3");
xw.WriteStartAttribute("u");
xw.WriteValue(texcoord3.U.ToString("0.000000"));
xw.WriteEndAttribute(); // u
xw.WriteStartAttribute("v");
xw.WriteValue(texcoord3.V.ToString("0.000000"));
xw.WriteEndAttribute(); // v
xw.WriteEndElement(); // texcoord3
}
xw.WriteEndElement(); // data
}
if (m3d.Vertices2 != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("vertices-2");
xw.WriteEndAttribute();
foreach (var vertex2 in m3d.Vertices2)
{
xw.WriteStartElement("vertex2");
xw.WriteStartAttribute("x");
xw.WriteValue(vertex2.X.ToString("0.000000"));
xw.WriteEndAttribute(); // x
xw.WriteStartAttribute("y");
xw.WriteValue(vertex2.Y.ToString("0.000000"));
xw.WriteEndAttribute(); // y
xw.WriteStartAttribute("z");
xw.WriteValue(vertex2.Z.ToString("0.000000"));
xw.WriteEndAttribute(); // z
xw.WriteEndElement(); // vertex2
}
xw.WriteEndElement(); // data
}
if (m3d.Normals2 != null)
{
xw.WriteStartElement("data");
xw.WriteStartAttribute("type");
xw.WriteValue("normals-2");
xw.WriteEndAttribute();
foreach (var normal2 in m3d.Normals2)
{
xw.WriteStartElement("normal2");
xw.WriteStartAttribute("x");
xw.WriteValue(normal2.X.ToString("0.000000"));
xw.WriteEndAttribute(); // x
xw.WriteStartAttribute("y");
xw.WriteValue(normal2.Y.ToString("0.000000"));
xw.WriteEndAttribute(); // y
xw.WriteStartAttribute("z");
xw.WriteValue(normal2.Z.ToString("0.000000"));
xw.WriteEndAttribute(); // z
xw.WriteEndElement(); // normal2
}
xw.WriteEndElement(); // data
}
xw.WriteEndElement(); //mesh-data
xw.WriteEndElement();
xw.WriteEndDocument();
xw.Flush();
}
}
private void WriteInternal(ThreeDModel m3d)
{
var opts = Program.Options;
var oclr = opts.OverrideColor;
var is_ascii = this.opts.ContainsKey("fmt") && this.opts["fmt"] == "ascii";
var ascii = is_ascii ? new ASCIIEncoding() : null;
this.tw.WriteLine("ply");
if (is_ascii)
{
this.tw.WriteLine("format ascii 1.0");
}
else
{
this.tw.WriteLine("format binary_little_endian 1.0");
}
var hasclr = m3d.Colors != null;
var hasnorm = m3d.Normals != null;
var hastex = m3d.TextureCoordinates != null;
this.tw.WriteLine("comment Converted using MSET Converter by John Cena of PTF");
this.tw.WriteLine("comment mset Version: {0}", Program.GetAssemblyVersion());
this.tw.WriteLine("comment mset-ply Version: {0}", this.VersionID);
this.tw.WriteLine("comment ");
this.tw.WriteLine("comment Model Summary: ");
this.tw.WriteLine("comment Name: {0}", m3d.ModelName);
this.tw.WriteLine("comment Vertex Count: {0:#,##0} ", m3d.VertexCount);
this.tw.WriteLine("comment Face Count: {0:#,##0} ", m3d.FaceCount);
this.tw.WriteLine("comment ");
this.tw.WriteLine("comment Writer options:");
foreach (var kvp in this.opts)
{
this.tw.WriteLine("comment {0}={1}", kvp.Key, kvp.Value);
}
this.tw.WriteLine("element vertex {0:0}", m3d.VertexCount);
this.tw.WriteLine("property float x");
this.tw.WriteLine("property float y");
this.tw.WriteLine("property float z");
if (hasnorm)
{
this.tw.WriteLine("property float nx");
this.tw.WriteLine("property float ny");
this.tw.WriteLine("property float nz");
}
if (hasclr)
{
this.tw.WriteLine("property uchar red");
this.tw.WriteLine("property uchar green");
this.tw.WriteLine("property uchar blue");
this.tw.WriteLine("property uchar alpha");
}
if (hastex)
{
this.tw.WriteLine("property float s");
this.tw.WriteLine("property float t");
}
this.tw.WriteLine("element face {0:0}", m3d.FaceCount);
this.tw.WriteLine("property list uchar int vertex_indices");
this.tw.WriteLine("end_header");
this.tw.Flush();
for (int i = 0; i < m3d.VertexCount; i++)
{
var vert = m3d.Vertices[i];
var norm = hasnorm ? m3d.Normals[i] : default(ThreeDNormal);
var clr = hasclr ? (m3d.Colors[i]) : default(ThreeDColor);
var texcoord = hastex ? m3d.TextureCoordinates[i] : default(ThreeDTextureCoordinate);
if (is_ascii)
{
this.tw.Write("{0:0.000000} {1:0.000000} {2:0.000000}", vert.X, vert.Y, vert.Z);
if (hasnorm)
{
this.tw.Write(" {0:0.000000} {1:0.000000} {2:0.000000}", norm.X, norm.Y, norm.Z);
}
if (hasclr && !opts.IsColorDefined)
{
this.tw.Write(" {0:0} {1:0} {2:0} {3:0}", clr.R, clr.G, clr.B, clr.A);
}
else if (hasclr)
{
this.tw.Write(" {0:0} {1:0} {2:0} {3:0}", oclr.R, oclr.G, oclr.B, oclr.A);
}
if (hastex)
{
this.tw.Write(" {0:0.000000} {1:0.000000}", texcoord.U, texcoord.V);
}
this.tw.WriteLine();
}
else
{
this.bw.Write(vert.X);
this.bw.Write(vert.Y);
this.bw.Write(vert.Z);
if (hasnorm)
{
this.bw.Write(norm.X);
this.bw.Write(norm.Y);
this.bw.Write(norm.Z);
}
if (hasclr && !opts.IsColorDefined)
{
this.bw.Write(clr.R);
this.bw.Write(clr.G);
this.bw.Write(clr.B);
this.bw.Write(clr.A);
}
else if (hasclr)
{
this.bw.Write(oclr.R);
this.bw.Write(oclr.G);
this.bw.Write(oclr.B);
this.bw.Write(oclr.A);
}
if (hastex)
{
this.bw.Write(texcoord.U);
this.bw.Write(texcoord.V);
}
}
}
if (is_ascii)
{
foreach (var face in m3d.Faces)
{
this.tw.WriteLine("3 {0:0} {1:0} {2:0}", face.Vertex1, face.Vertex2, face.Vertex3);
}
}
else
{
foreach (var face in m3d.Faces)
{
this.bw.Write((byte)3);
this.bw.Write(face.Vertex1);
this.bw.Write(face.Vertex2);
this.bw.Write(face.Vertex3);
}
}
if (is_ascii)
{
this.tw.Flush();
}
else
{
this.bw.Flush();
}
}
public void WriteModel(ThreeDModel m3d, string filename)
{
this.WriteModel(m3d, new FileInfo(filename));
}
public void WriteModel(ThreeDModel m3d, FileInfo file)
{
this.fi = file;
using (var fs = file.Create())
this.WriteModel(m3d, fs);
}
public void DeleteModel(ThreeDModel threeDModel)
{
ModelList.Remove((PrintModel)threeDModel);
SelectedModelIndex = -1;
PreView.models.Remove(threeDModel);
}
private ThreeDModel Picktest(int x, int y)
{
// int x = Mouse.X;
// int y = Mouse.Y;
// Console.WriteLine("X:" + x + " Y:" + y);
gl.MakeCurrent();
uint[] selectBuffer = new uint[128];
GL.SelectBuffer(128, selectBuffer);
GL.RenderMode(RenderingMode.Select);
SetupViewport();
GL.MatrixMode(MatrixMode.Projection);
GL.PushMatrix();
GL.LoadIdentity();
int[] viewport = new int[4];
GL.GetInteger(GetPName.Viewport, viewport);
Matrix4 m = GluPickMatrix(x, viewport[3] - y, 1, 1, viewport);
GL.MultMatrix(ref m);
//GluPerspective(45, 32 / 24, 0.1f, 100.0f);
//Matrix4 projection = Matrix4.CreatePerspectiveFieldOfView((float)Math.PI / 4, 1, 0.1f, 100.0f);
GL.MultMatrix(ref persp);
GL.MatrixMode(MatrixMode.Modelview);
GL.ClearColor(Main.threeDSettings.background.BackColor);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Enable(EnableCap.DepthTest);
lookAt = Matrix4.LookAt(userPosition.X, userPosition.Y, userPosition.Z, viewCenter.X, viewCenter.Y, viewCenter.Z, 0, 0, 1.0f);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref lookAt);
GL.Rotate(rotX, 1, 0, 0);
GL.Rotate(rotZ, 0, 0, 1);
GL.Translate(-ps.PrintAreaWidth * 0.5f, -ps.PrintAreaDepth * 0.5f, -0.5f * ps.PrintAreaHeight);
GL.InitNames();
int pos = 0;
foreach (ThreeDModel model in models)
{
GL.PushName(pos++);
GL.PushMatrix();
model.AnimationBefore();
GL.Translate(model.Position.x, model.Position.y, model.Position.z);
GL.Rotate(model.Rotation.z, Vector3.UnitZ);
GL.Rotate(model.Rotation.y, Vector3.UnitY);
GL.Rotate(model.Rotation.x, Vector3.UnitX);
GL.Scale(model.Scale.x, model.Scale.y, model.Scale.z);
model.Paint();
model.AnimationAfter();
GL.PopMatrix();
GL.PopName();
}
GL.MatrixMode(MatrixMode.Projection);
GL.PopMatrix();
GL.MatrixMode(MatrixMode.Modelview);
int hits = GL.RenderMode(RenderingMode.Render);
ThreeDModel selected = null;
if (hits > 0)
{
selected = models.ElementAt((int)selectBuffer[3]);
uint depth = selectBuffer[1];
for (int i = 1; i < hits; i++)
{
if (selectBuffer[4 * i + 1] < depth)
{
depth = selectBuffer[i * 4 + 1];
selected = models.ElementAt((int)selectBuffer[i * 4 + 3]);
}
}
}
//PrinterConnection.logInfo("Hits: " + hits);
return(selected);
}
private void WriteInternal(ThreeDModel m3d)
{
var opts = Program.Options;
var usemtl = this.opts.ContainsKey("usemtl") && this.opts["usemtl"] == "true";
if (usemtl && !opts.IsColorDefined)
{
ULogger.W("OBJWRITE", "usemtl set to true but no override color defined; ignoring...");
}
usemtl = usemtl && opts.IsColorDefined;
if (!usemtl && opts.IsColorDefined && opts.OverrideColor.A != 255)
{
ULogger.W("OBJWRITE", "usemtl is not set to true, but override color has Alpha different from 255 -- it won't be written!");
}
this.tw.WriteLine("# Converted using MSET Converter by John Cena of PTF");
this.tw.WriteLine("# mset Version: {0}", Program.GetAssemblyVersion());
this.tw.WriteLine("# mset-obj Version: {0}", this.VersionID);
this.tw.WriteLine("# ");
this.tw.WriteLine("# Model Summary: ");
this.tw.WriteLine("# Name: {0}", m3d.ModelName);
this.tw.WriteLine("# Vertex Count: {0:#,##0} ", m3d.VertexCount);
this.tw.WriteLine("# Face Count: {0:#,##0} ", m3d.FaceCount);
this.tw.WriteLine("# ");
this.tw.WriteLine("# Writer options:");
foreach (var kvp in this.opts)
{
this.tw.WriteLine("# {0}={1}", kvp.Key, kvp.Value);
}
this.tw.WriteLine();
var hasclr = m3d.Colors != null;
var hasnorm = m3d.Normals != null;
var hastex = m3d.TextureCoordinates != null;
var mtlfn = (string)null;
if (this.fi != null && usemtl)
{
mtlfn = this.fi.Name.Substring(0, this.fi.Name.Length - this.fi.Extension.Length);
this.tw.WriteLine("mtllib {0}.mtl", mtlfn);
}
this.tw.WriteLine("o Mset.1");
this.tw.WriteLine();
this.tw.WriteLine("# Vertices");
//foreach (var vert in m3d.Vertices)
for (int i = 0; i < m3d.VertexCount; i++)
{
var vert = m3d.Vertices[i];
var clr = hasclr && !usemtl ? m3d.Colors[i] : default(ThreeDColor);
if (hasclr && !usemtl)
{
this.tw.WriteLine("v {0:0.000000} {1:0.000000} {2:0.000000} {3:0.000000} {4:0.000000} {5:0.000000}", vert.X, vert.Y, vert.Z, clr.RFloat, clr.GFloat, clr.BFloat);
}
else
{
this.tw.WriteLine("v {0:0.000000} {1:0.000000} {2:0.000000}", vert.X, vert.Y, vert.Z);
}
}
this.tw.WriteLine("");
if (hasnorm)
{
this.tw.WriteLine("# Normals");
foreach (var norm in m3d.Normals)
{
this.tw.WriteLine("vn {0:0.000000} {1:0.000000} {2:0.000000}", norm.X, norm.Y, norm.Z);
}
this.tw.WriteLine("");
}
if (hastex)
{
this.tw.WriteLine("# Texture Coordinates");
foreach (var texcoord in m3d.TextureCoordinates)
{
this.tw.WriteLine("vt {0:0.000000} {1:0.000000}", texcoord.U, texcoord.V);
}
this.tw.WriteLine("");
}
this.tw.WriteLine("# Faces");
if (this.fi != null && usemtl)
{
this.tw.WriteLine("usemtl JCMset");
}
//foreach (var face in m3d.Faces)
for (int i = 0; i < m3d.FaceCount; i++)
{
var face = m3d.Faces[i];
if (hastex && hasnorm)
{
this.tw.WriteLine("f {0:0}/{0:0}/{0:0} {1:0}/{1:0}/{1:0} {2:0}/{2:0}/{2:0}", face.Vertex1 + 1, face.Vertex2 + 1, face.Vertex3 + 1);
}
else if (hastex && !hasnorm)
{
this.tw.WriteLine("f {0:0}/{0:0} {1:0}/{1:0} {2:0}/{2:0}", face.Vertex1 + 1, face.Vertex2 + 1, face.Vertex3 + 1);
}
else if (!hastex && hasnorm)
{
this.tw.WriteLine("f {0:0}//{0:0} {1:0}//{1:0} {2:0}//{2:0}", face.Vertex1 + 1, face.Vertex2 + 1, face.Vertex3 + 1);
}
else
{
this.tw.WriteLine("f {0:0} {1:0} {2:0}", face.Vertex1 + 1, face.Vertex2 + 1, face.Vertex3 + 1);
}
}
this.tw.WriteLine("");
this.tw.Flush();
if (usemtl)
{
this.WriteMtl(m3d, mtlfn);
}
}
public IEnumerable <ThreeDModel> Create3DModels(MSetFile file)
{
var opts = Program.Options;
var mzs = file.Data;
var mns = new HashSet <string>();
var ns = 0;
foreach (var mz in mzs)
{
ns = Math.Max(ns, mz.Model);
}
var mzm = new MSetZlibStream[ns + 1, 12];
for (int i = 0; i < mzs.Length; i++)
{
if (opts.VerboseMode)
{
ULogger.W("3DMC", "Processing stream {0}", i);
}
var mz = mzs[i];
int fc = file.Models[mz.Model].FaceCount;
var vc = file.Models[mz.Model].VertexCount;
var mzdat = new byte[mz.DecompressedLength];
var y = 0;
if (mz.CompressedLength == 0 && mz.DecompressedLength > 0)
{
while (y < mz.DecompressedLength)
{
y += mz.Data.Read(mzdat, y, mz.DecompressedLength - y);
}
}
else
{
var mzlib = new ZlibStream(mz.Data, CompressionMode.Decompress);
while (y < mz.DecompressedLength)
{
y += mzlib.Read(mzdat, y, mz.DecompressedLength - y);
}
}
if (mz.IsEncoded)
{
if (mz.DataStream == 0)
{
mzdat = DataOperations.DeltaDecompress(mzdat, DataType.I32S, 3, fc);
}
else if (mz.DataStream <= 4 || mz.DataStream >= 10)
{
mzdat = DataOperations.DeltaDecompress(mzdat, DataType.F32, 3, vc);
}
else if (mz.DataStream == 5 || mz.DataStream == 6)
{
mzdat = DataOperations.DeltaDecompress(mzdat, DataType.F32, 2, vc);
}
}
mz.DataProcessed = mzdat;
mzm[mz.Model, mz.DataStream] = mz;
}
if (file.Models.Length <= 0)
{
yield break;
}
for (int i = 0; i < ns + 1; i++)
{
if (opts.VerboseMode)
{
ULogger.W("3DMC", "Processing model {0}", i);
}
var mz_tris = mzm[i, 0];
var mz_verts = mzm[i, 1];
var mz_norms = mzm[i, 2];
var mz_binorms = mzm[i, 3];
var mz_tangents = mzm[i, 4];
var mz_sts = mzm[i, 5];
var mz_sts3 = mzm[i, 6];
var mz_colors = mzm[i, 7];
//var mz_weights = mzm[i, 8];
//var mz_matidxs = mzm[i, 9];
var mz_verts2 = mzm[i, 10];
var mz_norms2 = mzm[i, 11];
int fc = file.Models[mz_tris.Model].FaceCount;
var vc = file.Models[mz_tris.Model].VertexCount;
// ...
var l_tris = mz_tris.DataProcessed != null ? new ThreeDFace[fc] : null;
var l_verts = mz_verts.DataProcessed != null ? new ThreeDVertex[vc] : null;
var l_norms = mz_norms.DataProcessed != null ? new ThreeDNormal[vc] : null;
var l_binorms = mz_binorms.DataProcessed != null ? new ThreeDBinormal[vc] : null;
var l_tangents = mz_tangents.DataProcessed != null ? new ThreeDTangent[vc] : null;
var l_sts = mz_sts.DataProcessed != null ? new ThreeDTextureCoordinate[vc] : null;
var l_sts3 = mz_sts3.DataProcessed != null ? new ThreeDTextureCoordinate[vc] : null;
var l_colors = mz_colors.DataProcessed != null ? new ThreeDColor[vc] : null;
//var l_weights = mz_matidxs.DataProcessed != null ? new ThreeDBoneWeight[] : null;
//var l_matidxs = mz_weights.DataProcessed != null ? new ThreeDBoneMaterials[] : null;
var l_verts2 = mz_verts2.DataProcessed != null ? new ThreeDVertex[vc] : null;
var l_norms2 = mz_norms2.DataProcessed != null ? new ThreeDNormal[vc] : null;
if (l_tris != null)
{
for (int j = 0; j < fc; j++)
{
int index = j * 12;
var f_v1 = BitConverter.ToInt32(mz_tris.DataProcessed, index + 0);
var f_v2 = BitConverter.ToInt32(mz_tris.DataProcessed, index + 4);
var f_v3 = BitConverter.ToInt32(mz_tris.DataProcessed, index + 8);
//l_tris.Add(new ThreeDFace(f_v1, f_v2, f_v3));
l_tris[j] = new ThreeDFace(f_v1, f_v2, f_v3);
}
}
for (int j = 0; j < vc; j++)
{
int index1 = j * 12;
int index2 = j * 8;
int index3 = j * 4;
if (l_verts != null)
{
var v_x = BitConverter.ToSingle(mz_verts.DataProcessed, index1 + 0);
var v_y = BitConverter.ToSingle(mz_verts.DataProcessed, index1 + 4);
var v_z = BitConverter.ToSingle(mz_verts.DataProcessed, index1 + 8);
//l_verts.Add(new ThreeDVertex(v_x, v_y, v_z));
l_verts[j] = new ThreeDVertex(v_x, v_y, v_z);
}
if (l_norms != null)
{
var n_x = BitConverter.ToSingle(mz_norms.DataProcessed, index1 + 0);
var n_y = BitConverter.ToSingle(mz_norms.DataProcessed, index1 + 4);
var n_z = BitConverter.ToSingle(mz_norms.DataProcessed, index1 + 8);
//l_norms.Add(new ThreeDNormal(n_x, n_y, n_z));
l_norms[j] = new ThreeDNormal(n_x, n_y, n_z);
}
if (l_binorms != null)
{
var b_x = BitConverter.ToSingle(mz_binorms.DataProcessed, index1 + 0);
var b_y = BitConverter.ToSingle(mz_binorms.DataProcessed, index1 + 4);
var b_z = BitConverter.ToSingle(mz_binorms.DataProcessed, index1 + 8);
//l_binorms.Add(new ThreeDBinormal(b_x, b_y, b_z));
l_binorms[j] = new ThreeDBinormal(b_x, b_y, b_z);
}
if (l_tangents != null)
{
var t_x = BitConverter.ToSingle(mz_tangents.DataProcessed, index1 + 0);
var t_y = BitConverter.ToSingle(mz_tangents.DataProcessed, index1 + 4);
var t_z = BitConverter.ToSingle(mz_tangents.DataProcessed, index1 + 8);
//l_tangents.Add(new ThreeDTangent(t_x, t_y, t_z));
l_tangents[j] = new ThreeDTangent(t_x, t_y, t_z);
}
if (l_sts != null)
{
var t_u = BitConverter.ToSingle(mz_sts.DataProcessed, index2 + 0);
var t_v = 1F - BitConverter.ToSingle(mz_sts.DataProcessed, index2 + 4);
//l_sts.Add(new ThreeDTextureCoordinate(t_u, t_v));
l_sts[j] = new ThreeDTextureCoordinate(t_u, t_v);
}
if (l_sts3 != null)
{
var t_u = BitConverter.ToSingle(mz_sts3.DataProcessed, index2 + 0);
var t_v = 1F - BitConverter.ToSingle(mz_sts3.DataProcessed, index2 + 4);
//l_sts3.Add(new ThreeDTextureCoordinate(t_u, t_v));
l_sts3[j] = new ThreeDTextureCoordinate(t_u, t_v);
}
if (l_colors != null)
{
var c_r = mz_colors.DataProcessed[index3 + 0];
var c_g = mz_colors.DataProcessed[index3 + 1];
var c_b = mz_colors.DataProcessed[index3 + 2];
var c_a = mz_colors.DataProcessed[index3 + 3];
//l_colors.Add(new ThreeDColor(c_r, c_g, c_b, c_a));
l_colors[j] = new ThreeDColor(c_r, c_g, c_b, c_a);
}
if (l_verts2 != null)
{
var v_x = BitConverter.ToSingle(mz_verts2.DataProcessed, index1 + 0);
var v_y = BitConverter.ToSingle(mz_verts2.DataProcessed, index1 + 4);
var v_z = BitConverter.ToSingle(mz_verts2.DataProcessed, index1 + 8);
//l_verts2.Add(new ThreeDVertex(v_x, v_y, v_z));
l_verts2[j] = new ThreeDVertex(v_x, v_y, v_z);
}
if (l_norms2 != null)
{
var n_x = BitConverter.ToSingle(mz_norms2.DataProcessed, index1 + 0);
var n_y = BitConverter.ToSingle(mz_norms2.DataProcessed, index1 + 4);
var n_z = BitConverter.ToSingle(mz_norms2.DataProcessed, index1 + 8);
//l_norms2.Add(new ThreeDNormal(n_x, n_y, n_z));
l_norms2[j] = new ThreeDNormal(n_x, n_y, n_z);
}
}
var mname = this.GenerateUniqueName(mns, mz_tris.ModelName);
mns.Add(mname);
var m3d = new ThreeDModel
{
ModelName = mname,
VertexCount = vc,
FaceCount = fc,
Faces = l_tris != null?Array.AsReadOnly(l_tris) : null,
Vertices = l_verts != null?Array.AsReadOnly(l_verts) : null,
Normals = l_norms != null?Array.AsReadOnly(l_norms) : null,
Binormals = l_binorms != null?Array.AsReadOnly(l_binorms) : null,
Tangents = l_tangents != null?Array.AsReadOnly(l_tangents) : null,
TextureCoordinates = l_sts != null?Array.AsReadOnly(l_sts) : null,
TextureCoordinates3 = l_sts3 != null?Array.AsReadOnly(l_sts3) : null,
Colors = l_colors != null?Array.AsReadOnly(l_colors) : null,
//
//
Vertices2 = l_verts2 != null?Array.AsReadOnly(l_verts2) : null,
Normals2 = l_norms2 != null?Array.AsReadOnly(l_norms2) : null
};
yield return(m3d);
}
}
