getloc.cpp

空战游戏flacon源码

#include "header.h"
#include "namelist.h"

struct vertexRecord {
	int		id;
	float	x, y, z;
	float	u, v;
	float	nx, ny, nz;
	float	r, g, b, a;
	vertexRecord	*next;
};

struct materialPalettePtr {
	aflt_MaterialRecord *materialPalette;
	materialPalettePtr	*next;
};

struct rgbaRecord {
	int	r, g, b, a;
};

struct recordPtr {
	char	*record;
	recordPtr	*next;
};

struct treePtr {
	char	*record;
	int		counter, beadcounter, objectid;
	treePtr	*parent, *child, *next, *prev;
	treePtr *subface;
};

struct vertexPtr {
	int	vertexOffset;
	int	vertexNo;
	vertexPtr *next;
};

vertexRecord *getVertex ();
vertexRecord *findVertex (int id);
void getMaterialFromTable (rgbaRecord *col, int matindex);
int	getColorFromTable (int index);
int findVertexNo (int offset);
int convertColor (int color, int intensity);
int checkForLongID (treePtr *tree);
int saveRecordHeader (CFileIO& myfile, char *rec);
void buildTreeRecord (char *rec);
void deleteTreeRecord (treePtr *tree);

void processPolygon (short rectype, treePtr *tree);
void processTreeRecord (treePtr *tree);
void processRecord (treePtr *tree);
void processInfo (treePtr *tree);
void processRecord1 (treePtr *tree);
void processInfo1 (treePtr *tree);
void processInfoSubface (treePtr *tree);

void processBeadElement (CFileIO& myfile, treePtr *tree);
void storeVertex (int offset, int no);
void setobjectid (treePtr *tree, GLint objectid);

materialPalettePtr *headmaterialPalette, *currentmaterialPalette;
materialPalettePtr *newmaterialPalette;
recordPtr *headRecord, *currentRecord, *newRecord;
treePtr *treeRoot, *currentTree, *newTree;
treePtr *subfaceRoot, *currentsubfacetree, *currentsubface;
treePtr	*subfaceList[1000];		// only 1000 subfaces allowed
vertexPtr *headVertex, *currentVertex, *newVertex;
char *colorTableRecord;
flt_MaterialRecord *materialTableRecord;
char 	buffer[1024], buffer1[1024];
int	startflag;
int	vertexno, textureno;
int	inpushmode, inpushsubfacemode, insubfacemode, subfacecounter, usetextureflag;
int	beadcounter, matrixcounter;
int	dofcounter, groupcounter, objectcounter, bspcounter, polygoncounter;
int	switchcounter, bboxcounter, bspherecounter;
int	vertexOffset;
int	fltversion, warningflag;

GLfloat ScaleFactor;
GLint	DisableMask, tSetTotal;
char polyname[80], polyfilename[80];
int	polynamelen;

vertexRecord	*startVertex;
NameList	polynameList;

