fltutil.cpp

空战游戏flacon源码

#include "header.h"
#include "swaprec.h"

void swapData (char *buf, int *rec)
{
	int	i = *rec++;
	while (i--) {
		int j = *rec++;
		int	k = *rec++;
		char *buf1 = buf+k;
		k = *rec++;
		switch (k) {
			case 2:
				while (j--) {
					exch_char (&buf1[1], &buf1[0]);
					buf1 += 2;
				}
				break;
			case 4:
				while (j--) {
					exch_char (&buf1[3], &buf1[0]);
					exch_char (&buf1[2], &buf1[1]);
					buf1 += 4;
				}
				break;
			case 8:
				while (j--) {
					exch_char (&buf1[7], &buf1[0]);
					exch_char (&buf1[6], &buf1[1]);
					exch_char (&buf1[5], &buf1[2]);
					exch_char (&buf1[4], &buf1[3]);
					buf1 += 8;
				}
				break;
		}
	}
}

void swapData1 (char *buf, int *rec)
{
	while (1) {
		int	k = *rec++;
		if (k == -1) return;
		switch (k) {
			case 2:
				exch_char (&buf[1], &buf[0]);
				break;
			case 4:
				exch_char (&buf[3], &buf[0]);
				exch_char (&buf[2], &buf[1]);
				break;
			case 8:
				exch_char (&buf[7], &buf[0]);
				exch_char (&buf[6], &buf[1]);
				exch_char (&buf[5], &buf[2]);
				exch_char (&buf[4], &buf[3]);
				break;
		}
		buf += k;
	}
}

int getUnixFilename (char *filename)
{
	int	index = 0, curindex = 0;
	while (*filename) {
		if (*filename == '/') curindex = index + 1;
		filename++;
		index++;
	}
	return (curindex);
}

int getRecordType (CFileIO& myfile)
{
	short rectype = swap_short (myfile.read_short ());
	short reclen = swap_short (myfile.read_short ());
	if (reclen > 4) myfile.movefileptr (reclen-4, FILEIO_SEEK_CUR);
	return rectype;
}

char *getRecord (CFileIO& myfile, int version, int showerrorflag)
{
	short rectype = swap_short (myfile.read_short ());
	short reclen = swap_short (myfile.read_short ());
	int	i = checkSize (rectype, reclen, version, showerrorflag);
	if (rectype == OPCODE_LONG_IDENTIFIER) i++;
	char *buf = (char *) glAllocateMemory (i);
	if (!buf) {
		printf ("\nCan not allocate memory for record %d len = %d\n",
				rectype, reclen);
		return 0;
	}

	short *sbuf = (short *) buf;
	*sbuf++ = rectype;
	*sbuf++ = reclen;
	if (reclen > 4) myfile.readdata ((char *) sbuf, reclen-4);
	return buf;
}

