main.cpp

赫赫大名的 OGRE 游戏引擎

#include "lwo.h"
#include "lwReader.h"
#include "lwo2mesh.h"

#include "Ogre.h"
#include "OgreMeshSerializer.h"
#include "OgreSkeletonSerializer.h"
#include "OgreDataChunk.h"
#include "OgreDefaultHardwareBufferManager.h"

#include "io.h"
#include "time.h"

LogManager* logMgr;
Math* mth;
MaterialManager* matMgr;
SkeletonManager* skelMgr;
MeshSerializer* meshSerializer;
MaterialSerializer* materialSerializer;
SkeletonSerializer* skeletonSerializer;
DefaultHardwareBufferManager *bufferManager;

bool flags[NUMFLAGS] =
{
	false, // lightwave info
	false, // dump vmaps
	true,  // shared geometry
	false, // layers
	false, // generate LOD
	true,  // use fixed method
	true,  // materials
	true,  // skeleton
	true,  // has normals
	true,  // new submesh
	true   // linear copy
};

Mesh::LodDistanceList distanceList;
Real reduction = 0.0f;

ostream& nl(ostream& os)
{
	return os << '\n';
}

int nobjects = 0, nlayers = 0, nsurfs = 0, nenvs = 0, nclips = 0, npoints = 0, npolygons = 0;

/*
======================================================================
print_vmaps1()

  Print vmap values for a layer, looping through the vmaps.
  
	for each vmap
	print vmap statistics
	for each mapped point
	print point index and position
	if vmad, print polygon index and vertex number
	print vmap values
====================================================================== */

static void print_vmaps1( FILE *fp, lwLayer *layer )
{
	lwPoint *pt;
	lwVMap *vmap;
	char *tag;
	unsigned int i, j, k, n;
	
	fprintf( fp, "\n\nVertex Maps (%d)\n\n", layer->vmaps.size() );
	
	for ( i = 0; i < layer->vmaps.size(); i++ )
	{
		vmap = layer->vmaps[i];

		tag = ( char * ) &vmap->type;
		
		fprintf( fp, "%c%c%c%c \"%s\"  dim %d  nverts %d  vmad (%s)\n",
			tag[ 3 ], tag[ 2 ], tag[ 1 ], tag[ 0 ],
			vmap->name,
			vmap->dim,
			vmap->nverts,
			vmap->perpoly ? "yes" : "no" );
		
		printf( "%c%c%c%c \"%s\"  dim %d  nverts %d  vmad (%s)\n",
			tag[ 3 ], tag[ 2 ], tag[ 1 ], tag[ 0 ],
			vmap->name,
			vmap->dim,
			vmap->nverts,
			vmap->perpoly ? "yes" : "no" );
		
		for ( j = 0; j < vmap->nverts; j++ ) {
			/* point index */
			fprintf( fp, "  point %d ", vmap->vindex[ j ] );
			
			/* if vmad */
			if ( vmap->perpoly ) {
				lwPolygon *pol;
				
				/* polygon index */
				k = vmap->pindex[ j ];
				fprintf( fp, " poly %d ", k );
				
				/* vertex index */
				pol = layer->polygons[ k ];
				for ( n = 0; n < pol->vertices.size(); n++ )
					if ( pol->vertices[ n ]->index == vmap->vindex[ j ] ) break;
					fprintf( fp, " vert %d ", n );
			}
			
			/* point coords */
			pt = layer->points[ vmap->vindex[ j ]];
			fprintf( fp, " (%g, %g, %g) ", pt->x, pt->y, pt->z );
			
			/* vmap values */
			for ( k = 0; k < vmap->dim; k++ )
				fprintf( fp, " %g", vmap->val[ j ][ k ] );
			
			/* done with this point */
			fprintf( fp, "\n" );
		}
		/* done with this vmap */
		fprintf( fp, "\n" );
	}
	/* done with this layer */
	fprintf( fp, "\n\n" );
}


/*
======================================================================
print_vmaps2()

  Print vmap values for a layer, looping through the points.
  
	for each point
	print point index, position, number of vmaps, polygon indexes
	for each vmap on the point
	print vmap name, type and values
====================================================================== */

static void print_vmaps2( FILE *fp, lwLayer *layer )
{
	lwPoint *pt;
	lwVMap *vmap;
	char *tag;
	unsigned int i, j, k, n;
	
	fprintf( fp, "\n\nPoints (%d)\n\n", layer->points.size() );
	
	for ( i = 0; i < layer->points.size(); i++ ) {
		pt = layer->points[ i ];
		
		/* point index and position */
		fprintf( fp, "%d (%g, %g, %g)", i, pt->x, pt->y, pt->z );
		
		/* number of vmaps and polygons */
		fprintf( fp, "  nvmaps %d  npolygons %d", pt->vmaps.size(), pt->polygons.size() );
		
		/* polygon indexes */
		fprintf( fp, " [" );
		for ( j = 0; j < pt->polygons.size(); j++ )
			fprintf( fp, " %d", pt->polygons[ j ] );
		fprintf( fp, "]\n" );
		
		/* vmaps for this point */
		for ( j = 0; j < pt->vmaps.size(); j++ ) {
			vmap = pt->vmaps[ j ].vmap;
			n = pt->vmaps[ j ].index;
			
			tag = ( char * ) &vmap->type;
			
			fprintf( fp, "  %c%c%c%c \"%s\" vmad (%s)",
				tag[ 3 ], tag[ 2 ], tag[ 1 ], tag[ 0 ], vmap->name,
				vmap->perpoly ? "yes" : "no" );
			
			/* vmap values */
			for ( k = 0; k < vmap->dim; k++ )
				fprintf( fp, " %g", vmap->val[ n ][ k ] );
			
			/* done with this vmap */
			fprintf( fp, "\n" );
		}
		/* done with this point */
		fprintf( fp, "\n" );
	}
	/* done with this layer */
	fprintf( fp, "\n\n" );
}