void main (int argc, char *argv[])
{
	if (argc < 2) {
		puts ("\nGetLoc v1.0 by Erick Jap\n");
		puts ("Usage: GetLoc fltfile [options]");
		puts ("options:");
		puts ("-ffilename    --> Filename consisting of the polygon name");
		puts ("-nPolygonname --> Polygon to get the location from");
		puts ("-w            --> Display warning when structure size is different");
		exit (1);
	}

	char infile[80], outfile[80];
	glConcatFileExtension ((GLbyte *) infile, (GLbyte *) argv[1], (GLbyte *) "FLT");
	glConcatFileExtension ((GLbyte *) outfile, (GLbyte *) argv[1], (GLbyte *) "LOC");

	polyname[0] = 0;
	polyfilename[0] = 0;
	ScaleFactor = (GLfloat) 1.0;
	DisableMask = 0;
	tSetTotal = 1;
	warningflag = 0;
	GLint i;
	for (i=2;i < argc;i++) {
		if (argv[i][0] == '-') {
			if (argv[i][1] == 'f' || argv[i][1] == 'F') {
				strcpy (polyfilename, &(argv[i][2]));
			}
			else if (argv[i][1] == 'n' || argv[i][1] == 'N') {
				strcpy (polyname, &(argv[i][2]));
			}
			else if (argv[i][1] == 'w' || argv[i][1] == 'W') {
				warningflag = 1;
			}
		}
	}
	polynamelen = strlen (polyname);

	polynameList.ReadNameList (polyfilename);

	CFileIO myfile;
	if (!myfile.openread (infile)) {
		printf ("Can not open input file %s\n", infile);
		exit (1);
	}
	if (!myfile.openwrite (outfile)) {
		printf ("Can not open output file %s\n", outfile);
		exit (1);
	}

	puts ("Reading data");

	while (!myfile.eof()) {
		short rectype = swap_short (myfile.read_short ());
		short reclen = swap_short (myfile.read_short ());
		if (rectype == OPCODE_HEADER) {
			char *buf = (char *) glAllocateMemory (reclen);
			if (!buf) {
				printf ("\nCan not allocate memory for header\n");
				exit (1);
			}
			short *sbuf = (short *) buf;
			*sbuf++ = rectype;
			*sbuf++ = reclen;
			if (reclen > 4) myfile.readdata ((char *) sbuf, reclen-4);
			flt_HeaderRecord *header;
			header = (flt_HeaderRecord *) buf;
			fltversion = swap_int(header -> formatRev);
			glReleaseMemory (buf);
			break;
		}
		if (reclen > 4) myfile.movefileptr (reclen-4, FILEIO_SEEK_CUR);
	}
	myfile.movefileptr ();

	usetextureflag = 0;
	while (!myfile.eof()) {
		short rectype = getRecordType(myfile);
		if (rectype == OPCODE_TEXTURE_REFERENCE_RECORD) {
			usetextureflag = 1;
			break;
		}
	}
	myfile.movefileptr ();

	puts ("Processing data");
	colorTableRecord = 0;
	materialTableRecord = 0;
	headmaterialPalette = currentmaterialPalette = 0;
	headRecord = currentRecord = 0;
	headVertex = currentVertex = 0;
	vertexno = 0;
	textureno = 0;
	startflag = 0;
	vertexOffset = 0;
	startVertex = 0;

	while (!myfile.eof()) {
		char *record = getRecord (myfile, fltversion, warningflag);
		if (!record) exit (1);
		swapRecord (record, fltversion);
		int i = saveRecordHeader (myfile, record);
		if (i) {
			newRecord = (recordPtr *) glAllocateMemory (sizeof(recordPtr));
			newRecord -> record = record;
			newRecord -> next = 0;
			if (headRecord) {
				currentRecord -> next = newRecord;
				currentRecord = newRecord;
			}
			else headRecord = currentRecord = newRecord;
		}
		else {
			short *srec = (short *) record;
			short rectype = *srec;
			if (rectype == OPCODE_COLOR_TABLE) {
				colorTableRecord = record;
			}
			else if (rectype == OPCODE_MATERIAL_TABLE) {
				materialTableRecord = (flt_MaterialRecord *) record;
			}
			else if (rectype == OPCODE_MATERIAL_PALETTE) {
				newmaterialPalette = (materialPalettePtr *) glAllocateMemory (sizeof(materialPalettePtr));
				newmaterialPalette -> next = 0;
				newmaterialPalette -> materialPalette = (aflt_MaterialRecord *) record;
				if (headmaterialPalette) {
					currentmaterialPalette -> next = newmaterialPalette;
					currentmaterialPalette = newmaterialPalette;
				}
				else {
					headmaterialPalette = currentmaterialPalette = newmaterialPalette;
				}
			}
			else glReleaseMemory ((char *) record);
		}
	}

	if (!colorTableRecord) {
		puts ("Error! Can not find Color Table Record");
	}

	if (startflag & 3) {
		if (startflag & 1) startflag &= ~1;
		else if (startflag & 2) startflag &= ~2;
	}

	puts ("Building tree");
	inpushmode = 0;
	insubfacemode = 0;
	inpushsubfacemode = 0;
	subfacecounter = 0;
	treeRoot = 0;
	subfaceRoot = 0;
	newRecord = headRecord;
	while (newRecord) {
		currentRecord = newRecord;
		buildTreeRecord (newRecord -> record);
		newRecord = newRecord -> next;
		glReleaseMemory ((char *) currentRecord);
	}

	dofcounter = groupcounter = objectcounter = bspcounter = polygoncounter = 0;
	switchcounter = bboxcounter = bspherecounter = 0;
	beadcounter = 0;
	matrixcounter = 0;

	puts ("Processing Info");
	processInfo (treeRoot);
	processInfo1 (treeRoot);

	puts ("Processing Bead Element");
	processBeadElement (myfile, treeRoot);

	puts ("Clean up");
	glReleaseMemory ((char *) colorTableRecord);
	glReleaseMemory ((char *) materialTableRecord);

	while (headmaterialPalette) {
		currentmaterialPalette = headmaterialPalette;
		headmaterialPalette = headmaterialPalette -> next;
		glReleaseMemory (currentmaterialPalette);
	}

	while (headVertex) {
		newVertex = headVertex;
		headVertex = headVertex -> next;
		glReleaseMemory ((char *) newVertex);
	}
	deleteTreeRecord (treeRoot); 

	vertexRecord *vtxptr;
	while (startVertex) {
		vtxptr = startVertex;
		startVertex = startVertex -> next;
		glReleaseMemory ((char *) vtxptr);
	}

	puts ("Done");
	exit (0);
}