void swapRecord (char *rec, int version)
{
	short rectype, reclen;
	short *srec = (short *) rec;

	rectype = *srec++;
	reclen = *srec++;

	if (version > 1500) {//== 1520) {
		switch (rectype) {
			case OPCODE_HEADER:
				swapData1 (rec+12, aflt_header);
				break;
			case OPCODE_GROUP:
				swapData1 (rec+12, aflt_group);
				break;
			case OPCODE_OBJECT:
				swapData1 (rec+12, aflt_object);
				break;
			case OPCODE_POLYGON:
				swapData1 (rec+12, aflt_polygon);
				break;
			case OPCODE_DEGREE_OF_FREEDOM:
				swapData1 (rec+12, aflt_degreeoffreedomtable);
				break;
			case OPCODE_VERTEX_LIST:
				{
					aflt_VertexList *vtx = (aflt_VertexList *) rec;
					int i = (vtx -> recordLen-4)/4;
					int	j;
					for (j=0;j < i;j++) 
						vtx->offset[j] = swap_int(vtx->offset[j]);
				}
				break;
			case OPCODE_BINARY_SEPARATING_PLANE:
				swapData1 (rec+12, aflt_bsp);
				break;
			case OPCODE_EXTERNAL_REFERENCE:
				swapData1 (rec+4, aflt_externalreferencetable);
				break;
			case OPCODE_LEVEL_OF_DETAIL:
				swapData1 (rec+12, aflt_lodtable);
				break;
			case OPCODE_SWITCH_BEAD:
				{
					swapData1 (rec+12, aflt_switchtable);
					aflt_SwitchRecord *sw = (aflt_SwitchRecord *) rec;
					if (sw -> NumberWordPerMask > 1) puts ("Switch can only have 1 mask");
				}
				break;
			case OPCODE_BOUNDING_BOX:
				swapData1 (rec+4, aflt_boundingboxtable);
				break;
			case OPCODE_BOUNDING_SPHERE:
				swapData1 (rec+4, aflt_boundingspheretable);
				break;
			case OPCODE_SHARED_VERTEX_TABLE:
				swapData1 (rec+4, aflt_sharedvertex);
				break;
			case OPCODE_VERTEX_COORDINATE:
				swapData1 (rec+4, aflt_vertexcoord);
				break;
			case OPCODE_VERTEX_WITH_NORMAL:
				swapData1 (rec+4, aflt_vertexncoord);
				break;
			case OPCODE_VERTEX_WITH_UV:
				swapData1 (rec+4, aflt_vertexuvcoord);
				break;
			case OPCODE_VERTEX_WITH_NORMAL_AND_UV:
				swapData1 (rec+4, aflt_vertexnuvcoord);
				break;
			case OPCODE_COLOR_TABLE:
				swapData1 (rec+4, aflt_colortable);
				break;
			case OPCODE_TEXTURE_REFERENCE_RECORD:
				swapData1 (rec+4, aflt_texturepatternrecord);
				break;
			case OPCODE_PUT_TRANSFORM:
				swapData1 (rec+4, aflt_putrecord);
				break;
			case OPCODE_TRANSLATE_TRANSFORM:
				swapData1 (rec+4, aflt_translaterecord);
				break;
			case OPCODE_ROTATE_ABOUT_POINT_TRANSFORM:
				swapData1 (rec+4, aflt_rotatepointrecord);
				break;
			case OPCODE_MATERIAL_PALETTE:
				swapData1 (rec+4, aflt_materialtable);
				break;
			case OPCODE_MATERIAL_TABLE:
				swapData (rec, flt_materialtable);
				break;
			case OPCODE_TRANSFORMATION_MATRIX:
				swapData1 (rec+4, aflt_transformationmatrixrecord);
				break;
		}
		return;
	}

	switch (rectype) {
		case OPCODE_COLOR_TABLE:
			if (version > 1500)
				swapData1 (rec+4, aflt_colortable);
			else swapData (rec, flt_colortable);
			break;

		case OPCODE_LEVEL_OF_DETAIL:
			swapData (rec, flt_lodtable);
			break;
		case OPCODE_EXTERNAL_REFERENCE:
			swapData (rec, flt_externalreferencetable);
			break;
		case OPCODE_DEGREE_OF_FREEDOM:
			swapData (rec, flt_degreeoffreedomtable);
			break;
		case OPCODE_HEADER:
			swapData (rec, flt_header);
			break;
		case OPCODE_GROUP:
			swapData (rec, flt_group);
			break;
		case OPCODE_OBJECT:
			swapData (rec, flt_object);
			break;
		case OPCODE_BINARY_SEPARATING_PLANE:
			swapData (rec, flt_bsp);
			break;
		case OPCODE_SHARED_VERTEX_TABLE:
			swapData (rec, flt_sharedvertex);
			break;
		case OPCODE_VERTEX_LIST:
			{
			flt_VertexList *vtx;
			vtx = (flt_VertexList *) rec;
			int i = (vtx -> recordLen-4)/4;
			int	j;
			for (j=0;j < i;j++) 
				vtx->offset[j] = swap_int(vtx->offset[j]);
			}
			break;
		case OPCODE_VERTEX_COORDINATE:
			swapData (rec, flt_vertexcoord);
			break;
		case OPCODE_VERTEX_WITH_NORMAL:
			swapData (rec, flt_vertexncoord);
			break;
		case OPCODE_VERTEX_WITH_UV:
			swapData (rec, flt_vertexuvcoord);
			break;
		case OPCODE_VERTEX_WITH_NORMAL_AND_UV:
			swapData (rec, flt_vertexnuvcoord);
			break;
		case OPCODE_POLYGON:
			swapData (rec, flt_polygon);
			break;
		case OPCODE_TEXTURE_REFERENCE_RECORD:
			swapData (rec, flt_texturepatternrecord);
			break;
		case OPCODE_SWITCH_BEAD:
			{
			swapData (rec, flt_switchtable);
			flt_SwitchRecord *sw = (flt_SwitchRecord *) rec;
			if (sw -> NumberWordPerMask > 1) puts ("Switch can only have 1 mask");
			}
			break;
		case OPCODE_BOUNDING_BOX:
			swapData (rec, flt_boundingboxtable);
			break;
		case OPCODE_BOUNDING_SPHERE:
			swapData (rec, flt_boundingspheretable);
			break;
		case OPCODE_PUT_TRANSFORM:
			swapData (rec, flt_putrecord);
			break;
		case OPCODE_TRANSLATE_TRANSFORM:
			swapData (rec, flt_translaterecord);
			break;
		case OPCODE_ROTATE_ABOUT_POINT_TRANSFORM:
			swapData (rec, flt_rotatepointrecord);
			break;
		case OPCODE_MATERIAL_TABLE:
			swapData (rec, flt_materialtable);
			break;
		case OPCODE_MATERIAL_PALETTE:
			swapData1 (rec+4, aflt_materialtable);
			break;
		case OPCODE_TRANSFORMATION_MATRIX:
			swapData1 (rec+4, aflt_transformationmatrixrecord);
			break;
	}
}