/*
======================================================================
print_vmaps3()

  Print vmap values for a layer, looping through the polygons.
  
	for each polygon
	print polygon index, number of points
	for each vertex
	print point index, position, number of vmaps
	for each vmap on the point
	print vmap name, type and values
====================================================================== */

static void print_vmaps3( FILE *fp, lwLayer *layer )
{
	lwPoint *pt;
	lwPolygon *pol;
	lwVMap *vmap;
	char *tag;
	unsigned int i, j, k, m, n;
	
	fprintf( fp, "\n\nPolygons (%d)\n\n", layer->polygons.size() );
	
	for ( i = 0; i < layer->polygons.size(); i++ ) {
		pol = layer->polygons[ i ];
		
		/* polygon index, type, number of vertices */
		tag = ( char * ) &pol->type;
		fprintf( fp, "%d %c%c%c%c  nverts %d\n", i,
			tag[ 3 ], tag[ 2 ], tag[ 1 ], tag[ 0 ], pol->vertices.size() );
		
		for ( k = 0; k < pol->vertices.size(); k++ ) {
			/* point index, position, number of vmads and vmaps */
			n = pol->vertices[ k ]->index;
			pt = layer->points[ n ];
			fprintf( fp, "%d (%g, %g, %g)  nvmads %d  nvmaps %d\n", n,
				pt->x, pt->y, pt->z,
				pol->vertices[ k ]->vmaps.size(), pt->vmaps.size() - pol->vertices[ k ]->vmaps.size() );
			
			/* vmads for this vertex */
			for ( j = 0; j < pol->vertices[ k ]->vmaps.size(); j++ ) {
				vmap = pol->vertices[ k ]->vmaps[ j ].vmap;
				n = pol->vertices[ k ]->vmaps[ j ].index;
				
				tag = ( char * ) &vmap->type;
				fprintf( fp, "  %c%c%c%c vmad \"%s\"",
					tag[ 3 ], tag[ 2 ], tag[ 1 ], tag[ 0 ], vmap->name );
				
				/* vmap values */
				for ( m = 0; m < vmap->dim; m++ )
					fprintf( fp, " %g", vmap->val[ m ][ n ] );
				
				/* done with this vmad */
				fprintf( fp, "\n" );
			}
			
			/* vmaps for this vertex */
			for ( j = 0; j < pt->vmaps.size(); j++ ) {
				vmap = pt->vmaps[ j ].vmap;
				if ( vmap->perpoly ) continue;
				n = pt->vmaps[ j ].index;
				
				tag = ( char * ) &vmap->type;
				fprintf( fp, "  %c%c%c%c vmap \"%s\"",
					tag[ 3 ], tag[ 2 ], tag[ 1 ], tag[ 0 ], vmap->name );
				
				/* vmap values */
				for ( m = 0; m < vmap->dim; m++ )
					fprintf( fp, " %g", vmap->val[ m ][ n ] );
				
				/* done with this vmap */
				fprintf( fp, "\n" );
			}
			
			/* done with this vertex */
			if ( pt->vmaps.size() )
				fprintf( fp, "\n" );
		}
		/* done with this polygon */
		fprintf( fp, "\n" );
	}
	/* done with this layer */
	fprintf( fp, "\n\n" );
}


/*
======================================================================
print_vmaps()

  Print vmap values for a layer.
  
	Calls print_vmaps1(), print_vmaps2() and print_vmaps3().
====================================================================== */

void print_vmaps( lwObject *obj )
{
	FILE *fp[ 3 ];
	char buf[ 64 ];
	lwLayer *layer;
	unsigned int i, j;
	
	for ( i = 0; i < 3; i++ ) {
		sprintf( buf, "vmapout%d.txt", i + 1 );
		fp[ i ] = fopen( buf, "w" );
		if ( !fp[ i ] ) {
			for ( j = i - 1; j >= 0; j-- )
				fclose( fp[ j ] );
			return;
		}
	}
	
	for ( i = 0; i < obj->layers.size(); i++ )
	{
		layer = obj->layers[i];

		fprintf( fp[ 0 ], "------------------------\nLayer %d\n", i );
		print_vmaps1( fp[ 0 ], layer );
		
		fprintf( fp[ 1 ], "------------------------\nLayer %d\n", i );
		print_vmaps2( fp[ 1 ], layer );
		
		fprintf( fp[ 2 ], "------------------------\nLayer %d\n", i );
		print_vmaps3( fp[ 2 ], layer );
	}
	
	for ( i = 0; i < 3; i++ )
		fclose( fp[ i ] );
}

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