public static Lib3dsMeshInstanceNode lib3ds_node_new_mesh_instance(Lib3dsMesh mesh, string instance_name, float[] pos0, float[] scl0, float[] rot0)
{
Lib3dsNode node = lib3ds_node_new(Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE);
if (mesh != null)
{
node.name = mesh.name;
}
else
{
node.name = "$$$DUMMY";
}
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
if (instance_name != null)
{
n.instance_name = instance_name;
}
else
{
n.instance_name = "";
}
lib3ds_track_resize(n.pos_track, 1);
if (pos0 != null)
{
lib3ds_vector_copy(n.pos_track.keys[0].value, pos0);
}
lib3ds_track_resize(n.scl_track, 1);
if (scl0 != null)
{
lib3ds_vector_copy(n.scl_track.keys[0].value, scl0);
}
else
{
lib3ds_vector_make(n.scl_track.keys[0].value, 1, 1, 1);
}
lib3ds_track_resize(n.rot_track, 1);
if (rot0 != null)
{
for (int i = 0; i < 4; i++)
{
n.rot_track.keys[0].value[i] = rot0[i];
}
}
else
{
for (int i = 0; i < 4; i++)
{
n.rot_track.keys[0].value[i] = 0;
}
}
return(n);
}
public static Lib3dsMesh lib3ds_file_mesh_for_node(Lib3dsFile file, Lib3dsNode node)
{
if (node.type != Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
return(null);
}
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
int index = lib3ds_file_mesh_by_name(file, node.name);
return((index >= 0)?file.meshes[index]:null);
}
public static void AddMeshTo3DS(Lib3dsFile res, PSKFile f, Matrix m)
{
Lib3dsMesh mesh = new Lib3dsMesh();
string name = "Box00" + res.meshes.Count.ToString();
mesh.name = name;
mesh.matrix = Matrix2FA(Matrix.Identity);
mesh.vertices = new List<Lib3dsVertex>();
foreach (PSKFile.PSKPoint p in f.psk.points)
{
Vector3 v = p.ToVector3();
v = Vector3.TransformCoordinate(v, m);
mesh.vertices.Add(new Lib3dsVertex(v.X, -v.Y, v.Z));
}
mesh.texcos = new List<Lib3dsTexturecoordinate>();
for (int i = 0; i < f.psk.points.Count; i++)
foreach (PSKFile.PSKEdge e in f.psk.edges)
if (e.index == i)
mesh.texcos.Add(new Lib3dsTexturecoordinate(e.U, e.V));
mesh.faces = new List<Lib3dsFace>();
foreach (PSKFile.PSKFace face in f.psk.faces)
{
Lib3dsFace ff = new Lib3dsFace();
ff.flags = 6;
ff.index = new ushort[3];
ff.index[0] = (ushort)f.psk.edges[face.v0].index;
ff.index[1] = (ushort)f.psk.edges[face.v2].index;
ff.index[2] = (ushort)f.psk.edges[face.v1].index;
mesh.faces.Add(ff);
}
mesh.nfaces = (ushort)mesh.faces.Count;
mesh.nvertices = (ushort)mesh.vertices.Count;
mesh.map_type = Lib3dsMapType.LIB3DS_MAP_NONE;
mesh.object_flags = 0;
mesh.color = 128;
res.meshes.Add(mesh);
Lib3dsNode node = new Lib3dsMeshInstanceNode();
node.matrixNode = Matrix2FA(Matrix.Identity);
node.parent = null;
node.parent_id = 0xffff;
node.hasNodeID = true;
node.type = Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE;
node.flags = res.nodes[0].flags;
node.node_id = (ushort)(res.meshes.Count() - 1);
node.name = name;
res.nodes.Add(node);
}
// Create and return a new node object.
//
// The node is returned with an identity matrix. All other fields
// are zero.
//
// \return Lib3dsNode
public static Lib3dsNode lib3ds_node_new(Lib3dsNodeType type)
{
Lib3dsNode node=null;
switch(type)
{
case Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR:
{
Lib3dsAmbientColorNode n=new Lib3dsAmbientColorNode();
node=n;
node.name="$AMBIENT$";
n.color_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE:
{
Lib3dsMeshInstanceNode n=new Lib3dsMeshInstanceNode();
node=n;
node.name="$$$DUMMY";
n.pos_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.scl_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.rot_track.type=Lib3dsTrackType.LIB3DS_TRACK_QUAT;
n.hide_track.type=Lib3dsTrackType.LIB3DS_TRACK_BOOL;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
{
Lib3dsCameraNode n=new Lib3dsCameraNode();
node=n;
n.pos_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.fov_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
n.roll_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET:
{
Lib3dsTargetNode n=new Lib3dsTargetNode();
node=n;
n.pos_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
{
Lib3dsOmnilightNode n=new Lib3dsOmnilightNode();
node=n;
n.pos_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.color_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n=new Lib3dsSpotlightNode();
node=n;
n.pos_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.color_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.hotspot_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
n.falloff_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
n.roll_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET:
{
Lib3dsTargetNode n=new Lib3dsTargetNode();
node=n;
n.pos_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
break;
}
default: Debug.Assert(false); return null;
}
node.type=type;
node.node_id=65535;
node.parent_id=65535;
lib3ds_matrix_identity(node.matrixNode);
return node;
}
public static void lib3ds_node_write(Lib3dsNode node, ushort node_id, ushort parent_id, Lib3dsIo io)
{
Lib3dsChunk c_node = new Lib3dsChunk();
switch (node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR: c_node.chunk = Lib3dsChunks.CHK_AMBIENT_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE: c_node.chunk = Lib3dsChunks.CHK_OBJECT_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA: c_node.chunk = Lib3dsChunks.CHK_CAMERA_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET: c_node.chunk = Lib3dsChunks.CHK_TARGET_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT: c_node.chunk = Lib3dsChunks.CHK_LIGHT_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT: c_node.chunk = Lib3dsChunks.CHK_SPOTLIGHT_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET: c_node.chunk = Lib3dsChunks.CHK_L_TARGET_NODE_TAG; break;
default: Debug.Assert(false); return;
}
lib3ds_chunk_write_start(c_node, io);
{ // ---- CHK_NODE_ID ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_NODE_ID;
c.size = 8;
lib3ds_chunk_write(c, io);
lib3ds_io_write_word(io, node_id);
}
{ // ---- CHK_NODE_HDR ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_NODE_HDR;
c.size = 6 + 1 + (uint)node.name.Length + 2 + 2 + 2;
lib3ds_chunk_write(c, io);
lib3ds_io_write_string(io, node.name);
lib3ds_io_write_dword(io, node.flags);
lib3ds_io_write_word(io, parent_id);
}
switch (c_node.chunk)
{
case Lib3dsChunks.CHK_AMBIENT_NODE_TAG:
{
Lib3dsAmbientColorNode n = (Lib3dsAmbientColorNode)node;
if (n.color_track.keys.Count != 0)
{ // ---- CHK_COL_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_COL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.color_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_OBJECT_NODE_TAG:
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
{ // ---- CHK_PIVOT ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_PIVOT;
c.size = 18;
lib3ds_chunk_write(c, io);
lib3ds_io_write_vector(io, n.pivot);
}
if (n.instance_name.Length != 0)
{ // ---- CHK_INSTANCE_NAME ----
string name = n.instance_name;
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_INSTANCE_NAME;
c.size = 6 + 1 + (uint)name.Length;
lib3ds_chunk_write(c, io);
lib3ds_io_write_string(io, name);
}
{
int i = 0;
for (i = 0; i < 3; i++)
{
if (Math.Abs(n.bbox_min[i]) > EPSILON || Math.Abs(n.bbox_max[i]) > EPSILON)
{
break;
}
}
if (i < 3)
{ // ---- CHK_BOUNDBOX ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_BOUNDBOX;
c.size = 30;
lib3ds_chunk_write(c, io);
lib3ds_io_write_vector(io, n.bbox_min);
lib3ds_io_write_vector(io, n.bbox_max);
}
}
if (n.pos_track.keys.Count != 0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.rot_track.keys.Count != 0)
{ // ---- CHK_ROT_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_ROT_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.rot_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.scl_track.keys.Count != 0)
{ // ---- LIB3DS_SCL_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_SCL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.scl_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.hide_track.keys.Count != 0)
{ // ---- CHK_HIDE_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_HIDE_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.hide_track, io);
lib3ds_chunk_write_end(c, io);
}
if (Math.Abs(n.morph_smooth) > EPSILON)
{ // ---- CHK_MORPH_SMOOTH ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_MORPH_SMOOTH;
c.size = 10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_float(io, n.morph_smooth);
}
}
break;
case Lib3dsChunks.CHK_CAMERA_NODE_TAG:
{
Lib3dsCameraNode n = (Lib3dsCameraNode)node;
if (n.pos_track.keys.Count != 0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.fov_track.keys.Count != 0)
{ // ---- CHK_FOV_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_FOV_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.fov_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.roll_track.keys.Count != 0)
{ // ---- CHK_ROLL_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_ROLL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.roll_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_TARGET_NODE_TAG:
{
Lib3dsTargetNode n = (Lib3dsTargetNode)node;
if (n.pos_track.keys.Count != 0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_LIGHT_NODE_TAG:
{
Lib3dsOmnilightNode n = (Lib3dsOmnilightNode)node;
if (n.pos_track.keys.Count != 0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.color_track.keys.Count != 0)
{ // ---- CHK_COL_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_COL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.color_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_SPOTLIGHT_NODE_TAG:
{
Lib3dsSpotlightNode n = (Lib3dsSpotlightNode)node;
if (n.pos_track.keys.Count != 0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.color_track.keys.Count != 0)
{ // ---- CHK_COL_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_COL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.color_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.hotspot_track.keys.Count != 0)
{ // ---- CHK_HOT_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_HOT_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.hotspot_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.falloff_track.keys.Count != 0)
{ // ---- CHK_FALL_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_FALL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.falloff_track, io);
lib3ds_chunk_write_end(c, io);
}
if (n.roll_track.keys.Count != 0)
{ // ---- CHK_ROLL_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_ROLL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.roll_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_L_TARGET_NODE_TAG:
{
Lib3dsTargetNode n = (Lib3dsTargetNode)node;
if (n.pos_track.keys.Count != 0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
}
lib3ds_chunk_write_end(c_node, io);
}
public static void lib3ds_node_read(Lib3dsNode node, Lib3dsIo io)
{
Lib3dsChunk c = new Lib3dsChunk();
Lib3dsChunks chunk;
Debug.Assert(node != null);
lib3ds_chunk_read_start(c, 0, io);
switch (c.chunk)
{
case Lib3dsChunks.CHK_AMBIENT_NODE_TAG:
case Lib3dsChunks.CHK_OBJECT_NODE_TAG:
case Lib3dsChunks.CHK_CAMERA_NODE_TAG:
case Lib3dsChunks.CHK_TARGET_NODE_TAG:
case Lib3dsChunks.CHK_LIGHT_NODE_TAG:
case Lib3dsChunks.CHK_SPOTLIGHT_NODE_TAG:
case Lib3dsChunks.CHK_L_TARGET_NODE_TAG: break;
default: return;
}
while ((chunk = lib3ds_chunk_read_next(c, io)) != 0)
{
switch (chunk)
{
case Lib3dsChunks.CHK_NODE_ID:
node.node_id = lib3ds_io_read_word(io);
node.hasNodeID = true;
lib3ds_io_log_indent(io, 1);
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "ID={0}", node.node_id);
lib3ds_io_log_indent(io, -1);
break;
case Lib3dsChunks.CHK_NODE_HDR:
node.name = lib3ds_io_read_string(io, 64);
node.flags = lib3ds_io_read_dword(io);
node.parent_id = lib3ds_io_read_word(io);
lib3ds_io_log_indent(io, 1);
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "NAME={0}", node.name);
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "PARENT={0}", (short)node.parent_id);
lib3ds_io_log_indent(io, -1);
break;
case Lib3dsChunks.CHK_PIVOT:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
lib3ds_io_read_vector(io, n.pivot);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_INSTANCE_NAME:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
n.instance_name = lib3ds_io_read_string(io, 64);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_BOUNDBOX:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
lib3ds_io_read_vector(io, n.bbox_min);
lib3ds_io_read_vector(io, n.bbox_max);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_COL_TRACK_TAG:
{
Lib3dsTrack track = null;
switch (node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR:
{
Lib3dsAmbientColorNode n = (Lib3dsAmbientColorNode)node;
track = n.color_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
{
Lib3dsOmnilightNode n = (Lib3dsOmnilightNode)node;
track = n.color_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n = (Lib3dsSpotlightNode)node;
track = n.color_track;
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
if (track != null)
{
lib3ds_track_read(track, io);
}
}
break;
case Lib3dsChunks.CHK_POS_TRACK_TAG:
{
Lib3dsTrack track = null;
switch (node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE:
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
track = n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
{
Lib3dsCameraNode n = (Lib3dsCameraNode)node;
track = n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET:
{
Lib3dsTargetNode n = (Lib3dsTargetNode)node;
track = n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
{
Lib3dsOmnilightNode n = (Lib3dsOmnilightNode)node;
track = n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n = (Lib3dsSpotlightNode)node;
track = n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET:
{
Lib3dsTargetNode n = (Lib3dsTargetNode)node;
track = n.pos_track;
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
if (track != null)
{
lib3ds_track_read(track, io);
}
}
break;
case Lib3dsChunks.CHK_ROT_TRACK_TAG:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
n.rot_track.type = Lib3dsTrackType.LIB3DS_TRACK_QUAT;
lib3ds_track_read(n.rot_track, io);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_SCL_TRACK_TAG:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
n.scl_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
lib3ds_track_read(n.scl_track, io);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_FOV_TRACK_TAG:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_CAMERA)
{
Lib3dsCameraNode n = (Lib3dsCameraNode)node;
n.fov_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.fov_track, io);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_HOT_TRACK_TAG:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT)
{
Lib3dsSpotlightNode n = (Lib3dsSpotlightNode)node;
n.hotspot_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.hotspot_track, io);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_FALL_TRACK_TAG:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT)
{
Lib3dsSpotlightNode n = (Lib3dsSpotlightNode)node;
n.falloff_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.falloff_track, io);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_ROLL_TRACK_TAG:
switch (node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
{
Lib3dsCameraNode n = (Lib3dsCameraNode)node;
n.roll_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.roll_track, io);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n = (Lib3dsSpotlightNode)node;
n.roll_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.roll_track, io);
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
break;
case Lib3dsChunks.CHK_HIDE_TRACK_TAG:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
n.hide_track.type = Lib3dsTrackType.LIB3DS_TRACK_BOOL;
lib3ds_track_read(n.hide_track, io);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
case Lib3dsChunks.CHK_MORPH_SMOOTH:
if (node.type == Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
n.morph_smooth = lib3ds_io_read_float(io);
}
else
{
lib3ds_chunk_unknown(chunk, io);
}
break;
//case Lib3dsChunks.LIB3DS_MORPH_TRACK_TAG:
// if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
// {
// Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
// n.morph_track=lib3ds_track_new(node, LIB3DS_TRACK_MORPH, 0);
// lib3ds_track_read(n.morph_track, io);
// }
// else lib3ds_chunk_unknown(chunk, io);
// break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
// Evaluate an animation node.
//
// Recursively sets node and its children to their appropriate values
// for this point in the animation.
//
// \param node Node to be evaluated.
// \param t time value, between 0. and file.frames
public static void lib3ds_node_eval(Lib3dsNode node, float t)
{
Debug.Assert(node != null);
switch (node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR:
{
Lib3dsAmbientColorNode n = (Lib3dsAmbientColorNode)node;
if (node.parent != null)
{
lib3ds_matrix_copy(node.matrixNode, node.parent.matrixNode);
}
else
{
lib3ds_matrix_identity(node.matrixNode);
}
lib3ds_track_eval_vector(n.color_track, n.color, t);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE:
{
float[,] M = new float[4, 4];
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
lib3ds_track_eval_vector(n.pos_track, n.pos, t);
lib3ds_track_eval_quat(n.rot_track, n.rot, t);
if (n.scl_track.keys.Count != 0)
{
lib3ds_track_eval_vector(n.scl_track, n.scl, t);
}
else
{
n.scl[0] = n.scl[1] = n.scl[2] = 1.0f;
}
lib3ds_track_eval_bool(n.hide_track, out n.hide, t);
lib3ds_matrix_identity(M);
lib3ds_matrix_translate(M, n.pos[0], n.pos[1], n.pos[2]);
lib3ds_matrix_rotate_quat(M, n.rot);
lib3ds_matrix_scale(M, n.scl[0], n.scl[1], n.scl[2]);
if (node.parent != null)
{
lib3ds_matrix_mult(node.matrixNode, node.parent.matrixNode, M);
}
else
{
lib3ds_matrix_copy(node.matrixNode, M);
}
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
{
Lib3dsCameraNode n = (Lib3dsCameraNode)node;
lib3ds_track_eval_vector(n.pos_track, n.pos, t);
lib3ds_track_eval_float(n.fov_track, out n.fov, t);
lib3ds_track_eval_float(n.roll_track, out n.roll, t);
if (node.parent != null)
{
lib3ds_matrix_copy(node.matrixNode, node.parent.matrixNode);
}
else
{
lib3ds_matrix_identity(node.matrixNode);
}
lib3ds_matrix_translate(node.matrixNode, n.pos[0], n.pos[1], n.pos[2]);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET:
{
Lib3dsTargetNode n = (Lib3dsTargetNode)node;
lib3ds_track_eval_vector(n.pos_track, n.pos, t);
if (node.parent != null)
{
lib3ds_matrix_copy(node.matrixNode, node.parent.matrixNode);
}
else
{
lib3ds_matrix_identity(node.matrixNode);
}
lib3ds_matrix_translate(node.matrixNode, n.pos[0], n.pos[1], n.pos[2]);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
{
Lib3dsOmnilightNode n = (Lib3dsOmnilightNode)node;
lib3ds_track_eval_vector(n.pos_track, n.pos, t);
lib3ds_track_eval_vector(n.color_track, n.color, t);
if (node.parent != null)
{
lib3ds_matrix_copy(node.matrixNode, node.parent.matrixNode);
}
else
{
lib3ds_matrix_identity(node.matrixNode);
}
lib3ds_matrix_translate(node.matrixNode, n.pos[0], n.pos[1], n.pos[2]);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n = (Lib3dsSpotlightNode)node;
lib3ds_track_eval_vector(n.pos_track, n.pos, t);
lib3ds_track_eval_vector(n.color_track, n.color, t);
lib3ds_track_eval_float(n.hotspot_track, out n.hotspot, t);
lib3ds_track_eval_float(n.falloff_track, out n.falloff, t);
lib3ds_track_eval_float(n.roll_track, out n.roll, t);
if (node.parent != null)
{
lib3ds_matrix_copy(node.matrixNode, node.parent.matrixNode);
}
else
{
lib3ds_matrix_identity(node.matrixNode);
}
lib3ds_matrix_translate(node.matrixNode, n.pos[0], n.pos[1], n.pos[2]);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET:
{
Lib3dsTargetNode n = (Lib3dsTargetNode)node;
lib3ds_track_eval_vector(n.pos_track, n.pos, t);
if (node.parent != null)
{
lib3ds_matrix_copy(node.matrixNode, node.parent.matrixNode);
}
else
{
lib3ds_matrix_identity(node.matrixNode);
}
lib3ds_matrix_translate(node.matrixNode, n.pos[0], n.pos[1], n.pos[2]);
}
break;
}
foreach (Lib3dsNode p in node.childs)
{
lib3ds_node_eval(p, t);
}
}
static void free_node_and_childs(Lib3dsNode node)
{
Debug.Assert(node != null);
switch (node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR:
{
Lib3dsAmbientColorNode n = (Lib3dsAmbientColorNode)node;
lib3ds_track_resize(n.color_track, 0);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE:
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
lib3ds_track_resize(n.pos_track, 0);
lib3ds_track_resize(n.rot_track, 0);
lib3ds_track_resize(n.scl_track, 0);
lib3ds_track_resize(n.hide_track, 0);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
{
Lib3dsCameraNode n = (Lib3dsCameraNode)node;
lib3ds_track_resize(n.pos_track, 0);
lib3ds_track_resize(n.fov_track, 0);
lib3ds_track_resize(n.roll_track, 0);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET:
{
Lib3dsTargetNode n = (Lib3dsTargetNode)node;
lib3ds_track_resize(n.pos_track, 0);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
{
Lib3dsOmnilightNode n = (Lib3dsOmnilightNode)node;
lib3ds_track_resize(n.pos_track, 0);
lib3ds_track_resize(n.color_track, 0);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n = (Lib3dsSpotlightNode)node;
lib3ds_track_resize(n.pos_track, 0);
lib3ds_track_resize(n.color_track, 0);
lib3ds_track_resize(n.hotspot_track, 0);
lib3ds_track_resize(n.falloff_track, 0);
lib3ds_track_resize(n.roll_track, 0);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET:
{
Lib3dsTargetNode n = (Lib3dsTargetNode)node;
lib3ds_track_resize(n.pos_track, 0);
}
break;
}
foreach (Lib3dsNode p in node.childs)
{
free_node_and_childs(p);
}
node.childs.Clear();
}
// Create and return a new node object.
//
// The node is returned with an identity matrix. All other fields
// are zero.
//
// \return Lib3dsNode
public static Lib3dsNode lib3ds_node_new(Lib3dsNodeType type)
{
Lib3dsNode node = null;
switch (type)
{
case Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR:
{
Lib3dsAmbientColorNode n = new Lib3dsAmbientColorNode();
node = n;
node.name = "$AMBIENT$";
n.color_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE:
{
Lib3dsMeshInstanceNode n = new Lib3dsMeshInstanceNode();
node = n;
node.name = "$$$DUMMY";
n.pos_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.scl_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.rot_track.type = Lib3dsTrackType.LIB3DS_TRACK_QUAT;
n.hide_track.type = Lib3dsTrackType.LIB3DS_TRACK_BOOL;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
{
Lib3dsCameraNode n = new Lib3dsCameraNode();
node = n;
n.pos_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.fov_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
n.roll_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET:
{
Lib3dsTargetNode n = new Lib3dsTargetNode();
node = n;
n.pos_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
{
Lib3dsOmnilightNode n = new Lib3dsOmnilightNode();
node = n;
n.pos_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.color_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n = new Lib3dsSpotlightNode();
node = n;
n.pos_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.color_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
n.hotspot_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
n.falloff_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
n.roll_track.type = Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
break;
}
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET:
{
Lib3dsTargetNode n = new Lib3dsTargetNode();
node = n;
n.pos_track.type = Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
break;
}
default: Debug.Assert(false); return(null);
}
node.type = type;
node.node_id = 65535;
node.parent_id = 65535;
lib3ds_matrix_identity(node.matrixNode);
return(node);
}
/// <summary>
/// Insert a new child into this object.
/// </summary>
/// <param name="newObj">New child</param>
public void AddNewChild(Lib3dsMeshInstanceNode newObj)
{
string[] newObjectLoca = null;
// Return if location info is illegal
if ((newObjectLoca = GetLocation(newObj.name)) == null)
return;
switch (this.Type)
{
case BuildingObjectType.Building:
if (this.Childs.Contains(newObjectLoca[0]) == false)
{
BuildingObjectType childType;
if (newObjectLoca[0] == "0")
{
childType = BuildingObjectType.Outside;
}
else
{
childType = BuildingObjectType.Floor;
}
BuildingObjectLib3DS bObj = new BuildingObjectLib3DS(this, childType,
(uint)System.Convert.ToInt32(newObjectLoca[0]), Model, Textures);
this.Childs.Add(newObjectLoca[0], bObj);
bObj.AddNewChild(newObj);
}
else
{
(this.Childs[(newObjectLoca[0])] as BuildingObjectLib3DS).AddNewChild(newObj);
}
break;
case BuildingObjectType.Floor:
if (this.Childs.Contains(newObjectLoca[1]) == false)
{
BuildingObjectLib3DS bObj = new BuildingObjectLib3DS(this, BuildingObjectType.Room,
(uint)System.Convert.ToInt32(newObjectLoca[1]), Model, Textures);
this.Childs.Add(newObjectLoca[1], bObj);
bObj.AddNewChild(newObj);
}
else
{
(this.Childs[(newObjectLoca[1])] as BuildingObjectLib3DS).AddNewChild(newObj);
}
break;
case BuildingObjectType.Room:
if (this.Childs.Contains(newObjectLoca[2]) == false)
{
BuildingObjectLib3DS bObj = new BuildingObjectLib3DS(this, BuildingObjectType.Object,
(uint)System.Convert.ToInt32(newObjectLoca[2]), Model, Textures);
this.Childs.Add(newObjectLoca[2], bObj);
bObj.AddNewChild(newObj);
}
else
{
// Same Name... ??? Do not insert it...
}
break;
case BuildingObjectType.Outside:
case BuildingObjectType.Object:
this.Object = newObj;
//if (this.Object.childs.Count == 0)
//{
// Lib3dsMesh ThisMesh = FindLib3dsMeshByName(this.Object.name, this.Model.meshes);
// if (ThisMesh != null)
// {
// this.Normalizes = new Lib3dsVertex[1][];
// this.Normalizes[0] = new Lib3dsVertex[ThisMesh.faces.Count];
// for (int i = 0; i < ThisMesh.faces.Count; i++)
// {
// Lib3dsFace face = ThisMesh.faces[i];
// Lib3dsVertex Point1 = ThisMesh.vertices[face.index[0]];
// Lib3dsVertex Point2 = ThisMesh.vertices[face.index[1]];
// Lib3dsVertex Point3 = ThisMesh.vertices[face.index[2]];
// this.Normalizes[0][i] = CreateNormalize(Point1, Point2, Point3);
// }
// }
//}
//else
//{
// this.Normalizes = new Lib3dsVertex[newObj.childs.Count][];
// int cnt = 0;
// foreach (Lib3dsNode node in newObj.childs)
// {
// Lib3dsMesh ThisMesh = FindLib3dsMeshByName(node.name, this.Model.meshes);
// if (ThisMesh == null)
// {
// continue;
// }
// this.Normalizes[cnt] = new Lib3dsVertex[ThisMesh.faces.Count];
// for (int i = 0; i < ThisMesh.faces.Count; i++)
// {
// Lib3dsFace face = ThisMesh.faces[i];
// Lib3dsVertex Point1 = ThisMesh.vertices[face.index[0]];
// Lib3dsVertex Point2 = ThisMesh.vertices[face.index[1]];
// Lib3dsVertex Point3 = ThisMesh.vertices[face.index[2]];
// this.Normalizes[cnt][i] = CreateNormalize(Point1, Point2, Point3);
// }
// cnt++;
// }
//}
break;
default:
break;
}
}
static void file_bounding_box_of_nodes_impl(Lib3dsNode node, Lib3dsFile file, bool include_meshes, bool include_cameras, bool include_lights, float[] bmin, float[] bmax, float[,] matrix)
{
switch (node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE:
if (include_meshes)
{
Lib3dsMeshInstanceNode n = (Lib3dsMeshInstanceNode)node;
int index = lib3ds_file_mesh_by_name(file, n.instance_name);
if (index < 0)
{
index = lib3ds_file_mesh_by_name(file, node.name);
}
if (index >= 0)
{
float[,] inv_matrix = new float[4, 4], M = new float[4, 4];
float[] v = new float[3];
Lib3dsMesh mesh = file.meshes[index];
lib3ds_matrix_copy(inv_matrix, mesh.matrix);
lib3ds_matrix_inv(inv_matrix);
lib3ds_matrix_mult(M, matrix, node.matrixNode);
lib3ds_matrix_translate(M, -n.pivot[0], -n.pivot[1], -n.pivot[2]);
lib3ds_matrix_mult(M, M, inv_matrix);
foreach (Lib3dsVertex vertex in mesh.vertices)
{
lib3ds_vector_transform(v, M, vertex);
lib3ds_vector_min(bmin, v);
lib3ds_vector_max(bmax, v);
}
}
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET:
if (include_cameras)
{
float[] z = new float[3], v = new float[3];
float[,] M = new float[4, 4];
lib3ds_matrix_mult(M, matrix, node.matrixNode);
lib3ds_vector_zero(z);
lib3ds_vector_transform(v, M, z);
lib3ds_vector_min(bmin, v);
lib3ds_vector_max(bmax, v);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET:
if (include_lights)
{
float[] z = new float[3], v = new float[3];
float[,] M = new float[4, 4];
lib3ds_matrix_mult(M, matrix, node.matrixNode);
lib3ds_vector_zero(z);
lib3ds_vector_transform(v, M, z);
lib3ds_vector_min(bmin, v);
lib3ds_vector_max(bmax, v);
}
break;
}
foreach (Lib3dsNode p in node.childs)
{
file_bounding_box_of_nodes_impl(p, file, include_meshes, include_cameras, include_lights, bmin, bmax, matrix);
}
}
static void write_mesh(StreamWriter o, Lib3dsFile f, Lib3dsMeshInstanceNode node)
{
Lib3dsMesh mesh=LIB3DS.lib3ds_file_mesh_for_node(f, node);
if(mesh==null||mesh.vertices==null||mesh.vertices.Count==0) return;
o.WriteLine("# object {0}", node.name);
o.WriteLine("g {0}", node.instance_name!=null&&node.instance_name.Length!=0?node.instance_name:node.name);
List<Lib3dsVertex> orig_vertices=new List<Lib3dsVertex>();
foreach(Lib3dsVertex v in mesh.vertices) orig_vertices.Add(new Lib3dsVertex(v));
float[,] inv_matrix=new float[4, 4], M=new float[4, 4];
float[] tmp=new float[3];
LIB3DS.lib3ds_matrix_copy(M, node.matrixNode);
LIB3DS.lib3ds_matrix_translate(M, -node.pivot[0], -node.pivot[1], -node.pivot[2]);
LIB3DS.lib3ds_matrix_copy(inv_matrix, mesh.matrix);
LIB3DS.lib3ds_matrix_inv(inv_matrix);
LIB3DS.lib3ds_matrix_mult(M, M, inv_matrix);
for(int i=0; i<mesh.nvertices; i++)
{
LIB3DS.lib3ds_vector_transform(tmp, M, mesh.vertices[i]);
LIB3DS.lib3ds_vector_copy(mesh.vertices[i], tmp);
}
bool export_texcos=mesh.texcos!=null;
bool export_normals=mesh.faces!=null;
foreach(Lib3dsVertex v in mesh.vertices) o.WriteLine("v {0} {1} {2}", v.x, v.y, v.z);
o.WriteLine("# {0} vertices", mesh.vertices.Count);
if(export_texcos)
{
foreach(Lib3dsTexturecoordinate vt in mesh.texcos) o.WriteLine("vt {0} {1}", vt.s, vt.t);
o.WriteLine("# {0} texture vertices", mesh.vertices.Count);
}
if(export_normals)
{
float[][] normals=new float[3*mesh.nfaces][];
for(int i=0; i<3*mesh.nfaces; i++) normals[i]=new float[3];
LIB3DS.lib3ds_mesh_calculate_vertex_normals(mesh, normals);
for(int i=0; i<3*mesh.nfaces; i++) o.WriteLine("vn {0} {1} {2}", normals[i][0], normals[i][1], normals[i][2]);
o.WriteLine("# {0} normals", 3*mesh.nfaces);
}
int mat_index=-1;
for(int i=0; i<mesh.nfaces; i++)
{
if(mat_index!=mesh.faces[i].material)
{
mat_index=mesh.faces[i].material;
if(mat_index!=-1) o.WriteLine("usemtl {0}", f.materials[mat_index].name);
}
o.Write("f ");
for(int j=0; j<3; ++j)
{
o.Write("{0}", mesh.faces[i].index[j]+max_vertices+1);
if(export_texcos) o.Write("/{0}", mesh.faces[i].index[j]+max_texcos+1);
else if(export_normals) o.Write("/");
if(export_normals) o.Write("/{0}", 3*i+j+max_normals+1);
if(j<3) o.Write(" ");
}
o.WriteLine();
}
max_vertices+=mesh.nvertices;
if(export_texcos) max_texcos+=mesh.nvertices;
if(export_normals) max_normals+=3*mesh.nfaces;
mesh.vertices=orig_vertices;
}
