hobwritr.cpp

空战游戏flacon源码

#include "hobwritr.h"
#include "..\..\3Dlib\inline.h"

GLdynamicPolygon GlobalDynamicPolygon[MAX_FACES];
GLint TotalDynamicPolygon;

GLint CHOBWriter::CreateHOBFile (GLbyte *file, GLObjectData *data)
{
	if (!out.openwrite ((char *) file, 1)) return 1;

	objData = *data;
	objData.objectFlag |= OBJECT_TYPE_IS_BINARY;

	objData.beadTexture = 0;
	objData.objectAnimation = 0;
	objData.switchList = 0;
	objData.Slotptr = 0;
	objData.dofTree = 0;
	objData.version = HOB_VERSION;
	objData.DynamicVertex = 0;
	objData.TotalDynamicPolygon = 0;
	objData.DynamicPolygon = 0;

	curoffset = 0;

	out.writedata ((char *) &objData, sizeof (GLObjectData));
	curoffset += sizeof (GLObjectData);

	GLint	i;

	if (data -> beadTexture) {
		objData.beadTexture = (GLbeadTexture *) curoffset;
		i = objData.TotalTextures * sizeof (GLbeadTexture);
		out.writedata ((char *) data -> beadTexture, i);
		curoffset += i;
		glReleaseMemory ((char *) data -> beadTexture);
	}

	if (data -> switchList) {
		objData.switchList = (GLint *) curoffset;
		i = objData.TotalSwitch * sizeof (GLint);
		out.writedata ((char *) data -> switchList, i);
		curoffset += i;
		glReleaseMemory ((char *) data -> switchList);
	}

	if (data -> Slotptr) {
		objData.Slotptr = (GLbeadSlot *) curoffset;
		i = objData.TotalObjectSlot * sizeof (GLbeadSlot);
		out.writedata ((char *) data -> Slotptr, i);
		curoffset += i;
		glReleaseMemory ((char *) data -> Slotptr);
	}

	if (data -> DynamicVertex) {
		objData.DynamicVertex = (GLdynamicVertex *) curoffset;
		i = objData.TotalDynamicVertex * sizeof (GLdynamicVertex);
		out.writedata ((char *) data -> DynamicVertex, i);
		curoffset += i;
		glReleaseMemory ((char *) data -> DynamicVertex);
	}
	if (data -> objectAnimation) SaveAnimation (data);
	if (data -> dofTree) SaveDOF (data);

	objData.VertexList = (GLvertexData *) curoffset;
	i = objData.TotalVertices * sizeof (GLvertexData);
	out.writedata ((char *) data -> VertexList, i);
	curoffset += i;

	objData.VertexCoord = (GLvertexCoord *) curoffset;
	i = objData.TotalCoord * sizeof (GLvertexCoord);
	out.writedata ((char *) data -> VertexCoord, i);
	curoffset += i;

	TotalDynamicPolygon = 0;
	objData.beadRoot = (GLbeadTree *) SaveBeadTree (data -> beadRoot, data);

	if (TotalDynamicPolygon && data -> TotalDynamicVertex) {
		objData.TotalDynamicPolygon = TotalDynamicPolygon;
		objData.DynamicPolygon = (GLdynamicPolygon *) curoffset;
		i = objData.TotalDynamicPolygon * sizeof (GLdynamicPolygon);
		out.writedata ((char *) GlobalDynamicPolygon, i);
		curoffset += i;
	}

	// Note: VertexList is used inside SaveBeadTree
	glReleaseMemory ((char *) data -> VertexList);
	glReleaseMemory ((char *) data -> VertexCoord);

	out.moveoutfileptr ();
	objData.totalsize = curoffset;
	out.writedata ((char *) &objData, sizeof (GLObjectData));

	out.closefile (1);
	return 0;
}

void CHOBWriter::SaveAnimation (GLObjectData *data)
{
	GLint i, j;

	objData.objectAnimation = (GLAnimation *) curoffset;

	GLAnimation *anim = data -> objectAnimation;
	j = curoffset - (GLint) anim;

	i = (GLint) anim -> DOFptr;
	if (i) {
		i += j;
		anim -> DOFptr = (GLDOFInput *) i;
	}
	i = (GLint) anim -> Switchptr;
	if (i) {
		i += j;
		anim -> Switchptr = (GLint *) i;
	}
	i = (GLint) anim -> ANSdataptr;
	if (i) {
		i += j;
		anim -> ANSdataptr = (ANSStruct *) i;
	}
	i = (GLint) anim -> Slotvarptr;
	if (i) {
		i += j;
		anim -> Slotvarptr = (void **) i;
	}
	i = (GLint) anim -> InstanceDynamicVertex;
	if (i) {
		i += j;
		anim -> InstanceDynamicVertex = (GLdynamicVertex *) i;
	}
	i = (GLint) anim -> ANSinitcodeptr;
	if (i) {
		i += j;
		anim -> ANSinitcodeptr = (void *) i;
	}
	i = (GLint) anim -> ANScodeptr;
	if (i) {
		i += j;
		anim -> ANScodeptr = (void *) i;
	}
	out.writedata ((char *) anim, anim -> TotalSize);
	curoffset += anim -> TotalSize;
	glReleaseMemory ((char *) anim);
}