vertexRecord *getVertex ()
{
	vertexRecord *vtxptr;

	vtxptr = (vertexRecord *) glAllocateMemory (sizeof (vertexRecord));
	if (vtxptr) {
		vtxptr -> next = startVertex;
		startVertex = vtxptr;
	}
	else {
		puts ("Can not allocate vertex Record!");
	}
	return vtxptr;
}

vertexRecord *findVertex (int id)
{
	vertexRecord *vtxptr = startVertex;

	while (vtxptr) {
		if (vtxptr -> id == id) return vtxptr;
		vtxptr = vtxptr -> next;
	}
	return 0;
}

int findVertexNo (int offset)
{
	newVertex = headVertex;
	while (newVertex) {
		if (newVertex -> vertexOffset == offset)
			return (newVertex -> vertexNo);
		newVertex = newVertex -> next;
	}
	return 0;
}

void storeVertex (int offset, int no)
{
	newVertex = (vertexPtr *) glAllocateMemory (sizeof (vertexPtr));
	newVertex -> vertexOffset = offset;
	newVertex -> vertexNo = no;
	newVertex -> next = 0;
	if (headVertex) {
		currentVertex -> next = newVertex;
		currentVertex = newVertex;
	}
	else headVertex = currentVertex = newVertex;
}

void deleteTreeRecord (treePtr *tree) 
{
	if (tree) {
		deleteTreeRecord (tree -> subface);
		deleteTreeRecord (tree -> child);
		deleteTreeRecord (tree -> next);
		glReleaseMemory ((char *) tree -> record);
		glReleaseMemory ((char *) tree);
	}
}

// set objectid for every polygons
void processPolygon (short rectype, treePtr *tree)
{
	short rectype1 = rectype;
	if (rectype == OPCODE_LONG_IDENTIFIER) {
		short *srec = (short *) tree -> prev -> record;
		rectype1 = *srec;
	}
	if (rectype1 == OPCODE_OBJECT) {
		treePtr *polytree = tree -> child;
		if (polytree) {
			short *srec2 = (short *) polytree -> record;
			short rectype2 = *srec2;
			if (rectype2 == OPCODE_POLYGON) {
				setobjectid (polytree, tree -> counter);
			}
		}
	}
}