int checkSize (int rectype, int reclen, int version, int showerrorflag)
{
	int		recsize;
	char	str[100];

	recsize = reclen;
	if (version > 1500) {//== 1520) {
		switch (rectype) {
			case OPCODE_LEVEL_OF_DETAIL:
				recsize = sizeof(aflt_LODRecord);
				strcpy (str, "OPCODE_LOD");
				break;
			case OPCODE_EXTERNAL_REFERENCE:
				recsize = sizeof(aflt_ExternalReferenceRecord);
				strcpy (str, "OPCODE_EXTERNAL_REFERENCE");
				break;
			case OPCODE_HEADER:
				recsize = sizeof(aflt_HeaderRecord);
				strcpy (str, "OPCODE_HEADER");
				break;
			case OPCODE_GROUP:
				recsize = sizeof(aflt_GroupRecord);
				strcpy (str, "OPCODE_GROUP");
				break;
			case OPCODE_OBJECT:
				recsize = sizeof(aflt_ObjectRecord);
				strcpy (str, "OPCODE_OBJECT");
				break;
			case OPCODE_BINARY_SEPARATING_PLANE:
				recsize = sizeof(aflt_BinarySeparatingPlane);
				strcpy (str, "OPCODE_BINARY_SEPARATING_PLANE");
				break;
			case OPCODE_SHARED_VERTEX_TABLE:
				recsize = sizeof(aflt_SharedVertex);
				strcpy (str, "OPCODE_SHARED_VERTEX_TABLE");
				break;
			case OPCODE_VERTEX_COORDINATE:
				recsize = sizeof(aflt_VertexCoordinate);
				strcpy (str, "OPCODE_VERTEX_COORDINATE");
				break;
			case OPCODE_VERTEX_WITH_NORMAL:
				recsize = sizeof(aflt_VertexCoordinateNormal);
				strcpy (str, "OPCODE_VERTEX_WITH_NORMAL");
				break;
			case OPCODE_VERTEX_WITH_UV:
				recsize = sizeof(aflt_VertexCoordinateTexture);
				strcpy (str, "OPCODE_VERTEX_WITH_UV");
				break;
			case OPCODE_VERTEX_WITH_NORMAL_AND_UV:
				recsize = sizeof(aflt_VertexCoordinateTextureNormal);
				strcpy (str, "OPCODE_VERTEX_WITH_NORMAL_AND_UV");
				break;
			case OPCODE_POLYGON:
				recsize = sizeof(aflt_PolygonRecord);
				strcpy (str, "OPCODE_POLYGON");
				break;
			case OPCODE_TEXTURE_REFERENCE_RECORD:
				recsize = sizeof(aflt_TexturePatternRecord);