main.cpp

赫赫大名的 OGRE 游戏引擎

	return 1;
}

int make_destname( char *spec, char *name, char *fullname )
{
	char
		drive[ _MAX_DRIVE ],
		dir[ _MAX_DIR ],
		node[ _MAX_FNAME ],
		ext[ _MAX_EXT ],
		dnode[ _MAX_FNAME ];
	
	_splitpath( name, drive, dir, dnode, ext );
	_splitpath( spec, drive, dir, node, ext );
	_makepath( fullname, drive, dir, dnode, ".mesh" );
	return 1;
}

int make_filespec( char *spec, char *subdir, char *fullname )
{
	char
		name[ _MAX_FNAME ],
		drive[ _MAX_DRIVE ],
		dir[ _MAX_DIR ],
		node[ _MAX_FNAME ],
		ext[ _MAX_EXT ];
	
	_splitpath( spec, drive, dir, node, ext );
	_makepath( name, drive, dir, subdir, NULL );
	_makepath( fullname, NULL, name, node, ext );
	return 1;
}

void help( char *filename )
{
	cout << "lwo2mesh v0.89 (2004.05.09) by Dennis Verbeek." << nl
		<< "Converts a Lightwave object to an Ogre mesh." << nl
		<< "Please send any feedback to: [e-mail]" << nl << nl
		<< "Usage: " << filename << " [options] source [dest]" << nl
		<< "options:" << nl
		<< "-g do not use shared geometry" << nl
		<< "-d generate level of detail information" << nl
		<< "   method (f)ixed or (p)roportional" << nl
		<< "   reduction (fixed) or reductionfactor (proportional)" << nl
		<< "   number of LOD levels" << nl
		<< "   distances" << nl
		<< "   example: -d p 0.5 4 1000.0 2000.0 4000.0 8000.0" << nl
		<< "-l save layers separately" << nl
		<< "-m do not export materials" << nl
		<< "-s do not export skeleton" << nl
		<< "-i info on .lwo only, no conversion to mesh" << nl
		<< "   -v dump vertex maps" << endl;
	exit(0);
}

void info(lwObject *object, char *filename)
{
	unsigned int points = 0;
	unsigned int polygons = 0;

	nlayers += object->layers.size();
	nsurfs += object->surfaces.size();
	nclips += object->clips.size();
	nenvs += object->envelopes.size();

	cout << "File: " << filename << nl
		<< setw(8) << object->layers.size() << " layers" << nl
		<< setw(8) << object->surfaces.size() << " surfaces" << nl
		<< setw(8) << object->clips.size() << " clips" << nl
		<< setw(8) << object->envelopes.size() << " envelopes" << endl;
	
	if (object->layers.size() > 1)
	{
		for( unsigned int i = 0; i < object->layers.size(); i++ )
		{
			points += object->layers[i]->points.size();
			cout << setw(8) << object->layers[i]->points.size() << " points (layer " << i;
			
			if (object->layers[i]->name)
				cout << ", " << object->layers[i]->name << ")" << endl;
			else
				cout << ")" << endl;
			
			polygons += object->layers[i]->polygons.size();
			cout << setw(8) << object->layers[i]->polygons.size() << " polygons (layer " << i;
			
			if (object->layers[i]->name)				
				cout << ", " << object->layers[i]->name << ")" << endl;
			else
				cout << ")" << endl;
		}
	}
	else
	{
		points += object->layers[0]->points.size();
		polygons += object->layers[0]->polygons.size();
	}
	
	cout << setw(8) << points << " points (total)" << nl
		<< setw(8) << polygons << " polygons (total)" << nl << endl;
	
	nobjects++;
	npoints += points;
	npolygons += polygons;
	
	if (flags[PrintVMaps])
		print_vmaps( object );
}

int readFiles( char *source, char *dest)
{
	long h, err;
	struct _finddata_t data;
	char *filename, *prevname, *destname;
	unsigned int failID;
	int failpos;
	lwReader reader;
	Lwo2MeshWriter lwo2mesh;
	
	filename = (char *)malloc(3 * 512);
	if ( !filename ) return 0;
	prevname = filename + 512;
	destname = filename + 1024;
	
	err = h = _findfirst( source, &data );
	if ( err == -1 )
	{
		printf( "No files found: '%s'\n", source );
		return 0;
	}
	
	while ( err != -1 )
	{
		if (( data.attrib & _A_SUBDIR ) && data.name[ 0 ] != '.' )
		{
			make_filespec( source, data.name, filename );
			readFiles( filename, dest );
		}
		if ( !( data.attrib & _A_SUBDIR ))
		{
			make_filename( source, data.name, filename );

			if ( !strcmp( filename, prevname )) break;
			strcpy( prevname, filename );
			failID = failpos = 0;

			lwObject *object = reader.readObjectFromFile( filename );
			if ( object )
			{
				if (flags[InfoOnly])
					info(object, filename);
				else
				{
					make_destname( dest, data.name, destname );
					lwo2mesh.writeLwo2Mesh(object, destname);
				}
				delete object;
			}
		}
		err = _findnext( h, &data );
	}
	
	_findclose( h );
	free (filename);
	return 1;
}