void setobjectid (treePtr *tree, GLint objectid)
{
	if (tree) {
		tree -> objectid = objectid;
		setobjectid (tree -> subface, objectid);
		setobjectid (tree -> next, objectid);
	}
}

void processRecord (treePtr *tree)
{
	if (tree) {
		processInfo (tree -> child);
		processRecord (tree -> next);
	}
}

void processInfo (treePtr *tree)
{
	if (tree) {
		short *srec = (short *) tree -> record;
		short rectype = *srec;
		if (rectype != OPCODE_VERTEX_LIST) {
			processTreeRecord (tree);
		}
		processInfo (tree -> child);
		processRecord (tree -> next);
	}
}

void processRecord1 (treePtr *tree)
{
	if (tree) {
		processInfo1 (tree -> child);
		processRecord1 (tree -> next);
	}
}

void processInfo1 (treePtr *tree)
{
	if (tree) {
		processInfo1 (tree -> child);
		processRecord1 (tree -> next);
		processInfoSubface (tree -> subface);
	}
}

void processInfoSubface (treePtr *tree)
{
	if (tree) {
		short *srec = (short *) tree -> record;
		short rectype = *srec;
		if (rectype != OPCODE_VERTEX_LIST) {
			processTreeRecord (tree);
		}
		processInfoSubface (tree -> subface);
	}
}

void processTreeRecord (treePtr *tree)
{
	if (tree) {
		char  *rec = tree -> record;
		short *srec = (short *) rec;
		short rectype = *srec++;
		short reclen = *srec++;
		switch (rectype) {
			case OPCODE_SWITCH_BEAD:
				{
					tree -> counter = switchcounter++;
					tree -> beadcounter = ++beadcounter;
				}
				break;
			case OPCODE_DEGREE_OF_FREEDOM:
				{
					tree -> counter = dofcounter++;
					tree -> beadcounter = ++beadcounter;
				}
				break;
			case OPCODE_LONG_IDENTIFIER:
				{
					if (tree -> prev) {
						tree -> counter = tree -> prev -> counter;
						tree -> beadcounter = tree -> prev -> beadcounter;
						processPolygon (rectype, tree);
					}
				}
				break;
			case OPCODE_GROUP:
				{
					tree -> counter = groupcounter++;
					tree -> beadcounter = ++beadcounter;
				}
				break;
			case OPCODE_OBJECT:
				{
					tree -> counter = objectcounter++;
					tree -> beadcounter = ++beadcounter;
					processPolygon (rectype, tree);
				}
				break;
			case OPCODE_BINARY_SEPARATING_PLANE:
				{
					tree -> counter = bspcounter++;
					tree -> beadcounter = ++beadcounter;
				}
				break;
			case OPCODE_POLYGON:
				{
					tree -> counter = polygoncounter++;
					tree -> beadcounter += beadcounter;
				}
				break;
			case OPCODE_BOUNDING_BOX:
				{
					tree -> counter = bboxcounter++;
					tree -> beadcounter = ++beadcounter;
				}
				break;
			case OPCODE_BOUNDING_SPHERE:
				{
					tree -> counter = bspherecounter++;
					tree -> beadcounter = ++beadcounter;
				}
				break;
			case OPCODE_TRANSFORMATION_MATRIX:
				tree -> counter = matrixcounter++;
				tree -> beadcounter += beadcounter;
				break;
		}
		processTreeRecord (tree -> next);
	}
}

void processBeadElement (CFileIO& myfile, treePtr *tree)
{
	if (tree) {
		char  *rec = tree -> record;
		short *srec = (short *) rec;
		short rectype = *srec++;
		short reclen = *srec++;
		switch (rectype) {
			case OPCODE_POLYGON:
				{