/* Copyright (C) 1996-1997 Id Software, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA See file, 'COPYING', for details. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifdef HAVE_STRING_H # include #endif #ifdef HAVE_STRINGS_H # include #endif #include #include #include "QF/qendian.h" #include "QF/sys.h" #include "bsp5.h" int headclipnode; int firstface; //=========================================================================== /* ================== FindFinalPlane Used to find plane index numbers for clip nodes read from child processes ================== */ int FindFinalPlane (dplane_t *p) { int i; dplane_t *dplane; for (i = 0, dplane = bsp->planes; i < bsp->numplanes; i++, dplane++) { if (p->type != dplane->type) continue; if (p->dist != dplane->dist) continue; if (p->normal[0] != dplane->normal[0]) continue; if (p->normal[1] != dplane->normal[1]) continue; if (p->normal[2] != dplane->normal[2]) continue; return i; } // // new plane // if (bsp->numplanes == MAX_MAP_PLANES) Sys_Error ("numplanes == MAX_MAP_PLANES"); dplane = &bsp->planes[bsp->numplanes]; *dplane = *p; bsp->numplanes++; return bsp->numplanes - 1; } int planemapping[MAX_MAP_PLANES]; void WriteNodePlanes_r (node_t * node) { plane_t *plane; dplane_t *dplane; if (node->planenum == -1) return; if (planemapping[node->planenum] == -1) { // a new plane planemapping[node->planenum] = bsp->numplanes; if (bsp->numplanes == MAX_MAP_PLANES) Sys_Error ("numplanes == MAX_MAP_PLANES"); plane = &planes[node->planenum]; dplane = &bsp->planes[bsp->numplanes]; dplane->normal[0] = plane->normal[0]; dplane->normal[1] = plane->normal[1]; dplane->normal[2] = plane->normal[2]; dplane->dist = plane->dist; dplane->type = plane->type; bsp->numplanes++; } node->outputplanenum = planemapping[node->planenum]; WriteNodePlanes_r (node->children[0]); WriteNodePlanes_r (node->children[1]); } /* ================== WriteNodePlanes ================== */ void WriteNodePlanes (node_t * nodes) { memset (planemapping, -1, sizeof (planemapping)); WriteNodePlanes_r (nodes); } //=========================================================================== /* ================== WriteClipNodes_r ================== */ int WriteClipNodes_r (node_t * node) { int i, c; dclipnode_t *cn; int num; // FIXME: free more stuff? if (node->planenum == -1) { num = node->contents; free (node); return num; } // emit a clipnode c = bsp->numclipnodes; cn = &bsp->clipnodes[bsp->numclipnodes]; bsp->numclipnodes++; cn->planenum = node->outputplanenum; for (i = 0; i < 2; i++) cn->children[i] = WriteClipNodes_r (node->children[i]); free (node); return c; } /* ================== WriteClipNodes Called after the clipping hull is completed. Generates a disk format representation and frees the original memory. ================== */ void WriteClipNodes (node_t * nodes) { headclipnode = bsp->numclipnodes; WriteClipNodes_r (nodes); } //=========================================================================== /* ================== WriteLeaf ================== */ void WriteLeaf (node_t * node) { face_t **fp, *f; dleaf_t *leaf_p; // emit a leaf leaf_p = &bsp->leafs[bsp->numleafs]; bsp->numleafs++; leaf_p->contents = node->contents; // // write bounding box info // VectorCopy (node->mins, leaf_p->mins); VectorCopy (node->maxs, leaf_p->maxs); leaf_p->visofs = -1; // no vis info yet // // write the marksurfaces // leaf_p->firstmarksurface = bsp->nummarksurfaces; for (fp = node->markfaces; *fp; fp++) { // emit a marksurface if (bsp->nummarksurfaces == MAX_MAP_MARKSURFACES) Sys_Error ("nummarksurfaces == MAX_MAP_MARKSURFACES"); f = *fp; do { bsp->marksurfaces[bsp->nummarksurfaces] = f->outputnumber; bsp->nummarksurfaces++; f = f->original; // grab tjunction split faces } while (f); } leaf_p->nummarksurfaces = bsp->nummarksurfaces - leaf_p->firstmarksurface; } /* ================== WriteDrawNodes_r ================== */ void WriteDrawNodes_r (node_t * node) { dnode_t *n; int i; // emit a node if (bsp->numnodes == MAX_MAP_NODES) Sys_Error ("numnodes == MAX_MAP_NODES"); n = &bsp->nodes[bsp->numnodes]; bsp->numnodes++; VectorCopy (node->mins, n->mins); VectorCopy (node->maxs, n->maxs); n->planenum = node->outputplanenum; n->firstface = node->firstface; n->numfaces = node->numfaces; // // recursively output the other nodes // for (i = 0; i < 2; i++) { if (node->children[i]->planenum == -1) { if (node->children[i]->contents == CONTENTS_SOLID) n->children[i] = -1; else { n->children[i] = -(bsp->numleafs + 1); WriteLeaf (node->children[i]); } } else { n->children[i] = bsp->numnodes; WriteDrawNodes_r (node->children[i]); } } } /* ================== WriteDrawNodes ================== */ void WriteDrawNodes (node_t * headnode) { int i; int start; dmodel_t *bm; #if 0 if (headnode->contents < 0) Sys_Error ("FinishBSPModel: empty model"); #endif // emit a model if (bsp->nummodels == MAX_MAP_MODELS) Sys_Error ("nummodels == MAX_MAP_MODELS"); bm = &bsp->models[bsp->nummodels]; bsp->nummodels++; bm->headnode[0] = bsp->numnodes; bm->firstface = firstface; bm->numfaces = bsp->numfaces - firstface; firstface = bsp->numfaces; start = bsp->numleafs; if (headnode->contents < 0) WriteLeaf (headnode); else WriteDrawNodes_r (headnode); bm->visleafs = bsp->numleafs - start; for (i = 0; i < 3; i++) { bm->mins[i] = headnode->mins[i] + SIDESPACE + 1; // remove the // padding bm->maxs[i] = headnode->maxs[i] - SIDESPACE - 1; } // FIXME: are all the children decendant of padded nodes? } /* ================== BumpModel Used by the clipping hull processes that only need to store headclipnode ================== */ void BumpModel (int hullnum) { dmodel_t *bm; // emit a model if (bsp->nummodels == MAX_MAP_MODELS) Sys_Error ("nummodels == MAX_MAP_MODELS"); bm = &bsp->models[bsp->nummodels]; bsp->nummodels++; bm->headnode[hullnum] = headclipnode; } //============================================================================= typedef struct { char identification[4]; // should be WAD2 int numlumps; int infotableofs; } wadinfo_t; typedef struct { int filepos; int disksize; int size; // uncompressed char type; char compression; char pad1, pad2; char name[16]; // must be null terminated } lumpinfo_t; QFile *texfile; wadinfo_t wadinfo; lumpinfo_t *lumpinfo; void CleanupName (char *in, char *out) { int i; for (i = 0; i < 16; i++) { if (!in[i]) break; out[i] = toupper (in[i]); } for (; i < 16; i++) out[i] = 0; } /* ================= TEX_InitFromWad ================= */ void TEX_InitFromWad (char *path) { int i; texfile = Qopen (path, "rb"); Qread (texfile, &wadinfo, sizeof (wadinfo)); if (strncmp (wadinfo.identification, "WAD2", 4)) Sys_Error ("TEX_InitFromWad: %s isn't a wadfile", path); wadinfo.numlumps = LittleLong (wadinfo.numlumps); wadinfo.infotableofs = LittleLong (wadinfo.infotableofs); Qseek (texfile, wadinfo.infotableofs, SEEK_SET); lumpinfo = malloc (wadinfo.numlumps * sizeof (lumpinfo_t)); Qread (texfile, lumpinfo, wadinfo.numlumps * sizeof (lumpinfo_t)); for (i = 0; i < wadinfo.numlumps; i++) { CleanupName (lumpinfo[i].name, lumpinfo[i].name); lumpinfo[i].filepos = LittleLong (lumpinfo[i].filepos); lumpinfo[i].disksize = LittleLong (lumpinfo[i].disksize); } } /* ================== LoadLump ================== */ int LoadLump (char *name, byte * dest) { int i; char cname[16]; CleanupName (name, cname); for (i = 0; i < wadinfo.numlumps; i++) { if (!strcmp (cname, lumpinfo[i].name)) { Qseek (texfile, lumpinfo[i].filepos, SEEK_SET); Qread (texfile, dest, lumpinfo[i].disksize); return lumpinfo[i].disksize; } } printf ("WARNING: texture %s not found\n", name); return 0; } /* ================== AddAnimatingTextures ================== */ void AddAnimatingTextures (void) { int base; int i, j, k; char name[32]; base = nummiptex; for (i = 0; i < base; i++) { if (miptex[i][0] != '+') continue; strcpy (name, miptex[i]); for (j = 0; j < 20; j++) { if (j < 10) name[1] = '0' + j; else name[1] = 'A' + j - 10; // alternate animation // see if this name exists in the wadfile for (k = 0; k < wadinfo.numlumps; k++) if (!strcmp (name, lumpinfo[k].name)) { FindMiptex (name); // add to the miptex list break; } } } printf ("added %i texture frames\n", nummiptex - base); } /* ================== WriteMiptex ================== */ void WriteMiptex (void) { int i, len; byte *data; dmiptexlump_t *l; char *path; char fullpath[1024]; path = ValueForKey (&entities[0], "_wad"); if (!path || !path[0]) { path = ValueForKey (&entities[0], "wad"); if (!path || !path[0]) { printf ("WARNING: no wadfile specified\n"); bsp->texdatasize = 0; return; } } sprintf (fullpath, "%s/%s", /* FIXME gamedir */ ".", path); TEX_InitFromWad (fullpath); AddAnimatingTextures (); l = (dmiptexlump_t *) bsp->texdata; data = (byte *) & l->dataofs[nummiptex]; l->nummiptex = nummiptex; for (i = 0; i < nummiptex; i++) { l->dataofs[i] = data - (byte *) l; len = LoadLump (miptex[i], data); if (data + len - bsp->texdata >= MAX_MAP_MIPTEX) Sys_Error ("Textures exceeded MAX_MAP_MIPTEX"); if (!len) l->dataofs[i] = -1; // didn't find the texture data += len; } bsp->texdatasize = data - bsp->texdata; } //=========================================================================== /* ================== BeginBSPFile ================== */ void BeginBSPFile (void) { // edge 0 is not used, because 0 can't be negated bsp->numedges = 1; // leaf 0 is common solid with no faces bsp->numleafs = 1; bsp->leafs[0].contents = CONTENTS_SOLID; firstface = 0; } /* ================== FinishBSPFile ================== */ void FinishBSPFile (void) { QFile *f; printf ("--- FinishBSPFile ---\n"); printf ("WriteBSPFile: %s\n", bspfilename); WriteMiptex (); // XXX PrintBSPFileSizes (); f = Qopen (bspfilename, "wb"); WriteBSPFile (bsp, f); Qclose (f); }