Rudimentary dts to obj converter

ConsoleFunction(dumpDTStoObj, void, 3, 3, "(string objfile, string dts)")
{
	Resource<TSShape> shape;
	shape = ResourceManager->load(argv[2]);
	const char * str;
	if(shape.isNull())
		return;
	
	TSShapeInstance *shapeinst = new TSShapeInstance(shape, true);
	if(!shapeinst)
		return;
	
	FileStream stream;
	stream.open(argv[1], FileStream::Write);

	TSShape* mShape = shapeinst->getShape();
	
	Con::printf("Dumping %s to %s", argv[2], argv[1]);
	dumpLine("#obj file rn");
	U32 i;
	/*S32 frameCount = 0;
	for(i = 0; i < mShape->sequences.size(); i++){
		frameCount += mShape->sequences[i].numKeyframes;
	}
	//dumpLine(avar("Frames: %irn", frameCount));
	dumpLine("Frames: 1rn");	//only STATIC meshes for now, kthxbai
	dumpLine("Frame: 1rnrn");
	
	dumpLine(avar("Meshes: %irn", mShape->meshes.size()));*/
	
	// mesh: name, flags, material index
	i = 0; 	//make this loopy eventually
	TSMesh* tsm = mShape->meshes[i];
	
	// number of vertices
	dumpLine(avar("#%irnrn", tsm->verts.size()));
	
	ToolVector<Point2F> uvs;
	tsm->getUVs(TSMesh::tDiffuse, uvs);
	U32 j; // inner loopiness
	for(j = 0; j<tsm->verts.size(); j++){
		Point3F xyz = tsm->verts[j];
		// vertex: flags, x, y, z, u, v, bone index
		dumpLine(avar("v %f %f %frn", xyz.x, xyz.y, xyz.z));
	}
	dumpLine("rn");

	for(j = 0; j<tsm->verts.size(); j++){
		Point2F uv = uvs[j];
		dumpLine(avar("vt %f %frn", uv.x, uv.y));
	}
	dumpLine("rn");
	
	
	// number of normals
	U32 normcount = tsm->getFlags(TSMesh::UseEncodedNormals) ? tsm->encodedNorms.size() : tsm->norms.size();
	dumpLine(avar("#%irnrn", normcount));
	
	const Point3F * norms = tsm->getNormals(0);
	for(j = 0; j<normcount; j++){
		Point3F xyz = norms[j];
		// normal: x, y, z
		dumpLine(avar("vn %f %f %frn", xyz.x, xyz.y, xyz.z));
	}
	
	dumpLine("rn");

	// number of triangles
	U32 tris = 0;
	for(j = 0; j<tsm->primitives.size(); j++)
		tris += tsm->primitives[j].numElements;
		

	dumpLine(avar("# %irnrn",tris));
	
	dumpLine(avar("g Mesh%irnrn",i));
	for(j = 0; j<tsm->primitives.size(); j++){
		TSDrawPrimitive draw = tsm->primitives[j];
		// triangle: flags, vertex index1, vertex index2, vertex index3, normal index1, normal index 2, normal index 3, smoothing group
		if ( (draw.matIndex & TSDrawPrimitive::TypeMask) == TSDrawPrimitive::Triangles)
		{
			for (S32 k=0; k<draw.numElements; )
			{
				U32 idx0 = tsm->indices[draw.start + k + 0];
				U32 idx1 =tsm->indices[draw.start + k + 1];
				U32 idx2 = tsm->indices[draw.start + k + 2];
				dumpLine(avar("f %i/%i/%i %i/%i/%i %i/%i/%irn", (idx0+1), (idx0+1), (idx0+1), (idx1+1), (idx1+1), (idx1+1), (idx2+1), (idx2+1), (idx2+1)));
				
				k += 3;
			}
		} else if((draw.matIndex & TSDrawPrimitive::TypeMask) == TSDrawPrimitive::Strip){
			U32 idx0 = tsm->indices[draw.start + 0];
			U32 idx1;
			U32 idx2 = tsm->indices[draw.start + 1];
			U32 * nextIdx = &idx1;
			for (S32 k=2; k<draw.numElements; k++)
			{
				*nextIdx = idx2;
				nextIdx = (U32*) ( (dsize_t)nextIdx ^ (dsize_t)&idx0 ^ (dsize_t)&idx1);
				idx2 = tsm->indices[draw.start + k];
				if (idx0 == idx1 || idx0 == idx2 || idx1 == idx2)
					Con::printf("Warning, vertex redundancy: %i, %i, %i", idx0, idx1, idx2);
					//continue;
				dumpLine(avar("f %i/%i/%i %i/%i/%i %i/%i/%irn", (idx0+1), (idx0+1), (idx0+1), (idx1+1), (idx1+1), (idx1+1), (idx2+1), (idx2+1), (idx2+1)));
			}
			
		} else{
			dumpLine("# oops--don't really know how to handle thisrn");
		}
	}
	
	dumpLine("rn");
	
	stream.close();
	Con::printf("...dump complete");
}