private static void test01(string filename)
//****************************************************************************80
//
// Purpose:
//
// TEST01 tests OBJ_SIZE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 31 March 2011
//
// Author:
//
// John Burkardt
//
{
int face_num = 0;
int node_num = 0;
int normal_num = 0;
int order_max = 0;
Console.WriteLine("");
Console.WriteLine("TEST01");
Console.WriteLine(" OBJ_SIZE determines the size of various objects");
Console.WriteLine(" in an OBJ file.");
WavefrontOBJ.obj_size(filename, ref node_num, ref face_num, ref normal_num, ref order_max);
WavefrontOBJ.obj_size_print(filename, node_num, face_num, normal_num, order_max);
}
private bool importMD5ModelMeshes(MD5Model md5)
{
model = new WavefrontOBJ();
md5.addToSimpleStaticMeshBuilder(model);
recreateGPUBuffers();
UpdateDirectXDisplay();
return(false);
}
public void importMapFile(MapFile map)
{
WavefrontOBJ newObj = new WavefrontOBJ();
ConvexVolumeArrayToWaveFrontObjIterator converter = new ConvexVolumeArrayToWaveFrontObjIterator(newObj);
map.iterateBrushes(converter);
this.model = newObj;
recreateGPUBuffers();
UpdateDirectXDisplay();
}
private void loadModel(string name)
{
model = new WavefrontOBJ();
if (model.loadObjModel(name))
{
model = null;
}
recreateGPUBuffers();
UpdateDirectXDisplay();
}
private void exportObjFile(string fileName)
{
if (md5model == null)
{
return;
}
WavefrontOBJ obj = new WavefrontOBJ();
md5model.addToSimpleStaticMeshBuilder(obj);
obj.saveObjModel(fileName);
}
private void exportObjFile(string fileName)
{
if (map == null)
{
return;
}
WavefrontOBJ obj = new WavefrontOBJ();
ConvexVolumeArrayToWaveFrontObjIterator converter = new ConvexVolumeArrayToWaveFrontObjIterator(obj);
map.iterateBrushes(converter);
obj.saveObjModel(fileName);
}
private static void test02(string input_file_name)
//****************************************************************************80
//
// Purpose:
//
// TEST02 tests OBJ_READ.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 31 March 2011
//
// Author:
//
// John Burkardt
//
{
int face_num = 0;
int node_num = 0;
int normal_num = 0;
int order_max = 0;
Console.WriteLine("");
Console.WriteLine("TEST02");
Console.WriteLine(" OBJ_READ reads an object in an OBJ file.");
WavefrontOBJ.obj_size(input_file_name, ref node_num, ref face_num, ref normal_num, ref order_max);
int[] face_node = new int[order_max * face_num];
int[] face_order = new int[face_num];
double[] node_xyz = new double[3 * node_num];
double[] normal_vector = new double[3 * normal_num];
//obj_read ( input_file_name, node_num, face_num, normal_num,
// order_max, node_xyz, face_order, face_node, normal_vector, vertex_normal );
WavefrontOBJ.obj_face_node_print(face_num, order_max, face_order, face_node);
WavefrontOBJ.obj_normal_vector_print(normal_num, normal_vector);
WavefrontOBJ.obj_node_xyz_print(node_num, node_xyz);
}
private bool importMD3Model(string md3FileName)
{
MD3Model md3 = new MD3Model();
if (md3.loadMD3Model(md3FileName))
{
return(true);
}
if (md3.getNumSurfaces() == 0)
{
MessageBox.Show("MD3 model you tried to import has no surfaces.",
"MD3 model has 0 surfaces.",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation,
MessageBoxDefaultButton.Button1);
return(true);
}
model = new WavefrontOBJ();
md3.addToSimpleStaticMeshBuilder(0, model);
recreateGPUBuffers();
UpdateDirectXDisplay();
return(false);
}
private static void test03(string output_filename)
//****************************************************************************80
//
// Purpose:
//
// TEST03 tests OBJ_WRITE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 26 January 2011
//
// Author:
//
// John Burkardt
//
{
int[] face_node =
{
1, 3, 2,
2, 3, 4,
1, 6, 5,
1, 2, 6,
3, 7, 4,
4, 7, 8,
5, 6, 8,
5, 8, 7,
1, 5, 7,
1, 7, 3,
2, 4, 6,
6, 4, 8
};
const int face_num = 12;
int[] face_order =
{
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
};
const int node_num = 8;
double[] node_xyz =
{
0.0, 0.0, 0.0,
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
1.0, 1.0, 0.0,
0.0, 0.0, 1.0,
1.0, 0.0, 1.0,
0.0, 1.0, 1.0,
1.0, 1.0, 1.0
};
const int normal_num = 6;
double[] normal_vector =
{
0.0, 0.0, 1.0,
0.0, 0.0, -1.0,
0.0, 1.0, 0.0,
0.0, -1.0, 0.0,
1.0, 0.0, 0.0,
-1.0, 0.0, 0.0
};
const int order_max = 3;
int[] vertex_normal =
{
2, 2, 2,
2, 2, 2,
4, 4, 4,
4, 4, 4,
3, 3, 3,
3, 3, 3,
1, 1, 1,
1, 1, 1,
6, 6, 6,
6, 6, 6,
5, 5, 5,
5, 5, 5
};
Console.WriteLine("");
Console.WriteLine("TEST03");
Console.WriteLine(" OBJ_WRITE writes an ASCII OBJ file.");
WavefrontOBJ.obj_write(output_filename, node_num, face_num, normal_num,
order_max, node_xyz, face_order, face_node, normal_vector, vertex_normal);
Console.WriteLine("");
Console.WriteLine(" Graphics data was written to the OBJ file \""
+ output_filename + "\".");
}
private void loadModel(string fileName)
{
treeView1.Nodes.Clear();
m = new WavefrontOBJ();
m.loadObjModel(fileName);
TreeNode nodeObjects = new TreeNode("Objects (" + m.getNumObjects() + ")");
for (int i = 0; i < m.getNumObjects(); i++)
{
ObjObject o = m.getObject(i);
TreeNode nodeObject = new TreeNode("Object " + i + " - \"" + o.getName() + "\"");
// object name
TreeNode nodeObjectName = new TreeNode("Name");
TreeNode nodeObjectNameValue = new TreeNode(o.getName());
nodeObjectNameValue.Tag = o;
nodeObjectName.Nodes.Add(nodeObjectNameValue);
nodeObject.Nodes.Add(nodeObjectName);
// first face
TreeNode nodeObjectFirstFace = new TreeNode("First face");
TreeNode nodeObjectFirstFaceValue = new TreeNode(o.getFirstFace().ToString());
nodeObjectFirstFace.Nodes.Add(nodeObjectFirstFaceValue);
nodeObject.Nodes.Add(nodeObjectFirstFace);
// face count
TreeNode nodeObjectNumFaces = new TreeNode("Faces count");
TreeNode nodeObjectNumFacesValue = new TreeNode(o.getNumFaces().ToString());
nodeObjectNumFaces.Nodes.Add(nodeObjectNumFacesValue);
nodeObject.Nodes.Add(nodeObjectNumFaces);
nodeObjects.Nodes.Add(nodeObject);
}
treeView1.Nodes.Add(nodeObjects);
TreeNode nodeGroups = new TreeNode("Groups (" + m.getNumGroups() + ")");
for (int i = 0; i < m.getNumGroups(); i++)
{
ObjGroup o = m.getGroup(i);
TreeNode nodeGroup = new TreeNode("Group " + i + " - \"" + o.getName() + "\"");
// object name
TreeNode nodeGroupName = new TreeNode("Name");
TreeNode nodeGroupNameValue = new TreeNode(o.getName());
nodeGroupNameValue.Tag = o;
nodeGroupName.Nodes.Add(nodeGroupNameValue);
nodeGroup.Nodes.Add(nodeGroupName);
// first face
TreeNode nodeGroupFirstFace = new TreeNode("First face");
TreeNode nodeGroupFirstFaceValue = new TreeNode(o.getFirstFace().ToString());
nodeGroupFirstFace.Nodes.Add(nodeGroupFirstFaceValue);
nodeGroup.Nodes.Add(nodeGroupFirstFace);
// face count
TreeNode nodeGroupNumFaces = new TreeNode("Faces count");
TreeNode nodeGroupNumFacesValue = new TreeNode(o.getNumFaces().ToString());
nodeGroupNumFaces.Nodes.Add(nodeGroupNumFacesValue);
nodeGroup.Nodes.Add(nodeGroupNumFaces);
nodeGroups.Nodes.Add(nodeGroup);
}
treeView1.Nodes.Add(nodeGroups);
TreeNode nodeFaces = new TreeNode("Faces (" + m.getNumFaces() + ")");
for (int i = 0; i < m.getNumFaces(); i++)
{
ObjFace f = m.getFace(i);
TreeNode nodeFace = new TreeNode("Face " + i);
// number of vertices
/*TreeNode nodeFaceNumFaceVerts = new TreeNode("FaceVerts count");
* TreeNode nodeFaceNumFaceVertsValue = new TreeNode(f.getNumVerts().ToString());
* nodeFaceNumFaceVerts.Nodes.Add(nodeFaceNumFaceVertsValue);
* nodeFace.Nodes.Add(nodeFaceNumFaceVerts);*/
// vertices
TreeNode nodeFaceFaceVerts = new TreeNode("FaceVerts (" + f.getNumVerts() + ")");
for (int j = 0; j < f.getNumVerts(); j++)
{
TreeNode nodeFaceFaceVert = new TreeNode("FaceVert " + j + " (abs " + (j + f.getFirstVert()) + ")");
nodeFaceFaceVerts.Nodes.Add(nodeFaceFaceVert);
}
nodeFace.Nodes.Add(nodeFaceFaceVerts);
nodeFaces.Nodes.Add(nodeFace);
}
treeView1.Nodes.Add(nodeFaces);
TreeNode nodePositions = new TreeNode("XYZs (" + m.getNumXYZs() + ")");
for (int i = 0; i < m.getNumXYZs(); i++)
{
TreeNode nodePosition = new TreeNode("XYZ " + i);
TreeNode nodePositionValue = new TreeNode(m.getXYZ(i).ToString());
nodePosition.Nodes.Add(nodePositionValue);
nodePositions.Nodes.Add(nodePosition);
}
treeView1.Nodes.Add(nodePositions);
if (m.getNumTexCoords() > 0)
{
TreeNode nodeTexCoords = new TreeNode("TexCoords (" + m.getNumTexCoords() + ")");
for (int i = 0; i < m.getNumTexCoords(); i++)
{
TreeNode nodeTexCoord = new TreeNode("TexCoord " + i);
TreeNode nodeTexCoordValue = new TreeNode(m.getTexCoord(i).ToString());
nodeTexCoord.Nodes.Add(nodeTexCoordValue);
nodeTexCoords.Nodes.Add(nodeTexCoord);
}
treeView1.Nodes.Add(nodeTexCoords);
}
;
if (m.getNumNormals() > 0)
{
TreeNode nodeNormals = new TreeNode("Normals (" + m.getNumNormals() + ")");
for (int i = 0; i < m.getNumNormals(); i++)
{
TreeNode nodeNormal = new TreeNode("Normal " + i);
TreeNode nodeNormalValue = new TreeNode(m.getNormal(i).ToString());
nodeNormal.Nodes.Add(nodeNormalValue);
nodeNormals.Nodes.Add(nodeNormal);
}
treeView1.Nodes.Add(nodeNormals);
}
}
public ConvexVolumeArrayToWaveFrontObjIterator(WavefrontOBJ obj)
{
this.obj = obj;
bMergeBrushPolygonVertices = true;
}