void main( int argc, char *argv[] )
{
	int i = 1;
	unsigned int ndistances = 0;
	Real distance = 0;
	char *source = 0;
	char *dest = 0;

	if ( argc < 2 ) help(argv[0]);

	while (i < argc)
	{
		if (argv[i][0] == '-' || argv[i][0] == '/')
		{
			switch (argv[i++][1])
			{
			case 'd':
			case 'D':
				flags[GenerateLOD] = true;
				switch (argv[i++][0])
				{
				case 'f':
				case 'F':
					flags[UseFixedMethod] = true;
					break;
				case 'p':
				case 'P':
					flags[UseFixedMethod] = false;
					break;
				default:
					help(argv[0]);
				}
				try
				{
					reduction = atof(argv[i++]);
					ndistances = atoi(argv[i++]);
					while (ndistances > 0)
					{
						if (i < argc && argv[i][0] != '-' && argv[i][0] != '/')
							distanceList.push_back(atof(argv[i++]));									
						else
							ndistances = 0;
						ndistances--;
					}
				}
				catch (Exception *e)
				{
					ndistances = 0;
					distanceList.clear();
					flags[GenerateLOD] = false;
				}
				break;
			case 'g':
			case 'G':
				flags[UseSharedVertexData] = false;
				break;
			case 'i':
			case 'I':
				flags[InfoOnly] = true;
				break;
			case 'l':
			case 'L':
				flags[UseSeparateLayers] = true;
				break;
			case 'm':
			case 'M':
				flags[ExportMaterials] = false;
				break;
			case 's':
			case 'S':
				flags[ExportSkeleton] = false;
				break;
			case 'v':
			case 'V':
				flags[PrintVMaps] = true;
				break;
			default:
				help(argv[0]);
			}
		}
		else
		{
			if (!source) source = argv[i];
			else
				if (!dest) dest = argv[i];
			i++;
		}
	}

	if ( !source ) help(argv[0]);

	if (!dest) dest = "\0";

	float t1, t2;
	
	t1 = ( float ) clock() / CLOCKS_PER_SEC;

	if (!flags[InfoOnly])
	{
		logMgr = new LogManager();
		mth = new Math();
		matMgr = new MaterialManager();;
        matMgr->initialise();
		skelMgr = new SkeletonManager();
		meshSerializer = new MeshSerializer();
		materialSerializer = new MaterialSerializer();
		skeletonSerializer = new SkeletonSerializer();
		bufferManager = new DefaultHardwareBufferManager(); // needed because we don't have a rendersystem
	}

	if ( strchr(source, '*') )
		readFiles( source, dest );
	else
	{
		lwReader reader;
		lwObject *object = reader.readObjectFromFile(source);
		if ( object )
		{
			if (flags[InfoOnly])
				info(object, source);
			else
			{
				char *destname = (char *)malloc(512);
				if ( !destname ) return;

				if (strlen(dest))
					make_destname(dest, dest, destname);
				else
					make_destname(dest, source, destname);

				Lwo2MeshWriter lwo2mesh;
				lwo2mesh.writeLwo2Mesh(object, destname);
				free(destname);
			}
			delete object;
		}
	}

	t2 = ( float ) clock() / CLOCKS_PER_SEC - t1;
	
	if (flags[InfoOnly])
	{
		cout << "Total:" << nl
			<< setw(8) << nobjects << " objects" << nl
			<< setw(8) << nlayers << " layers" << nl
			<< setw(8) << nsurfs << " surfaces" << nl
			<< setw(8) << nclips << " clips" << nl
			<< setw(8) << nenvs << " envelopes" << nl
			<< setw(8) << npoints << " points" << nl
			<< setw(8) << npolygons << " polygons" << nl
			<< setw(8) << t2 << " seconds processing time." << endl;
	}
	else
	{
		delete bufferManager;
	    delete skeletonSerializer;
		delete materialSerializer;
		delete meshSerializer;
		delete skelMgr;
		delete matMgr;
		delete mth;
		delete logMgr;
	}
}