void CHOBWriter::SaveDOF (GLObjectData *data)
{
	GLint i, j, k;

	objData.dofTree = (GLbeadDOFTree *) curoffset;
	j = curoffset - (GLint) data -> dofTree;
	for (i=0; i <= objData.TotalDOF; i++) {
		data -> dofTree[i].tree = 0;		// This field is used only by OTF
		k = (GLint) (data -> dofTree[i].dof);
		if (k) {
			k += j;
			data -> dofTree[i].dof = (GLbeadDegreeOfFreedom *) k;
		}
		k = (GLint) (data -> dofTree[i].Parent);
		if (k) {
			k += j;
			data -> dofTree[i].Parent = (GLbeadDOFTree *) k;
		}
		k = (GLint) (data -> dofTree[i].Sibling);
		if (k) {
			k += j;
			data -> dofTree[i].Sibling = (GLbeadDOFTree *) k;
		}
		k = (GLint) (data -> dofTree[i].Child);
		if (k) {
			k += j;
			data -> dofTree[i].Child = (GLbeadDOFTree *) k;
		}
	}
	j = sizeof (GLbeadDOFTree) + sizeof (GLbeadDegreeOfFreedom);
	i = (objData.TotalDOF + 1) * j;
	out.writedata ((char *) data -> dofTree, i);
	curoffset += i;

	j = (GLint) objData.dofTree - (GLint) data -> dofTree;
	for (i = 0; i < objData.TotalCoord; i++) {
		k = (GLint) data -> VertexCoord[i].dataptr;
		if (k) {
			k += j;
			data -> VertexCoord[i].dataptr = (void *) k;
		}
	}
	glReleaseMemory ((char *) data -> dofTree);
}

GLint CHOBWriter::SaveBeadPolygon (GLbeadPolygon *poly, GLObjectData *data)
{
	poly -> subface = (GLbeadTree *) SaveBeadList (poly -> subface, data);
	GLint i = curoffset;
	GLint j = sizeof (GLbeadPolygon) + (poly -> totalVertices * sizeof (GLint));
	out.writedata ((char *) poly, j);
	curoffset += j;

	if (poly -> faceType & FACE_USE_DYNAMIC_VERTEX) {
		if (poly -> totalVertices > 2) {
			GlobalDynamicPolygon[TotalDynamicPolygon].poly = (GLbeadPolygon *) i;

// polygon index points to vertex index
// dynamic polygon index must points to coord index
			GLint k;
			k = poly -> vertices[0] / sizeof (GLPolyVertex);
			GlobalDynamicPolygon[TotalDynamicPolygon].vertices[0] = data -> VertexList[k].vtxindex;
			GlobalDynamicPolygon[TotalDynamicPolygon].vertices[0] *= sizeof (GLvertexCoord);

			k = poly -> vertices[1] / sizeof (GLPolyVertex);
			GlobalDynamicPolygon[TotalDynamicPolygon].vertices[1] = data -> VertexList[k].vtxindex;
			GlobalDynamicPolygon[TotalDynamicPolygon].vertices[1] *= sizeof (GLvertexCoord);

			k = poly -> vertices[2] / sizeof (GLPolyVertex);
			GlobalDynamicPolygon[TotalDynamicPolygon].vertices[2] = data -> VertexList[k].vtxindex;
			GlobalDynamicPolygon[TotalDynamicPolygon].vertices[2] *= sizeof (GLvertexCoord);

			TotalDynamicPolygon++;
		}
	}
	glReleaseMemory ((char *) poly);
	return i;
}

GLint CHOBWriter::SaveBeadList (GLbeadTree *bead, GLObjectData *data)
{
	if (bead) {
		bead -> beadElement = (GLbeadPolygon *)
					SaveBeadPolygon ((GLbeadPolygon *) bead -> beadElement, data);
		bead -> next = (GLbeadTree *) SaveBeadList (bead -> next, data);
		bead -> child = 0;	// no child 

		GLint i = curoffset;
		out.writedata ((char *) bead, sizeof (GLbeadTree));
		curoffset += sizeof (GLbeadTree);
		glReleaseMemory ((char *) bead);
		return i;
	}
	return 0;
}

GLint CHOBWriter::SaveBeadTree (GLbeadTree *bead, GLObjectData *data)
{
	if (bead) {
		GLint	i;
		switch (bead -> type) {
			case BEAD_TYPE_GROUP:
			case BEAD_TYPE_OBJECT:
			case BEAD_TYPE_BSP:
			case BEAD_TYPE_DOF:
			case BEAD_TYPE_SWITCH:
			case BEAD_TYPE_OBJECT_SLOT:
// no need to do anything
				break;
			case BEAD_TYPE_POLYGON:
			case BEAD_TYPE_POLYGON_BSP:
				bead -> beadElement = (void *) 
					SaveBeadPolygon ((GLbeadPolygon *) bead -> beadElement, data);
				break;
			case BEAD_TYPE_LINE_LIST:
				bead -> beadElement = (void *)
					SaveBeadList ((GLbeadTree *) bead -> beadElement, data);
				break;
			case BEAD_TYPE_BOUNDING_BOX:
				out.writedata ((char *) bead -> beadElement, sizeof (GLbeadBoundingBox));
				glReleaseMemory ((char *) bead -> beadElement);
				bead -> beadElement = (void *) curoffset;
				curoffset += sizeof (GLbeadBoundingBox);
				break;
			case BEAD_TYPE_BOUNDING_SPHERE:
				out.writedata ((char *) bead -> beadElement, sizeof (GLbeadBoundingSphere));
				glReleaseMemory ((char *) bead -> beadElement);
				bead -> beadElement = (void *) curoffset;
				curoffset += sizeof (GLbeadBoundingSphere);
				break;
		}

		bead -> next = (GLbeadTree *) SaveBeadTree (bead -> next, data);
		bead -> child = (GLbeadTree *) SaveBeadTree (bead -> child, data);

		i = curoffset;
		out.writedata ((char *) bead, sizeof (GLbeadTree));
		curoffset += sizeof (GLbeadTree);
		glReleaseMemory ((char *) bead);
		return i;
	}
	return 0;
}