diff --git a/bsputil/bsputil.cc b/bsputil/bsputil.cc index 926b2c07..987b8341 100644 --- a/bsputil/bsputil.cc +++ b/bsputil/bsputil.cc @@ -541,7 +541,7 @@ main(int argc, char **argv) LoadBSPFile(source, &bspdata); - ConvertBSPFormat(&bspdata, &bspver_generic); + ConvertBSPFormat(GENERIC_BSP, &bspdata); for (i = 0; i < argc - 1; i++) { if (!strcmp(argv[i], "--compare")) { @@ -556,7 +556,7 @@ main(int argc, char **argv) strcpy(refbspname, argv[i]); DefaultExtension(refbspname, ".bsp"); LoadBSPFile(refbspname, &refbspdata); - ConvertBSPFormat(&refbspdata, &bspver_generic); + ConvertBSPFormat(GENERIC_BSP, &refbspdata); printf("comparing reference bsp %s with test bsp %s\n", refbspname, source); @@ -569,21 +569,21 @@ main(int argc, char **argv) if (!(i < argc - 1)) { Error("--convert requires an argument"); } - - const bspversion_t *fmt = nullptr; - - for (const bspversion_t *bspver : bspversions) { - if (!strcmp(argv[i], bspver->short_name)) { - fmt = bspver; - break; - } - } - - if (!fmt) { + + int fmt; + if (!strcmp(argv[i], "bsp29")) { + fmt = BSPVERSION; + } else if (!strcmp(argv[i], "bsp2")) { + fmt = BSP2VERSION; + } else if (!strcmp(argv[i], "bsp2rmq")) { + fmt = BSP2RMQVERSION; + } else if (!strcmp(argv[i], "q2bsp")) { + fmt = Q2_BSPVERSION; + } else { Error("Unsupported format %s", argv[i]); } - - ConvertBSPFormat(&bspdata, fmt); + + ConvertBSPFormat(fmt, &bspdata); StripExtension(source); strcat(source, "-"); @@ -672,7 +672,7 @@ main(int argc, char **argv) bsp2_dface_t* face = BSP_GetFace(bsp, fnum); face->texinfo = texinfonum; - ConvertBSPFormat(&bspdata, bspdata.loadversion); + ConvertBSPFormat(bspdata.loadversion, &bspdata); // Overwrite source bsp! WriteBSPFile(source, &bspdata); diff --git a/common/bspfile.cc b/common/bspfile.cc index 9f96e755..364f0e2a 100644 --- a/common/bspfile.cc +++ b/common/bspfile.cc @@ -23,45 +23,43 @@ #include -const bspversion_t bspver_generic { NO_VERSION, NO_VERSION, "mbsp", "generic BSP" }; -const bspversion_t bspver_q1 { BSPVERSION, NO_VERSION, "bsp29", "Quake BSP" }; -/* Hexen II doesn't use a separate version, but we can still use a separate tag/name for it */ -const bspversion_t bspver_h2 { BSPVERSION, NO_VERSION, "hexen2", "Hexen II BSP" }; -const bspversion_t bspver_bsp2 { BSP2VERSION, NO_VERSION, "bsp2", "Quake BSP2" }; -const bspversion_t bspver_bsp2rmq { BSP2RMQVERSION, NO_VERSION, "bsp2rmq", "Quake BSP2-RMQ" }; -const bspversion_t bspver_hl { BSPHLVERSION, NO_VERSION, "hl", "Half-Life BSP" }; -const bspversion_t bspver_q2 { Q2_BSPIDENT, Q2_BSPVERSION, "q2bsp", "Quake II BSP" }; -const bspversion_t bspver_qbism { Q2_QBISMIDENT, Q2_BSPVERSION, "qbism", "Quake II Qbism BSP" }; - static const char * -BSPVersionString(const bspversion_t *version) +BSPVersionString(int32_t version) { - if (version->name) { - return version->name; - } - static char buffers[2][20]; static int index; - char *buffer = buffers[1 & ++index]; - if (version->version != NO_VERSION) { - q_snprintf(buffer, sizeof(buffers[0]), "%d:%d", version->version, version->ident); - } else { - q_snprintf(buffer, sizeof(buffers[0]), "%d", version->version); + char *buffer; + + switch (version) { + case BSP2RMQVERSION: + return "BSP2rmq"; + case BSP2VERSION: + return "BSP2"; + case BSPHLVERSION: + return "HLBSP"; + case Q2_BSPVERSION: + return "Q2BSP"; + default: + buffer = buffers[1 & ++index]; + q_snprintf(buffer, sizeof(buffers[0]), "%d", version); + return buffer; } - return buffer; } static qboolean -BSPVersionSupported(int32_t ident, int32_t version, const bspversion_t **out_version) +BSPVersionSupported(int32_t version) { - for (const bspversion_t *bspver : bspversions) { - if (bspver->ident == ident && bspver->version == version) { - *out_version = bspver; - return true; - } + switch (version) { + case BSPVERSION: + case BSP2VERSION: + case BSP2RMQVERSION: + case BSPHLVERSION: + return true; + case Q2_BSPVERSION: + return true; + default: + return false; } - - return false; } /* @@ -570,200 +568,6 @@ void Q2_SwapBSPFile (q2bsp_t *bsp, qboolean todisk) } } -/* -============= -Q2_Qbism_SwapBSPFile - -Byte swaps all data in a bsp file. -============= -*/ -void Q2_Qbism_SwapBSPFile (q2bsp_qbism_t *bsp, qboolean todisk) -{ - int i, j; - q2_dmodel_t *d; - - - // models - for (i=0 ; inummodels ; i++) - { - d = &bsp->dmodels[i]; - - d->firstface = LittleLong (d->firstface); - d->numfaces = LittleLong (d->numfaces); - d->headnode = LittleLong (d->headnode); - - for (j=0 ; j<3 ; j++) - { - d->mins[j] = LittleFloat(d->mins[j]); - d->maxs[j] = LittleFloat(d->maxs[j]); - d->origin[j] = LittleFloat(d->origin[j]); - } - } - - // - // vertexes - // - for (i=0 ; inumvertexes ; i++) - { - for (j=0 ; j<3 ; j++) - bsp->dvertexes[i].point[j] = LittleFloat (bsp->dvertexes[i].point[j]); - } - - // - // planes - // - for (i=0 ; inumplanes ; i++) - { - for (j=0 ; j<3 ; j++) - bsp->dplanes[i].normal[j] = LittleFloat (bsp->dplanes[i].normal[j]); - bsp->dplanes[i].dist = LittleFloat (bsp->dplanes[i].dist); - bsp->dplanes[i].type = LittleLong (bsp->dplanes[i].type); - } - - // - // texinfos - // - for (i=0 ; inumtexinfo ; i++) - { - for (j=0 ; j<4 ; j++) - { - bsp->texinfo[i].vecs[0][j] = LittleFloat(bsp->texinfo[i].vecs[0][j]); - bsp->texinfo[i].vecs[1][j] = LittleFloat(bsp->texinfo[i].vecs[1][j]); - } - bsp->texinfo[i].flags = LittleLong (bsp->texinfo[i].flags); - bsp->texinfo[i].value = LittleLong (bsp->texinfo[i].value); - bsp->texinfo[i].nexttexinfo = LittleLong (bsp->texinfo[i].nexttexinfo); - } - - // - // faces - // - for (i=0 ; inumfaces ; i++) - { - bsp->dfaces[i].texinfo = LittleLong (bsp->dfaces[i].texinfo); - bsp->dfaces[i].planenum = LittleLong (bsp->dfaces[i].planenum); - bsp->dfaces[i].side = LittleLong (bsp->dfaces[i].side); - bsp->dfaces[i].lightofs = LittleLong (bsp->dfaces[i].lightofs); - bsp->dfaces[i].firstedge = LittleLong (bsp->dfaces[i].firstedge); - bsp->dfaces[i].numedges = LittleLong (bsp->dfaces[i].numedges); - } - - // - // nodes - // - for (i=0 ; inumnodes ; i++) - { - bsp->dnodes[i].planenum = LittleLong (bsp->dnodes[i].planenum); - for (j=0 ; j<3 ; j++) - { - bsp->dnodes[i].mins[j] = LittleFloat (bsp->dnodes[i].mins[j]); - bsp->dnodes[i].maxs[j] = LittleFloat (bsp->dnodes[i].maxs[j]); - } - bsp->dnodes[i].children[0] = LittleLong (bsp->dnodes[i].children[0]); - bsp->dnodes[i].children[1] = LittleLong (bsp->dnodes[i].children[1]); - bsp->dnodes[i].firstface = LittleLong (bsp->dnodes[i].firstface); - bsp->dnodes[i].numfaces = LittleLong (bsp->dnodes[i].numfaces); - } - - // - // leafs - // - for (i=0 ; inumleafs ; i++) - { - bsp->dleafs[i].contents = LittleLong (bsp->dleafs[i].contents); - bsp->dleafs[i].cluster = LittleLong (bsp->dleafs[i].cluster); - bsp->dleafs[i].area = LittleLong (bsp->dleafs[i].area); - for (j=0 ; j<3 ; j++) - { - bsp->dleafs[i].mins[j] = LittleFloat (bsp->dleafs[i].mins[j]); - bsp->dleafs[i].maxs[j] = LittleFloat (bsp->dleafs[i].maxs[j]); - } - - bsp->dleafs[i].firstleafface = LittleLong (bsp->dleafs[i].firstleafface); - bsp->dleafs[i].numleaffaces = LittleLong (bsp->dleafs[i].numleaffaces); - bsp->dleafs[i].firstleafbrush = LittleLong (bsp->dleafs[i].firstleafbrush); - bsp->dleafs[i].numleafbrushes = LittleLong (bsp->dleafs[i].numleafbrushes); - } - - // - // leaffaces - // - for (i=0 ; inumleaffaces ; i++) - bsp->dleaffaces[i] = LittleLong (bsp->dleaffaces[i]); - - // - // leafbrushes - // - for (i=0 ; inumleafbrushes ; i++) - bsp->dleafbrushes[i] = LittleLong (bsp->dleafbrushes[i]); - - // - // surfedges - // - for (i=0 ; inumsurfedges ; i++) - bsp->dsurfedges[i] = LittleLong (bsp->dsurfedges[i]); - - // - // edges - // - for (i=0 ; inumedges ; i++) - { - bsp->dedges[i].v[0] = LittleLong (bsp->dedges[i].v[0]); - bsp->dedges[i].v[1] = LittleLong (bsp->dedges[i].v[1]); - } - - // - // brushes - // - for (i=0 ; inumbrushes ; i++) - { - bsp->dbrushes[i].firstside = LittleLong (bsp->dbrushes[i].firstside); - bsp->dbrushes[i].numsides = LittleLong (bsp->dbrushes[i].numsides); - bsp->dbrushes[i].contents = LittleLong (bsp->dbrushes[i].contents); - } - - // - // areas - // - for (i=0 ; inumareas ; i++) - { - bsp->dareas[i].numareaportals = LittleLong (bsp->dareas[i].numareaportals); - bsp->dareas[i].firstareaportal = LittleLong (bsp->dareas[i].firstareaportal); - } - - // - // areasportals - // - for (i=0 ; inumareaportals ; i++) - { - bsp->dareaportals[i].portalnum = LittleLong (bsp->dareaportals[i].portalnum); - bsp->dareaportals[i].otherarea = LittleLong (bsp->dareaportals[i].otherarea); - } - - // - // brushsides - // - for (i=0 ; inumbrushsides ; i++) - { - bsp->dbrushsides[i].planenum = LittleLong (bsp->dbrushsides[i].planenum); - bsp->dbrushsides[i].texinfo = LittleLong (bsp->dbrushsides[i].texinfo); - } - - // - // visibility - // - if (todisk) - j = bsp->dvis->numclusters; - else - j = LittleLong(bsp->dvis->numclusters); - bsp->dvis->numclusters = LittleLong (bsp->dvis->numclusters); - for (i=0 ; idvis->bitofs[i][0] = LittleLong (bsp->dvis->bitofs[i][0]); - bsp->dvis->bitofs[i][1] = LittleLong (bsp->dvis->bitofs[i][1]); - } -} - /* * ============= * SwapBSPFile @@ -773,17 +577,15 @@ void Q2_Qbism_SwapBSPFile (q2bsp_qbism_t *bsp, qboolean todisk) static void SwapBSPFile(bspdata_t *bspdata, swaptype_t swap) { - if (bspdata->version == &bspver_q2) { + if (bspdata->version == Q2_BSPVERSION) { q2bsp_t *bsp = &bspdata->data.q2bsp; + Q2_SwapBSPFile(bsp, swap == TO_DISK); - return; - } else if (bspdata->version == &bspver_qbism) { - q2bsp_qbism_t *bsp = &bspdata->data.q2bsp_qbism; - Q2_Qbism_SwapBSPFile(bsp, swap == TO_DISK); + return; } - if (bspdata->version == &bspver_q1 || bspdata->version == &bspver_h2 || bspdata->version == &bspver_hl) { + if (bspdata->version == BSPVERSION || bspdata->version == BSPHLVERSION) { bsp29_t *bsp = &bspdata->data.bsp29; SwapBSPVertexes(bsp->numvertexes, bsp->dvertexes); @@ -802,7 +604,7 @@ SwapBSPFile(bspdata_t *bspdata, swaptype_t swap) return; } - if (bspdata->version == &bspver_bsp2rmq) { + if (bspdata->version == BSP2RMQVERSION) { bsp2rmq_t *bsp = &bspdata->data.bsp2rmq; SwapBSPVertexes(bsp->numvertexes, bsp->dvertexes); @@ -821,7 +623,7 @@ SwapBSPFile(bspdata_t *bspdata, swaptype_t swap) return; } - if (bspdata->version == &bspver_bsp2) { + if (bspdata->version == BSP2VERSION) { bsp2_t *bsp = &bspdata->data.bsp2; SwapBSPVertexes(bsp->numvertexes, bsp->dvertexes); @@ -1013,33 +815,6 @@ Q2BSPtoM_Leafs(const q2_dleaf_t *dleafsq2, int numleafs) { return newdata; } -static mleaf_t * -Q2BSP_QBSPtoM_Leafs(const q2_dleaf_qbism_t *dleafsq2, int numleafs) { - const q2_dleaf_qbism_t *dleafq2 = dleafsq2; - mleaf_t *newdata, *mleaf; - int i, j; - - newdata = mleaf = (mleaf_t *)calloc(numleafs, sizeof(*mleaf)); - - for (i = 0; i < numleafs; i++, dleafq2++, mleaf++) { - mleaf->contents = dleafq2->contents; - mleaf->cluster = dleafq2->cluster; - mleaf->area = dleafq2->area; - - for (j = 0; j < 3; j++) { - mleaf->mins[j] = dleafq2->mins[j]; - mleaf->maxs[j] = dleafq2->maxs[j]; - } - mleaf->firstmarksurface = dleafq2->firstleafface; - mleaf->nummarksurfaces = dleafq2->numleaffaces; - - mleaf->firstleafbrush = dleafq2->firstleafbrush; - mleaf->numleafbrushes = dleafq2->numleafbrushes; - } - - return newdata; -} - static q2_dleaf_t * MBSPtoQ2_Leafs(const mleaf_t *mleafs, int numleafs) { const mleaf_t *mleaf = mleafs; @@ -1067,33 +842,6 @@ MBSPtoQ2_Leafs(const mleaf_t *mleafs, int numleafs) { return newdata; } -static q2_dleaf_qbism_t * -MBSPtoQ2_Qbism_Leafs(const mleaf_t *mleafs, int numleafs) { - const mleaf_t *mleaf = mleafs; - q2_dleaf_qbism_t *newdata, *dleafq2; - int i, j; - - newdata = dleafq2 = (q2_dleaf_qbism_t *)calloc(numleafs, sizeof(*dleafq2)); - - for (i = 0; i < numleafs; i++, mleaf++, dleafq2++) { - dleafq2->contents = mleaf->contents; - dleafq2->cluster = mleaf->cluster; - dleafq2->area = mleaf->area; - - for (j = 0; j < 3; j++) { - dleafq2->mins[j] = mleaf->mins[j]; - dleafq2->maxs[j] = mleaf->maxs[j]; - } - dleafq2->firstleafface = mleaf->firstmarksurface; - dleafq2->numleaffaces = mleaf->nummarksurfaces; - - dleafq2->firstleafbrush = mleaf->firstleafbrush; - dleafq2->numleafbrushes = mleaf->numleafbrushes; - } - - return newdata; -} - static bsp2_dnode_t * Q2BSPto2_Nodes(const q2_dnode_t *dnodesq2, int numnodes) { const q2_dnode_t *dnodeq2 = dnodesq2; @@ -1162,28 +910,6 @@ Q2BSPto2_Faces(const q2_dface_t *dfacesq2, int numfaces) { return newdata; } -static bsp2_dface_t * -Q2BSP_QBSPto2_Faces(const q2_dface_qbism_t *dfacesq2, int numfaces) { - const q2_dface_qbism_t *dfaceq2 = dfacesq2; - bsp2_dface_t *newdata, *dface2; - int i, j; - - newdata = dface2 = static_cast(malloc(numfaces * sizeof(*dface2))); - - for (i = 0; i < numfaces; i++, dfaceq2++, dface2++) { - dface2->planenum = dfaceq2->planenum; - dface2->side = dfaceq2->side; - dface2->firstedge = dfaceq2->firstedge; - dface2->numedges = dfaceq2->numedges; - dface2->texinfo = dfaceq2->texinfo; - for (j = 0; j < MAXLIGHTMAPS; j++) - dface2->styles[j] = dfaceq2->styles[j]; - dface2->lightofs = dfaceq2->lightofs; - } - - return newdata; -} - static q2_dface_t * BSP2toQ2_Faces(const bsp2_dface_t *dfaces2, int numfaces) { const bsp2_dface_t *dface2 = dfaces2; @@ -1206,28 +932,6 @@ BSP2toQ2_Faces(const bsp2_dface_t *dfaces2, int numfaces) { return newdata; } -static q2_dface_qbism_t * -BSP2toQ2_Qbism_Faces(const bsp2_dface_t *dfaces2, int numfaces) { - const bsp2_dface_t *dface2 = dfaces2; - q2_dface_qbism_t *newdata, *dfaceq2; - int i, j; - - newdata = dfaceq2 = static_cast(malloc(numfaces * sizeof(*dfaceq2))); - - for (i = 0; i < numfaces; i++, dface2++, dfaceq2++) { - dfaceq2->planenum = dface2->planenum; - dfaceq2->side = dface2->side; - dfaceq2->firstedge = dface2->firstedge; - dfaceq2->numedges = dface2->numedges; - dfaceq2->texinfo = dface2->texinfo; - for (j = 0; j < MAXLIGHTMAPS; j++) - dfaceq2->styles[j] = dface2->styles[j]; - dfaceq2->lightofs = dface2->lightofs; - } - - return newdata; -} - static gtexinfo_t * Q2BSPtoM_Texinfo(const q2_texinfo_t *dtexinfosq2, int numtexinfos) { const q2_texinfo_t *dtexinfoq2 = dtexinfosq2; @@ -1713,37 +1417,9 @@ static bsp2_dnode_t *BSP2_CopyNodes(const bsp2_dnode_t *dnodes, int numnodes) return (bsp2_dnode_t *)CopyArray(dnodes, numnodes, sizeof(*dnodes)); } -static uint32_t *Q2BSPtoM_CopyLeafBrushes(const uint16_t *leafbrushes, int count) +static uint16_t *Q2BSP_CopyLeafBrushes(const uint16_t *leafbrushes, int count) { - const uint16_t *leafbrush = leafbrushes; - uint32_t *newdata, *leafbrushes2; - int i; - - newdata = leafbrushes2 = static_cast(malloc(count * sizeof(*leafbrushes2))); - - for (i = 0; i < count; i++, leafbrush++, leafbrushes2++) - *leafbrushes2 = *leafbrush; - - return newdata; -} - -static uint16_t *MBSPtoQ2_CopyLeafBrushes(const uint32_t *leafbrushes, int count) -{ - const uint32_t *leafbrush = leafbrushes; - uint16_t *newdata, *leafbrushes2; - int i; - - newdata = leafbrushes2 = static_cast(malloc(count * sizeof(*leafbrushes2))); - - for (i = 0; i < count; i++, leafbrush++, leafbrushes2++) - *leafbrushes2 = *leafbrush; - - return newdata; -} - -static uint32_t *Q2BSP_Qbism_CopyLeafBrushes(const uint32_t *leafbrushes, int count) -{ - return (uint32_t *)CopyArray(leafbrushes, count, sizeof(*leafbrushes)); + return (uint16_t *)CopyArray(leafbrushes, count, sizeof(*leafbrushes)); } static darea_t *Q2BSP_CopyAreas(const darea_t *areas, int count) @@ -1761,41 +1437,9 @@ static dbrush_t *Q2BSP_CopyBrushes(const dbrush_t *brushes, int count) return (dbrush_t *)CopyArray(brushes, count, sizeof(*brushes)); } -static q2_dbrushside_qbism_t *Q2BSPtoM_CopyBrushSides(const dbrushside_t *dbrushsides, int count) +static dbrushside_t *Q2BSP_CopyBrushSides(const dbrushside_t *dbrushsides, int count) { - const dbrushside_t *brushside = dbrushsides; - q2_dbrushside_qbism_t *newdata, *brushsides2; - int i; - - newdata = brushsides2 = static_cast(malloc(count * sizeof(*brushsides2))); - - for (i = 0; i < count; i++, brushside++, brushsides2++) { - brushsides2->planenum = brushside->planenum; - brushsides2->texinfo = brushside->texinfo; - } - - return newdata; -} - -static q2_dbrushside_qbism_t *Q2BSP_Qbism_CopyBrushSides(const q2_dbrushside_qbism_t *brushsides, int count) -{ - return (q2_dbrushside_qbism_t *)CopyArray(brushsides, count, sizeof(*brushsides)); -} - -static dbrushside_t *MBSPtoQ2_CopyBrushSides(const q2_dbrushside_qbism_t *dbrushsides, int count) -{ - const q2_dbrushside_qbism_t *brushside = dbrushsides; - dbrushside_t *newdata, *brushsides2; - int i; - - newdata = brushsides2 = static_cast(malloc(count * sizeof(*brushsides2))); - - for (i = 0; i < count; i++, brushside++, brushsides2++) { - brushsides2->planenum = brushside->planenum; - brushsides2->texinfo = brushside->texinfo; - } - - return newdata; + return (dbrushside_t *)CopyArray(dbrushsides, count, sizeof(*dbrushsides)); } @@ -1888,29 +1532,6 @@ static void FreeQ2BSP(q2bsp_t *bsp) memset(bsp, 0, sizeof(*bsp)); } -static void FreeQ2BSP_QBSP(q2bsp_qbism_t *bsp) -{ - free(bsp->dmodels); - free(bsp->dvis); - free(bsp->dlightdata); - free(bsp->dentdata); - free(bsp->dleafs); - free(bsp->dplanes); - free(bsp->dvertexes); - free(bsp->dnodes); - free(bsp->texinfo); - free(bsp->dfaces); - free(bsp->dedges); - free(bsp->dleaffaces); - free(bsp->dleafbrushes); - free(bsp->dsurfedges); - free(bsp->dareas); - free(bsp->dareaportals); - free(bsp->dbrushes); - free(bsp->dbrushsides); - memset(bsp, 0, sizeof(*bsp)); -} - static void FreeMBSP(mbsp_t *bsp) { free(bsp->dmodels); @@ -1937,13 +1558,6 @@ static void FreeMBSP(mbsp_t *bsp) memset(bsp, 0, sizeof(*bsp)); } -inline void -ConvertBSPToMFormatComplete(const bspversion_t **mbsp_loadversion, const bspversion_t *version, bspdata_t *bspdata) -{ - *mbsp_loadversion = bspdata->version; - bspdata->version = version; -} - /* * ========================================================================= * ConvertBSPFormat @@ -1952,547 +1566,440 @@ ConvertBSPToMFormatComplete(const bspversion_t **mbsp_loadversion, const bspvers * ========================================================================= */ void -ConvertBSPFormat(bspdata_t *bspdata, const bspversion_t *to_version) +ConvertBSPFormat(int32_t version, bspdata_t *bspdata) { - if (bspdata->version == to_version) + if (bspdata->version == version) return; // conversions to GENERIC_BSP - if (to_version == &bspver_generic) { - if (bspdata->version == &bspver_q1 || bspdata->version == &bspver_h2 || bspdata->version == &bspver_hl) { - const bsp29_t *bsp29 = &bspdata->data.bsp29; - mbsp_t *mbsp = &bspdata->data.mbsp; - - memset(mbsp, 0, sizeof(*mbsp)); - - // copy counts - mbsp->nummodels = bsp29->nummodels; - mbsp->visdatasize = bsp29->visdatasize; - mbsp->lightdatasize = bsp29->lightdatasize; - mbsp->texdatasize = bsp29->texdatasize; - mbsp->entdatasize = bsp29->entdatasize; - mbsp->numleafs = bsp29->numleafs; - mbsp->numplanes = bsp29->numplanes; - mbsp->numvertexes = bsp29->numvertexes; - mbsp->numnodes = bsp29->numnodes; - mbsp->numtexinfo = bsp29->numtexinfo; - mbsp->numfaces = bsp29->numfaces; - mbsp->numclipnodes = bsp29->numclipnodes; - mbsp->numedges = bsp29->numedges; - mbsp->numleaffaces = bsp29->nummarksurfaces; - mbsp->numsurfedges = bsp29->numsurfedges; - - // copy or convert data - mbsp->dmodels = BSP29_CopyModels(bsp29->dmodels, bsp29->nummodels); - mbsp->dvisdata = BSP29_CopyVisData(bsp29->dvisdata, bsp29->visdatasize); - mbsp->dlightdata = BSP29_CopyLightData(bsp29->dlightdata, bsp29->lightdatasize); - mbsp->dtexdata = BSP29_CopyTexData(bsp29->dtexdata, bsp29->texdatasize); - mbsp->dentdata = BSP29_CopyEntData(bsp29->dentdata, bsp29->entdatasize); - mbsp->dleafs = BSP29toM_Leafs(bsp29->dleafs, bsp29->numleafs); - mbsp->dplanes = BSP29_CopyPlanes(bsp29->dplanes, bsp29->numplanes); - mbsp->dvertexes = BSP29_CopyVertexes(bsp29->dvertexes, bsp29->numvertexes); - mbsp->dnodes = BSP29to2_Nodes(bsp29->dnodes, bsp29->numnodes); - mbsp->texinfo = BSP29toM_Texinfo(bsp29->texinfo, bsp29->numtexinfo); - mbsp->dfaces = BSP29to2_Faces(bsp29->dfaces, bsp29->numfaces); - mbsp->dclipnodes = BSP29to2_Clipnodes(bsp29->dclipnodes, bsp29->numclipnodes); - mbsp->dedges = BSP29to2_Edges(bsp29->dedges, bsp29->numedges); - mbsp->dleaffaces = BSP29to2_Marksurfaces(bsp29->dmarksurfaces, bsp29->nummarksurfaces); - mbsp->dsurfedges = BSP29_CopySurfedges(bsp29->dsurfedges, bsp29->numsurfedges); - - /* Free old data */ - FreeBSP29((bsp29_t *)bsp29); - - /* Conversion complete! */ - ConvertBSPToMFormatComplete(&mbsp->loadversion, to_version, bspdata); - - return; - } - else if (bspdata->version == &bspver_q2) { - const q2bsp_t *q2bsp = &bspdata->data.q2bsp; - mbsp_t *mbsp = &bspdata->data.mbsp; + if ((bspdata->version == BSPVERSION || bspdata->version == BSPHLVERSION) && version == GENERIC_BSP) { + const bsp29_t *bsp29 = &bspdata->data.bsp29; + mbsp_t *mbsp = &bspdata->data.mbsp; - memset(mbsp, 0, sizeof(*mbsp)); + memset(mbsp, 0, sizeof(*mbsp)); - // copy counts - mbsp->nummodels = q2bsp->nummodels; - mbsp->visdatasize = q2bsp->visdatasize; - mbsp->lightdatasize = q2bsp->lightdatasize; - mbsp->entdatasize = q2bsp->entdatasize; - mbsp->numleafs = q2bsp->numleafs; - mbsp->numplanes = q2bsp->numplanes; - mbsp->numvertexes = q2bsp->numvertexes; - mbsp->numnodes = q2bsp->numnodes; - mbsp->numtexinfo = q2bsp->numtexinfo; - mbsp->numfaces = q2bsp->numfaces; - mbsp->numedges = q2bsp->numedges; - mbsp->numleaffaces = q2bsp->numleaffaces; - mbsp->numleafbrushes = q2bsp->numleafbrushes; - mbsp->numsurfedges = q2bsp->numsurfedges; - mbsp->numareas = q2bsp->numareas; - mbsp->numareaportals = q2bsp->numareaportals; - mbsp->numbrushes = q2bsp->numbrushes; - mbsp->numbrushsides = q2bsp->numbrushsides; + // copy counts + mbsp->nummodels = bsp29->nummodels; + mbsp->visdatasize = bsp29->visdatasize; + mbsp->lightdatasize = bsp29->lightdatasize; + mbsp->texdatasize = bsp29->texdatasize; + mbsp->entdatasize = bsp29->entdatasize; + mbsp->numleafs = bsp29->numleafs; + mbsp->numplanes = bsp29->numplanes; + mbsp->numvertexes = bsp29->numvertexes; + mbsp->numnodes = bsp29->numnodes; + mbsp->numtexinfo = bsp29->numtexinfo; + mbsp->numfaces = bsp29->numfaces; + mbsp->numclipnodes = bsp29->numclipnodes; + mbsp->numedges = bsp29->numedges; + mbsp->numleaffaces = bsp29->nummarksurfaces; + mbsp->numsurfedges = bsp29->numsurfedges; - // copy or convert data - mbsp->dmodels = Q2BSPtoM_Models(q2bsp->dmodels, q2bsp->nummodels); - mbsp->dvisdata = (uint8_t *)CopyArray(q2bsp->dvis, q2bsp->visdatasize, 1); - mbsp->dlightdata = BSP29_CopyLightData(q2bsp->dlightdata, q2bsp->lightdatasize); - mbsp->dentdata = BSP29_CopyEntData(q2bsp->dentdata, q2bsp->entdatasize); - mbsp->dleafs = Q2BSPtoM_Leafs(q2bsp->dleafs, q2bsp->numleafs); - mbsp->dplanes = BSP29_CopyPlanes(q2bsp->dplanes, q2bsp->numplanes); - mbsp->dvertexes = BSP29_CopyVertexes(q2bsp->dvertexes, q2bsp->numvertexes); - mbsp->dnodes = Q2BSPto2_Nodes(q2bsp->dnodes, q2bsp->numnodes); - mbsp->texinfo = Q2BSPtoM_Texinfo(q2bsp->texinfo, q2bsp->numtexinfo); - mbsp->dfaces = Q2BSPto2_Faces(q2bsp->dfaces, q2bsp->numfaces); - mbsp->dedges = BSP29to2_Edges(q2bsp->dedges, q2bsp->numedges); - mbsp->dleaffaces = BSP29to2_Marksurfaces(q2bsp->dleaffaces, q2bsp->numleaffaces); - mbsp->dleafbrushes = Q2BSPtoM_CopyLeafBrushes(q2bsp->dleafbrushes, q2bsp->numleafbrushes); - mbsp->dsurfedges = BSP29_CopySurfedges(q2bsp->dsurfedges, q2bsp->numsurfedges); + // copy or convert data + mbsp->dmodels = BSP29_CopyModels(bsp29->dmodels, bsp29->nummodels); + mbsp->dvisdata = BSP29_CopyVisData(bsp29->dvisdata, bsp29->visdatasize); + mbsp->dlightdata = BSP29_CopyLightData(bsp29->dlightdata, bsp29->lightdatasize); + mbsp->dtexdata = BSP29_CopyTexData(bsp29->dtexdata, bsp29->texdatasize); + mbsp->dentdata = BSP29_CopyEntData(bsp29->dentdata, bsp29->entdatasize); + mbsp->dleafs = BSP29toM_Leafs(bsp29->dleafs, bsp29->numleafs); + mbsp->dplanes = BSP29_CopyPlanes(bsp29->dplanes, bsp29->numplanes); + mbsp->dvertexes = BSP29_CopyVertexes(bsp29->dvertexes, bsp29->numvertexes); + mbsp->dnodes = BSP29to2_Nodes(bsp29->dnodes, bsp29->numnodes); + mbsp->texinfo = BSP29toM_Texinfo(bsp29->texinfo, bsp29->numtexinfo); + mbsp->dfaces = BSP29to2_Faces(bsp29->dfaces, bsp29->numfaces); + mbsp->dclipnodes = BSP29to2_Clipnodes(bsp29->dclipnodes, bsp29->numclipnodes); + mbsp->dedges = BSP29to2_Edges(bsp29->dedges, bsp29->numedges); + mbsp->dleaffaces = BSP29to2_Marksurfaces(bsp29->dmarksurfaces, bsp29->nummarksurfaces); + mbsp->dsurfedges = BSP29_CopySurfedges(bsp29->dsurfedges, bsp29->numsurfedges); - mbsp->dareas = Q2BSP_CopyAreas(q2bsp->dareas, q2bsp->numareas); - mbsp->dareaportals = Q2BSP_CopyAreaPortals(q2bsp->dareaportals, q2bsp->numareaportals); + /* Free old data */ + FreeBSP29((bsp29_t *)bsp29); - mbsp->dbrushes = Q2BSP_CopyBrushes(q2bsp->dbrushes, q2bsp->numbrushes); - mbsp->dbrushsides = Q2BSPtoM_CopyBrushSides(q2bsp->dbrushsides, q2bsp->numbrushsides); + /* Conversion complete! */ + mbsp->loadversion = bspdata->version; + bspdata->version = version; - /* Free old data */ - FreeQ2BSP((q2bsp_t *)q2bsp); - - /* Conversion complete! */ - ConvertBSPToMFormatComplete(&mbsp->loadversion, to_version, bspdata); - - return; - } else if (bspdata->version == &bspver_qbism) { - const q2bsp_qbism_t *q2bsp = &bspdata->data.q2bsp_qbism; - mbsp_t *mbsp = &bspdata->data.mbsp; - - memset(mbsp, 0, sizeof(*mbsp)); - - // copy counts - mbsp->nummodels = q2bsp->nummodels; - mbsp->visdatasize = q2bsp->visdatasize; - mbsp->lightdatasize = q2bsp->lightdatasize; - mbsp->entdatasize = q2bsp->entdatasize; - mbsp->numleafs = q2bsp->numleafs; - mbsp->numplanes = q2bsp->numplanes; - mbsp->numvertexes = q2bsp->numvertexes; - mbsp->numnodes = q2bsp->numnodes; - mbsp->numtexinfo = q2bsp->numtexinfo; - mbsp->numfaces = q2bsp->numfaces; - mbsp->numedges = q2bsp->numedges; - mbsp->numleaffaces = q2bsp->numleaffaces; - mbsp->numleafbrushes = q2bsp->numleafbrushes; - mbsp->numsurfedges = q2bsp->numsurfedges; - mbsp->numareas = q2bsp->numareas; - mbsp->numareaportals = q2bsp->numareaportals; - mbsp->numbrushes = q2bsp->numbrushes; - mbsp->numbrushsides = q2bsp->numbrushsides; - - // copy or convert data - mbsp->dmodels = Q2BSPtoM_Models(q2bsp->dmodels, q2bsp->nummodels); - mbsp->dvisdata = (uint8_t *)CopyArray(q2bsp->dvis, q2bsp->visdatasize, 1); - mbsp->dlightdata = BSP29_CopyLightData(q2bsp->dlightdata, q2bsp->lightdatasize); - mbsp->dentdata = BSP29_CopyEntData(q2bsp->dentdata, q2bsp->entdatasize); - mbsp->dleafs = Q2BSP_QBSPtoM_Leafs(q2bsp->dleafs, q2bsp->numleafs); - mbsp->dplanes = BSP29_CopyPlanes(q2bsp->dplanes, q2bsp->numplanes); - mbsp->dvertexes = BSP29_CopyVertexes(q2bsp->dvertexes, q2bsp->numvertexes); - mbsp->dnodes = BSP2_CopyNodes(q2bsp->dnodes, q2bsp->numnodes); - mbsp->texinfo = Q2BSPtoM_Texinfo(q2bsp->texinfo, q2bsp->numtexinfo); - mbsp->dfaces = Q2BSP_QBSPto2_Faces(q2bsp->dfaces, q2bsp->numfaces); - mbsp->dedges = BSP2_CopyEdges(q2bsp->dedges, q2bsp->numedges); - mbsp->dleaffaces = BSP2_CopyMarksurfaces(q2bsp->dleaffaces, q2bsp->numleaffaces); - mbsp->dleafbrushes = Q2BSP_Qbism_CopyLeafBrushes(q2bsp->dleafbrushes, q2bsp->numleafbrushes); - mbsp->dsurfedges = BSP29_CopySurfedges(q2bsp->dsurfedges, q2bsp->numsurfedges); - - mbsp->dareas = Q2BSP_CopyAreas(q2bsp->dareas, q2bsp->numareas); - mbsp->dareaportals = Q2BSP_CopyAreaPortals(q2bsp->dareaportals, q2bsp->numareaportals); - - mbsp->dbrushes = Q2BSP_CopyBrushes(q2bsp->dbrushes, q2bsp->numbrushes); - mbsp->dbrushsides = Q2BSP_Qbism_CopyBrushSides(q2bsp->dbrushsides, q2bsp->numbrushsides); - - /* Free old data */ - FreeQ2BSP_QBSP((q2bsp_qbism_t *)q2bsp); - - /* Conversion complete! */ - ConvertBSPToMFormatComplete(&mbsp->loadversion, to_version, bspdata); - - return; - } - - else if (bspdata->version == &bspver_bsp2rmq) { - const bsp2rmq_t *bsp2rmq = &bspdata->data.bsp2rmq; - mbsp_t *mbsp = &bspdata->data.mbsp; - - memset(mbsp, 0, sizeof(*mbsp)); - - // copy counts - mbsp->nummodels = bsp2rmq->nummodels; - mbsp->visdatasize = bsp2rmq->visdatasize; - mbsp->lightdatasize = bsp2rmq->lightdatasize; - mbsp->texdatasize = bsp2rmq->texdatasize; - mbsp->entdatasize = bsp2rmq->entdatasize; - mbsp->numleafs = bsp2rmq->numleafs; - mbsp->numplanes = bsp2rmq->numplanes; - mbsp->numvertexes = bsp2rmq->numvertexes; - mbsp->numnodes = bsp2rmq->numnodes; - mbsp->numtexinfo = bsp2rmq->numtexinfo; - mbsp->numfaces = bsp2rmq->numfaces; - mbsp->numclipnodes = bsp2rmq->numclipnodes; - mbsp->numedges = bsp2rmq->numedges; - mbsp->numleaffaces = bsp2rmq->nummarksurfaces; - mbsp->numsurfedges = bsp2rmq->numsurfedges; - - // copy or convert data - mbsp->dmodels = BSP29_CopyModels(bsp2rmq->dmodels, bsp2rmq->nummodels); - mbsp->dvisdata = BSP29_CopyVisData(bsp2rmq->dvisdata, bsp2rmq->visdatasize); - mbsp->dlightdata = BSP29_CopyLightData(bsp2rmq->dlightdata, bsp2rmq->lightdatasize); - mbsp->dtexdata = BSP29_CopyTexData(bsp2rmq->dtexdata, bsp2rmq->texdatasize); - mbsp->dentdata = BSP29_CopyEntData(bsp2rmq->dentdata, bsp2rmq->entdatasize); - mbsp->dleafs = BSP2rmqtoM_Leafs(bsp2rmq->dleafs, bsp2rmq->numleafs); - mbsp->dplanes = BSP29_CopyPlanes(bsp2rmq->dplanes, bsp2rmq->numplanes); - mbsp->dvertexes = BSP29_CopyVertexes(bsp2rmq->dvertexes, bsp2rmq->numvertexes); - mbsp->dnodes = BSP2rmqto2_Nodes(bsp2rmq->dnodes, bsp2rmq->numnodes); - mbsp->texinfo = BSP29toM_Texinfo(bsp2rmq->texinfo, bsp2rmq->numtexinfo); - mbsp->dfaces = BSP2_CopyFaces(bsp2rmq->dfaces, bsp2rmq->numfaces); - mbsp->dclipnodes = BSP2_CopyClipnodes(bsp2rmq->dclipnodes, bsp2rmq->numclipnodes); - mbsp->dedges = BSP2_CopyEdges(bsp2rmq->dedges, bsp2rmq->numedges); - mbsp->dleaffaces = BSP2_CopyMarksurfaces(bsp2rmq->dmarksurfaces, bsp2rmq->nummarksurfaces); - mbsp->dsurfedges = BSP29_CopySurfedges(bsp2rmq->dsurfedges, bsp2rmq->numsurfedges); - - /* Free old data */ - FreeBSP2RMQ((bsp2rmq_t *)bsp2rmq); - - /* Conversion complete! */ - ConvertBSPToMFormatComplete(&mbsp->loadversion, to_version, bspdata); - - return; - } - - else if (bspdata->version == &bspver_bsp2) { - const bsp2_t *bsp2 = &bspdata->data.bsp2; - mbsp_t *mbsp = &bspdata->data.mbsp; - - memset(mbsp, 0, sizeof(*mbsp)); - - // copy counts - mbsp->nummodels = bsp2->nummodels; - mbsp->visdatasize = bsp2->visdatasize; - mbsp->lightdatasize = bsp2->lightdatasize; - mbsp->texdatasize = bsp2->texdatasize; - mbsp->entdatasize = bsp2->entdatasize; - mbsp->numleafs = bsp2->numleafs; - mbsp->numplanes = bsp2->numplanes; - mbsp->numvertexes = bsp2->numvertexes; - mbsp->numnodes = bsp2->numnodes; - mbsp->numtexinfo = bsp2->numtexinfo; - mbsp->numfaces = bsp2->numfaces; - mbsp->numclipnodes = bsp2->numclipnodes; - mbsp->numedges = bsp2->numedges; - mbsp->numleaffaces = bsp2->nummarksurfaces; - mbsp->numsurfedges = bsp2->numsurfedges; - - // copy or convert data - mbsp->dmodels = BSP29_CopyModels(bsp2->dmodels, bsp2->nummodels); - mbsp->dvisdata = BSP29_CopyVisData(bsp2->dvisdata, bsp2->visdatasize); - mbsp->dlightdata = BSP29_CopyLightData(bsp2->dlightdata, bsp2->lightdatasize); - mbsp->dtexdata = BSP29_CopyTexData(bsp2->dtexdata, bsp2->texdatasize); - mbsp->dentdata = BSP29_CopyEntData(bsp2->dentdata, bsp2->entdatasize); - mbsp->dleafs = BSP2toM_Leafs(bsp2->dleafs, bsp2->numleafs); - mbsp->dplanes = BSP29_CopyPlanes(bsp2->dplanes, bsp2->numplanes); - mbsp->dvertexes = BSP29_CopyVertexes(bsp2->dvertexes, bsp2->numvertexes); - mbsp->dnodes = BSP2_CopyNodes(bsp2->dnodes, bsp2->numnodes); - mbsp->texinfo = BSP29toM_Texinfo(bsp2->texinfo, bsp2->numtexinfo); - mbsp->dfaces = BSP2_CopyFaces(bsp2->dfaces, bsp2->numfaces); - mbsp->dclipnodes = BSP2_CopyClipnodes(bsp2->dclipnodes, bsp2->numclipnodes); - mbsp->dedges = BSP2_CopyEdges(bsp2->dedges, bsp2->numedges); - mbsp->dleaffaces = BSP2_CopyMarksurfaces(bsp2->dmarksurfaces, bsp2->nummarksurfaces); - mbsp->dsurfedges = BSP29_CopySurfedges(bsp2->dsurfedges, bsp2->numsurfedges); - - /* Free old data */ - FreeBSP2((bsp2_t *)bsp2); - - /* Conversion complete! */ - ConvertBSPToMFormatComplete(&mbsp->loadversion, to_version, bspdata); - - return; - } + return; } + + if (bspdata->version == Q2_BSPVERSION && version == GENERIC_BSP) { + const q2bsp_t *q2bsp = &bspdata->data.q2bsp; + mbsp_t *mbsp = &bspdata->data.mbsp; + + memset(mbsp, 0, sizeof(*mbsp)); + + // copy counts + mbsp->nummodels = q2bsp->nummodels; + mbsp->visdatasize = q2bsp->visdatasize; + mbsp->lightdatasize = q2bsp->lightdatasize; + mbsp->entdatasize = q2bsp->entdatasize; + mbsp->numleafs = q2bsp->numleafs; + mbsp->numplanes = q2bsp->numplanes; + mbsp->numvertexes = q2bsp->numvertexes; + mbsp->numnodes = q2bsp->numnodes; + mbsp->numtexinfo = q2bsp->numtexinfo; + mbsp->numfaces = q2bsp->numfaces; + mbsp->numedges = q2bsp->numedges; + mbsp->numleaffaces = q2bsp->numleaffaces; + mbsp->numleafbrushes = q2bsp->numleafbrushes; + mbsp->numsurfedges = q2bsp->numsurfedges; + mbsp->numareas = q2bsp->numareas; + mbsp->numareaportals = q2bsp->numareaportals; + mbsp->numbrushes = q2bsp->numbrushes; + mbsp->numbrushsides = q2bsp->numbrushsides; + + // copy or convert data + mbsp->dmodels = Q2BSPtoM_Models(q2bsp->dmodels, q2bsp->nummodels); + mbsp->dvisdata = (uint8_t *)CopyArray(q2bsp->dvis, q2bsp->visdatasize, 1); + mbsp->dlightdata = BSP29_CopyLightData(q2bsp->dlightdata, q2bsp->lightdatasize); + mbsp->dentdata = BSP29_CopyEntData(q2bsp->dentdata, q2bsp->entdatasize); + mbsp->dleafs = Q2BSPtoM_Leafs(q2bsp->dleafs, q2bsp->numleafs); + mbsp->dplanes = BSP29_CopyPlanes(q2bsp->dplanes, q2bsp->numplanes); + mbsp->dvertexes = BSP29_CopyVertexes(q2bsp->dvertexes, q2bsp->numvertexes); + mbsp->dnodes = Q2BSPto2_Nodes(q2bsp->dnodes, q2bsp->numnodes); + mbsp->texinfo = Q2BSPtoM_Texinfo(q2bsp->texinfo, q2bsp->numtexinfo); + mbsp->dfaces = Q2BSPto2_Faces(q2bsp->dfaces, q2bsp->numfaces); + mbsp->dedges = BSP29to2_Edges(q2bsp->dedges, q2bsp->numedges); + mbsp->dleaffaces = BSP29to2_Marksurfaces(q2bsp->dleaffaces, q2bsp->numleaffaces); + mbsp->dleafbrushes = Q2BSP_CopyLeafBrushes(q2bsp->dleafbrushes, q2bsp->numleafbrushes); + mbsp->dsurfedges = BSP29_CopySurfedges(q2bsp->dsurfedges, q2bsp->numsurfedges); + + mbsp->dareas = Q2BSP_CopyAreas(q2bsp->dareas, q2bsp->numareas); + mbsp->dareaportals = Q2BSP_CopyAreaPortals(q2bsp->dareaportals, q2bsp->numareaportals); + + mbsp->dbrushes = Q2BSP_CopyBrushes(q2bsp->dbrushes, q2bsp->numbrushes); + mbsp->dbrushsides = Q2BSP_CopyBrushSides(q2bsp->dbrushsides, q2bsp->numbrushsides); + + /* Free old data */ + FreeQ2BSP((q2bsp_t *)q2bsp); + + /* Conversion complete! */ + mbsp->loadversion = bspdata->version; + bspdata->version = version; + + return; + } + + if (bspdata->version == BSP2RMQVERSION && version == GENERIC_BSP) { + const bsp2rmq_t *bsp2rmq = &bspdata->data.bsp2rmq; + mbsp_t *mbsp = &bspdata->data.mbsp; + + memset(mbsp, 0, sizeof(*mbsp)); + + // copy counts + mbsp->nummodels = bsp2rmq->nummodels; + mbsp->visdatasize = bsp2rmq->visdatasize; + mbsp->lightdatasize = bsp2rmq->lightdatasize; + mbsp->texdatasize = bsp2rmq->texdatasize; + mbsp->entdatasize = bsp2rmq->entdatasize; + mbsp->numleafs = bsp2rmq->numleafs; + mbsp->numplanes = bsp2rmq->numplanes; + mbsp->numvertexes = bsp2rmq->numvertexes; + mbsp->numnodes = bsp2rmq->numnodes; + mbsp->numtexinfo = bsp2rmq->numtexinfo; + mbsp->numfaces = bsp2rmq->numfaces; + mbsp->numclipnodes = bsp2rmq->numclipnodes; + mbsp->numedges = bsp2rmq->numedges; + mbsp->numleaffaces = bsp2rmq->nummarksurfaces; + mbsp->numsurfedges = bsp2rmq->numsurfedges; + + // copy or convert data + mbsp->dmodels = BSP29_CopyModels(bsp2rmq->dmodels, bsp2rmq->nummodels); + mbsp->dvisdata = BSP29_CopyVisData(bsp2rmq->dvisdata, bsp2rmq->visdatasize); + mbsp->dlightdata = BSP29_CopyLightData(bsp2rmq->dlightdata, bsp2rmq->lightdatasize); + mbsp->dtexdata = BSP29_CopyTexData(bsp2rmq->dtexdata, bsp2rmq->texdatasize); + mbsp->dentdata = BSP29_CopyEntData(bsp2rmq->dentdata, bsp2rmq->entdatasize); + mbsp->dleafs = BSP2rmqtoM_Leafs(bsp2rmq->dleafs, bsp2rmq->numleafs); + mbsp->dplanes = BSP29_CopyPlanes(bsp2rmq->dplanes, bsp2rmq->numplanes); + mbsp->dvertexes = BSP29_CopyVertexes(bsp2rmq->dvertexes, bsp2rmq->numvertexes); + mbsp->dnodes = BSP2rmqto2_Nodes(bsp2rmq->dnodes, bsp2rmq->numnodes); + mbsp->texinfo = BSP29toM_Texinfo(bsp2rmq->texinfo, bsp2rmq->numtexinfo); + mbsp->dfaces = BSP2_CopyFaces(bsp2rmq->dfaces, bsp2rmq->numfaces); + mbsp->dclipnodes = BSP2_CopyClipnodes(bsp2rmq->dclipnodes, bsp2rmq->numclipnodes); + mbsp->dedges = BSP2_CopyEdges(bsp2rmq->dedges, bsp2rmq->numedges); + mbsp->dleaffaces = BSP2_CopyMarksurfaces(bsp2rmq->dmarksurfaces, bsp2rmq->nummarksurfaces); + mbsp->dsurfedges = BSP29_CopySurfedges(bsp2rmq->dsurfedges, bsp2rmq->numsurfedges); + + /* Free old data */ + FreeBSP2RMQ((bsp2rmq_t *)bsp2rmq); + + /* Conversion complete! */ + mbsp->loadversion = bspdata->version; + bspdata->version = version; + + return; + } + + if (bspdata->version == BSP2VERSION && version == GENERIC_BSP) { + const bsp2_t *bsp2 = &bspdata->data.bsp2; + mbsp_t *mbsp = &bspdata->data.mbsp; + + memset(mbsp, 0, sizeof(*mbsp)); + + // copy counts + mbsp->nummodels = bsp2->nummodels; + mbsp->visdatasize = bsp2->visdatasize; + mbsp->lightdatasize = bsp2->lightdatasize; + mbsp->texdatasize = bsp2->texdatasize; + mbsp->entdatasize = bsp2->entdatasize; + mbsp->numleafs = bsp2->numleafs; + mbsp->numplanes = bsp2->numplanes; + mbsp->numvertexes = bsp2->numvertexes; + mbsp->numnodes = bsp2->numnodes; + mbsp->numtexinfo = bsp2->numtexinfo; + mbsp->numfaces = bsp2->numfaces; + mbsp->numclipnodes = bsp2->numclipnodes; + mbsp->numedges = bsp2->numedges; + mbsp->numleaffaces = bsp2->nummarksurfaces; + mbsp->numsurfedges = bsp2->numsurfedges; + + // copy or convert data + mbsp->dmodels = BSP29_CopyModels(bsp2->dmodels, bsp2->nummodels); + mbsp->dvisdata = BSP29_CopyVisData(bsp2->dvisdata, bsp2->visdatasize); + mbsp->dlightdata = BSP29_CopyLightData(bsp2->dlightdata, bsp2->lightdatasize); + mbsp->dtexdata = BSP29_CopyTexData(bsp2->dtexdata, bsp2->texdatasize); + mbsp->dentdata = BSP29_CopyEntData(bsp2->dentdata, bsp2->entdatasize); + mbsp->dleafs = BSP2toM_Leafs(bsp2->dleafs, bsp2->numleafs); + mbsp->dplanes = BSP29_CopyPlanes(bsp2->dplanes, bsp2->numplanes); + mbsp->dvertexes = BSP29_CopyVertexes(bsp2->dvertexes, bsp2->numvertexes); + mbsp->dnodes = BSP2_CopyNodes(bsp2->dnodes, bsp2->numnodes); + mbsp->texinfo = BSP29toM_Texinfo(bsp2->texinfo, bsp2->numtexinfo); + mbsp->dfaces = BSP2_CopyFaces(bsp2->dfaces, bsp2->numfaces); + mbsp->dclipnodes = BSP2_CopyClipnodes(bsp2->dclipnodes, bsp2->numclipnodes); + mbsp->dedges = BSP2_CopyEdges(bsp2->dedges, bsp2->numedges); + mbsp->dleaffaces = BSP2_CopyMarksurfaces(bsp2->dmarksurfaces, bsp2->nummarksurfaces); + mbsp->dsurfedges = BSP29_CopySurfedges(bsp2->dsurfedges, bsp2->numsurfedges); + + /* Free old data */ + FreeBSP2((bsp2_t *)bsp2); + + /* Conversion complete! */ + mbsp->loadversion = bspdata->version; + bspdata->version = version; + + return; + } + // conversions from GENERIC_BSP - else if (bspdata->version == &bspver_generic) { - if (to_version == &bspver_q1 || to_version == &bspver_h2 || to_version == &bspver_hl) { - bsp29_t *bsp29 = &bspdata->data.bsp29; - const mbsp_t *mbsp = &bspdata->data.mbsp; - - memset(bsp29, 0, sizeof(*bsp29)); - - // copy counts - bsp29->nummodels = mbsp->nummodels; - bsp29->visdatasize = mbsp->visdatasize; - bsp29->lightdatasize = mbsp->lightdatasize; - bsp29->texdatasize = mbsp->texdatasize; - bsp29->entdatasize = mbsp->entdatasize; - bsp29->numleafs = mbsp->numleafs; - bsp29->numplanes = mbsp->numplanes; - bsp29->numvertexes = mbsp->numvertexes; - bsp29->numnodes = mbsp->numnodes; - bsp29->numtexinfo = mbsp->numtexinfo; - bsp29->numfaces = mbsp->numfaces; - bsp29->numclipnodes = mbsp->numclipnodes; - bsp29->numedges = mbsp->numedges; - bsp29->nummarksurfaces = mbsp->numleaffaces; - bsp29->numsurfedges = mbsp->numsurfedges; - - // copy or convert data - bsp29->dmodels = BSP29_CopyModels(mbsp->dmodels, mbsp->nummodels); - bsp29->dvisdata = BSP29_CopyVisData(mbsp->dvisdata, mbsp->visdatasize); - bsp29->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); - bsp29->dtexdata = BSP29_CopyTexData(mbsp->dtexdata, mbsp->texdatasize); - bsp29->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); - bsp29->dleafs = MBSPto29_Leafs(mbsp->dleafs, mbsp->numleafs); - bsp29->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); - bsp29->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); - bsp29->dnodes = BSP2to29_Nodes(mbsp->dnodes, mbsp->numnodes); - bsp29->texinfo = MBSPto29_Texinfo(mbsp->texinfo, mbsp->numtexinfo); - bsp29->dfaces = BSP2to29_Faces(mbsp->dfaces, mbsp->numfaces); - bsp29->dclipnodes = BSP2to29_Clipnodes(mbsp->dclipnodes, mbsp->numclipnodes); - bsp29->dedges = BSP2to29_Edges(mbsp->dedges, mbsp->numedges); - bsp29->dmarksurfaces = BSP2to29_Marksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); - bsp29->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); - - /* Free old data */ - FreeMBSP((mbsp_t *)mbsp); - - /* Conversion complete! */ - bspdata->version = to_version; - - return; - } - else if (to_version == &bspver_q2) { - const mbsp_t *mbsp = &bspdata->data.mbsp; - q2bsp_t *q2bsp = &bspdata->data.q2bsp; + if (bspdata->version == GENERIC_BSP && (version == BSPVERSION || version == BSPHLVERSION)) { + bsp29_t *bsp29 = &bspdata->data.bsp29; + const mbsp_t *mbsp = &bspdata->data.mbsp; - memset(q2bsp, 0, sizeof(*q2bsp)); + memset(bsp29, 0, sizeof(*bsp29)); - // copy counts - q2bsp->nummodels = mbsp->nummodels; - q2bsp->visdatasize = mbsp->visdatasize; - q2bsp->lightdatasize = mbsp->lightdatasize; - q2bsp->entdatasize = mbsp->entdatasize; - q2bsp->numleafs = mbsp->numleafs; - q2bsp->numplanes = mbsp->numplanes; - q2bsp->numvertexes = mbsp->numvertexes; - q2bsp->numnodes = mbsp->numnodes; - q2bsp->numtexinfo = mbsp->numtexinfo; - q2bsp->numfaces = mbsp->numfaces; - q2bsp->numedges = mbsp->numedges; - q2bsp->numleaffaces = mbsp->numleaffaces; - q2bsp->numleafbrushes = mbsp->numleafbrushes; - q2bsp->numsurfedges = mbsp->numsurfedges; - q2bsp->numareas = mbsp->numareas; - q2bsp->numareaportals = mbsp->numareaportals; - q2bsp->numbrushes = mbsp->numbrushes; - q2bsp->numbrushsides = mbsp->numbrushsides; + // copy counts + bsp29->nummodels = mbsp->nummodels; + bsp29->visdatasize = mbsp->visdatasize; + bsp29->lightdatasize = mbsp->lightdatasize; + bsp29->texdatasize = mbsp->texdatasize; + bsp29->entdatasize = mbsp->entdatasize; + bsp29->numleafs = mbsp->numleafs; + bsp29->numplanes = mbsp->numplanes; + bsp29->numvertexes = mbsp->numvertexes; + bsp29->numnodes = mbsp->numnodes; + bsp29->numtexinfo = mbsp->numtexinfo; + bsp29->numfaces = mbsp->numfaces; + bsp29->numclipnodes = mbsp->numclipnodes; + bsp29->numedges = mbsp->numedges; + bsp29->nummarksurfaces = mbsp->numleaffaces; + bsp29->numsurfedges = mbsp->numsurfedges; - // copy or convert data - q2bsp->dmodels = MBSPtoQ2_Models(mbsp->dmodels, mbsp->nummodels); - q2bsp->dvis = (dvis_t *)CopyArray(mbsp->dvisdata, mbsp->visdatasize, 1); - q2bsp->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); - q2bsp->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); - q2bsp->dleafs = MBSPtoQ2_Leafs(mbsp->dleafs, mbsp->numleafs); - q2bsp->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); - q2bsp->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); - q2bsp->dnodes = BSP2toQ2_Nodes(mbsp->dnodes, mbsp->numnodes); - q2bsp->texinfo = MBSPtoQ2_Texinfo(mbsp->texinfo, mbsp->numtexinfo); - q2bsp->dfaces = BSP2toQ2_Faces(mbsp->dfaces, mbsp->numfaces); - q2bsp->dedges = BSP2to29_Edges(mbsp->dedges, mbsp->numedges); - q2bsp->dleaffaces = BSP2to29_Marksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); - q2bsp->dleafbrushes = MBSPtoQ2_CopyLeafBrushes(mbsp->dleafbrushes, mbsp->numleafbrushes); - q2bsp->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); + // copy or convert data + bsp29->dmodels = BSP29_CopyModels(mbsp->dmodels, mbsp->nummodels); + bsp29->dvisdata = BSP29_CopyVisData(mbsp->dvisdata, mbsp->visdatasize); + bsp29->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); + bsp29->dtexdata = BSP29_CopyTexData(mbsp->dtexdata, mbsp->texdatasize); + bsp29->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); + bsp29->dleafs = MBSPto29_Leafs(mbsp->dleafs, mbsp->numleafs); + bsp29->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); + bsp29->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); + bsp29->dnodes = BSP2to29_Nodes(mbsp->dnodes, mbsp->numnodes); + bsp29->texinfo = MBSPto29_Texinfo(mbsp->texinfo, mbsp->numtexinfo); + bsp29->dfaces = BSP2to29_Faces(mbsp->dfaces, mbsp->numfaces); + bsp29->dclipnodes = BSP2to29_Clipnodes(mbsp->dclipnodes, mbsp->numclipnodes); + bsp29->dedges = BSP2to29_Edges(mbsp->dedges, mbsp->numedges); + bsp29->dmarksurfaces = BSP2to29_Marksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); + bsp29->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); - q2bsp->dareas = Q2BSP_CopyAreas(mbsp->dareas, mbsp->numareas); - q2bsp->dareaportals = Q2BSP_CopyAreaPortals(mbsp->dareaportals, mbsp->numareaportals); + /* Free old data */ + FreeMBSP((mbsp_t *)mbsp); - q2bsp->dbrushes = Q2BSP_CopyBrushes(mbsp->dbrushes, mbsp->numbrushes); - q2bsp->dbrushsides = MBSPtoQ2_CopyBrushSides(mbsp->dbrushsides, mbsp->numbrushsides); + /* Conversion complete! */ + bspdata->version = version; - /* Free old data */ - FreeMBSP((mbsp_t *)mbsp); - - /* Conversion complete! */ - bspdata->version = to_version; - - return; - } else if (to_version == &bspver_qbism) { - const mbsp_t *mbsp = &bspdata->data.mbsp; - q2bsp_qbism_t *q2bsp = &bspdata->data.q2bsp_qbism; - - memset(q2bsp, 0, sizeof(*q2bsp)); - - // copy counts - q2bsp->nummodels = mbsp->nummodels; - q2bsp->visdatasize = mbsp->visdatasize; - q2bsp->lightdatasize = mbsp->lightdatasize; - q2bsp->entdatasize = mbsp->entdatasize; - q2bsp->numleafs = mbsp->numleafs; - q2bsp->numplanes = mbsp->numplanes; - q2bsp->numvertexes = mbsp->numvertexes; - q2bsp->numnodes = mbsp->numnodes; - q2bsp->numtexinfo = mbsp->numtexinfo; - q2bsp->numfaces = mbsp->numfaces; - q2bsp->numedges = mbsp->numedges; - q2bsp->numleaffaces = mbsp->numleaffaces; - q2bsp->numleafbrushes = mbsp->numleafbrushes; - q2bsp->numsurfedges = mbsp->numsurfedges; - q2bsp->numareas = mbsp->numareas; - q2bsp->numareaportals = mbsp->numareaportals; - q2bsp->numbrushes = mbsp->numbrushes; - q2bsp->numbrushsides = mbsp->numbrushsides; - - // copy or convert data - q2bsp->dmodels = MBSPtoQ2_Models(mbsp->dmodels, mbsp->nummodels); - q2bsp->dvis = (dvis_t *)CopyArray(mbsp->dvisdata, mbsp->visdatasize, 1); - q2bsp->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); - q2bsp->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); - q2bsp->dleafs = MBSPtoQ2_Qbism_Leafs(mbsp->dleafs, mbsp->numleafs); - q2bsp->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); - q2bsp->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); - q2bsp->dnodes = BSP2_CopyNodes(mbsp->dnodes, mbsp->numnodes); - q2bsp->texinfo = MBSPtoQ2_Texinfo(mbsp->texinfo, mbsp->numtexinfo); - q2bsp->dfaces = BSP2toQ2_Qbism_Faces(mbsp->dfaces, mbsp->numfaces); - q2bsp->dedges = BSP2_CopyEdges(mbsp->dedges, mbsp->numedges); - q2bsp->dleaffaces = BSP2_CopyMarksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); - q2bsp->dleafbrushes = Q2BSP_Qbism_CopyLeafBrushes(mbsp->dleafbrushes, mbsp->numleafbrushes); - q2bsp->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); - - q2bsp->dareas = Q2BSP_CopyAreas(mbsp->dareas, mbsp->numareas); - q2bsp->dareaportals = Q2BSP_CopyAreaPortals(mbsp->dareaportals, mbsp->numareaportals); - - q2bsp->dbrushes = Q2BSP_CopyBrushes(mbsp->dbrushes, mbsp->numbrushes); - q2bsp->dbrushsides = Q2BSP_Qbism_CopyBrushSides(mbsp->dbrushsides, mbsp->numbrushsides); - - /* Free old data */ - FreeMBSP((mbsp_t *)mbsp); - - /* Conversion complete! */ - bspdata->version = to_version; - - return; - } + return; + } - else if (to_version == &bspver_bsp2rmq) { - bsp2rmq_t *bsp2rmq = &bspdata->data.bsp2rmq; - const mbsp_t *mbsp = &bspdata->data.mbsp; + if (bspdata->version == GENERIC_BSP && version == Q2_BSPVERSION) { + const mbsp_t *mbsp = &bspdata->data.mbsp; + q2bsp_t *q2bsp = &bspdata->data.q2bsp; - memset(bsp2rmq, 0, sizeof(*bsp2rmq)); + memset(q2bsp, 0, sizeof(*q2bsp)); - // copy counts - bsp2rmq->nummodels = mbsp->nummodels; - bsp2rmq->visdatasize = mbsp->visdatasize; - bsp2rmq->lightdatasize = mbsp->lightdatasize; - bsp2rmq->texdatasize = mbsp->texdatasize; - bsp2rmq->entdatasize = mbsp->entdatasize; - bsp2rmq->numleafs = mbsp->numleafs; - bsp2rmq->numplanes = mbsp->numplanes; - bsp2rmq->numvertexes = mbsp->numvertexes; - bsp2rmq->numnodes = mbsp->numnodes; - bsp2rmq->numtexinfo = mbsp->numtexinfo; - bsp2rmq->numfaces = mbsp->numfaces; - bsp2rmq->numclipnodes = mbsp->numclipnodes; - bsp2rmq->numedges = mbsp->numedges; - bsp2rmq->nummarksurfaces = mbsp->numleaffaces; - bsp2rmq->numsurfedges = mbsp->numsurfedges; + // copy counts + q2bsp->nummodels = mbsp->nummodels; + q2bsp->visdatasize = mbsp->visdatasize; + q2bsp->lightdatasize = mbsp->lightdatasize; + q2bsp->entdatasize = mbsp->entdatasize; + q2bsp->numleafs = mbsp->numleafs; + q2bsp->numplanes = mbsp->numplanes; + q2bsp->numvertexes = mbsp->numvertexes; + q2bsp->numnodes = mbsp->numnodes; + q2bsp->numtexinfo = mbsp->numtexinfo; + q2bsp->numfaces = mbsp->numfaces; + q2bsp->numedges = mbsp->numedges; + q2bsp->numleaffaces = mbsp->numleaffaces; + q2bsp->numleafbrushes = mbsp->numleafbrushes; + q2bsp->numsurfedges = mbsp->numsurfedges; + q2bsp->numareas = mbsp->numareas; + q2bsp->numareaportals = mbsp->numareaportals; + q2bsp->numbrushes = mbsp->numbrushes; + q2bsp->numbrushsides = mbsp->numbrushsides; - // copy or convert data - bsp2rmq->dmodels = BSP29_CopyModels(mbsp->dmodels, mbsp->nummodels); - bsp2rmq->dvisdata = BSP29_CopyVisData(mbsp->dvisdata, mbsp->visdatasize); - bsp2rmq->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); - bsp2rmq->dtexdata = BSP29_CopyTexData(mbsp->dtexdata, mbsp->texdatasize); - bsp2rmq->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); - bsp2rmq->dleafs = MBSPto2rmq_Leafs(mbsp->dleafs, mbsp->numleafs); - bsp2rmq->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); - bsp2rmq->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); - bsp2rmq->dnodes = BSP2to2rmq_Nodes(mbsp->dnodes, mbsp->numnodes); - bsp2rmq->texinfo = MBSPto29_Texinfo(mbsp->texinfo, mbsp->numtexinfo); - bsp2rmq->dfaces = BSP2_CopyFaces(mbsp->dfaces, mbsp->numfaces); - bsp2rmq->dclipnodes = BSP2_CopyClipnodes(mbsp->dclipnodes, mbsp->numclipnodes); - bsp2rmq->dedges = BSP2_CopyEdges(mbsp->dedges, mbsp->numedges); - bsp2rmq->dmarksurfaces = BSP2_CopyMarksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); - bsp2rmq->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); + // copy or convert data + q2bsp->dmodels = MBSPtoQ2_Models(mbsp->dmodels, mbsp->nummodels); + q2bsp->dvis = (dvis_t *)CopyArray(mbsp->dvisdata, mbsp->visdatasize, 1); + q2bsp->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); + q2bsp->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); + q2bsp->dleafs = MBSPtoQ2_Leafs(mbsp->dleafs, mbsp->numleafs); + q2bsp->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); + q2bsp->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); + q2bsp->dnodes = BSP2toQ2_Nodes(mbsp->dnodes, mbsp->numnodes); + q2bsp->texinfo = MBSPtoQ2_Texinfo(mbsp->texinfo, mbsp->numtexinfo); + q2bsp->dfaces = BSP2toQ2_Faces(mbsp->dfaces, mbsp->numfaces); + q2bsp->dedges = BSP2to29_Edges(mbsp->dedges, mbsp->numedges); + q2bsp->dleaffaces = BSP2to29_Marksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); + q2bsp->dleafbrushes = Q2BSP_CopyLeafBrushes(mbsp->dleafbrushes, mbsp->numleafbrushes); + q2bsp->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); - /* Free old data */ - FreeMBSP((mbsp_t *)mbsp); + q2bsp->dareas = Q2BSP_CopyAreas(mbsp->dareas, mbsp->numareas); + q2bsp->dareaportals = Q2BSP_CopyAreaPortals(mbsp->dareaportals, mbsp->numareaportals); - /* Conversion complete! */ - bspdata->version = to_version; + q2bsp->dbrushes = Q2BSP_CopyBrushes(mbsp->dbrushes, mbsp->numbrushes); + q2bsp->dbrushsides = Q2BSP_CopyBrushSides(mbsp->dbrushsides, mbsp->numbrushsides); - return; - } + /* Free old data */ + FreeMBSP((mbsp_t *)mbsp); + + /* Conversion complete! */ + bspdata->version = version; + + return; + } - else if (to_version == &bspver_bsp2) { - bsp2_t *bsp2 = &bspdata->data.bsp2; - const mbsp_t *mbsp = &bspdata->data.mbsp; + if (bspdata->version == GENERIC_BSP && version == BSP2RMQVERSION) { + bsp2rmq_t *bsp2rmq = &bspdata->data.bsp2rmq; + const mbsp_t *mbsp = &bspdata->data.mbsp; - memset(bsp2, 0, sizeof(*bsp2)); + memset(bsp2rmq, 0, sizeof(*bsp2rmq)); - // copy counts - bsp2->nummodels = mbsp->nummodels; - bsp2->visdatasize = mbsp->visdatasize; - bsp2->lightdatasize = mbsp->lightdatasize; - bsp2->texdatasize = mbsp->texdatasize; - bsp2->entdatasize = mbsp->entdatasize; - bsp2->numleafs = mbsp->numleafs; - bsp2->numplanes = mbsp->numplanes; - bsp2->numvertexes = mbsp->numvertexes; - bsp2->numnodes = mbsp->numnodes; - bsp2->numtexinfo = mbsp->numtexinfo; - bsp2->numfaces = mbsp->numfaces; - bsp2->numclipnodes = mbsp->numclipnodes; - bsp2->numedges = mbsp->numedges; - bsp2->nummarksurfaces = mbsp->numleaffaces; - bsp2->numsurfedges = mbsp->numsurfedges; + // copy counts + bsp2rmq->nummodels = mbsp->nummodels; + bsp2rmq->visdatasize = mbsp->visdatasize; + bsp2rmq->lightdatasize = mbsp->lightdatasize; + bsp2rmq->texdatasize = mbsp->texdatasize; + bsp2rmq->entdatasize = mbsp->entdatasize; + bsp2rmq->numleafs = mbsp->numleafs; + bsp2rmq->numplanes = mbsp->numplanes; + bsp2rmq->numvertexes = mbsp->numvertexes; + bsp2rmq->numnodes = mbsp->numnodes; + bsp2rmq->numtexinfo = mbsp->numtexinfo; + bsp2rmq->numfaces = mbsp->numfaces; + bsp2rmq->numclipnodes = mbsp->numclipnodes; + bsp2rmq->numedges = mbsp->numedges; + bsp2rmq->nummarksurfaces = mbsp->numleaffaces; + bsp2rmq->numsurfedges = mbsp->numsurfedges; - // copy or convert data - bsp2->dmodels = BSP29_CopyModels(mbsp->dmodels, mbsp->nummodels); - bsp2->dvisdata = BSP29_CopyVisData(mbsp->dvisdata, mbsp->visdatasize); - bsp2->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); - bsp2->dtexdata = BSP29_CopyTexData(mbsp->dtexdata, mbsp->texdatasize); - bsp2->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); - bsp2->dleafs = MBSPto2_Leafs(mbsp->dleafs, mbsp->numleafs); - bsp2->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); - bsp2->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); - bsp2->dnodes = BSP2_CopyNodes(mbsp->dnodes, mbsp->numnodes); - bsp2->texinfo = MBSPto29_Texinfo(mbsp->texinfo, mbsp->numtexinfo); - bsp2->dfaces = BSP2_CopyFaces(mbsp->dfaces, mbsp->numfaces); - bsp2->dclipnodes = BSP2_CopyClipnodes(mbsp->dclipnodes, mbsp->numclipnodes); - bsp2->dedges = BSP2_CopyEdges(mbsp->dedges, mbsp->numedges); - bsp2->dmarksurfaces = BSP2_CopyMarksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); - bsp2->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); + // copy or convert data + bsp2rmq->dmodels = BSP29_CopyModels(mbsp->dmodels, mbsp->nummodels); + bsp2rmq->dvisdata = BSP29_CopyVisData(mbsp->dvisdata, mbsp->visdatasize); + bsp2rmq->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); + bsp2rmq->dtexdata = BSP29_CopyTexData(mbsp->dtexdata, mbsp->texdatasize); + bsp2rmq->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); + bsp2rmq->dleafs = MBSPto2rmq_Leafs(mbsp->dleafs, mbsp->numleafs); + bsp2rmq->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); + bsp2rmq->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); + bsp2rmq->dnodes = BSP2to2rmq_Nodes(mbsp->dnodes, mbsp->numnodes); + bsp2rmq->texinfo = MBSPto29_Texinfo(mbsp->texinfo, mbsp->numtexinfo); + bsp2rmq->dfaces = BSP2_CopyFaces(mbsp->dfaces, mbsp->numfaces); + bsp2rmq->dclipnodes = BSP2_CopyClipnodes(mbsp->dclipnodes, mbsp->numclipnodes); + bsp2rmq->dedges = BSP2_CopyEdges(mbsp->dedges, mbsp->numedges); + bsp2rmq->dmarksurfaces = BSP2_CopyMarksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); + bsp2rmq->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); - /* Free old data */ - FreeMBSP((mbsp_t *)mbsp); + /* Free old data */ + FreeMBSP((mbsp_t *)mbsp); - /* Conversion complete! */ - bspdata->version = to_version; + /* Conversion complete! */ + bspdata->version = version; - return; - } + return; + } + + if (bspdata->version == GENERIC_BSP && version == BSP2VERSION) { + bsp2_t *bsp2 = &bspdata->data.bsp2; + const mbsp_t *mbsp = &bspdata->data.mbsp; + + memset(bsp2, 0, sizeof(*bsp2)); + + // copy counts + bsp2->nummodels = mbsp->nummodels; + bsp2->visdatasize = mbsp->visdatasize; + bsp2->lightdatasize = mbsp->lightdatasize; + bsp2->texdatasize = mbsp->texdatasize; + bsp2->entdatasize = mbsp->entdatasize; + bsp2->numleafs = mbsp->numleafs; + bsp2->numplanes = mbsp->numplanes; + bsp2->numvertexes = mbsp->numvertexes; + bsp2->numnodes = mbsp->numnodes; + bsp2->numtexinfo = mbsp->numtexinfo; + bsp2->numfaces = mbsp->numfaces; + bsp2->numclipnodes = mbsp->numclipnodes; + bsp2->numedges = mbsp->numedges; + bsp2->nummarksurfaces = mbsp->numleaffaces; + bsp2->numsurfedges = mbsp->numsurfedges; + + // copy or convert data + bsp2->dmodels = BSP29_CopyModels(mbsp->dmodels, mbsp->nummodels); + bsp2->dvisdata = BSP29_CopyVisData(mbsp->dvisdata, mbsp->visdatasize); + bsp2->dlightdata = BSP29_CopyLightData(mbsp->dlightdata, mbsp->lightdatasize); + bsp2->dtexdata = BSP29_CopyTexData(mbsp->dtexdata, mbsp->texdatasize); + bsp2->dentdata = BSP29_CopyEntData(mbsp->dentdata, mbsp->entdatasize); + bsp2->dleafs = MBSPto2_Leafs(mbsp->dleafs, mbsp->numleafs); + bsp2->dplanes = BSP29_CopyPlanes(mbsp->dplanes, mbsp->numplanes); + bsp2->dvertexes = BSP29_CopyVertexes(mbsp->dvertexes, mbsp->numvertexes); + bsp2->dnodes = BSP2_CopyNodes(mbsp->dnodes, mbsp->numnodes); + bsp2->texinfo = MBSPto29_Texinfo(mbsp->texinfo, mbsp->numtexinfo); + bsp2->dfaces = BSP2_CopyFaces(mbsp->dfaces, mbsp->numfaces); + bsp2->dclipnodes = BSP2_CopyClipnodes(mbsp->dclipnodes, mbsp->numclipnodes); + bsp2->dedges = BSP2_CopyEdges(mbsp->dedges, mbsp->numedges); + bsp2->dmarksurfaces = BSP2_CopyMarksurfaces(mbsp->dleaffaces, mbsp->numleaffaces); + bsp2->dsurfedges = BSP29_CopySurfedges(mbsp->dsurfedges, mbsp->numsurfedges); + + /* Free old data */ + FreeMBSP((mbsp_t *)mbsp); + + /* Conversion complete! */ + bspdata->version = version; + + return; } Error("Don't know how to convert BSP version %s to %s", - BSPVersionString(bspdata->version), BSPVersionString(to_version)); + BSPVersionString(bspdata->version), BSPVersionString(version)); } static int isHexen2(const dheader_t *header) { - /* + /* the world should always have some face. however, if the sizes are wrong then we're actually reading headnode[6]. hexen2 only used 5 hulls, so this should be 0 in hexen2, and not in quake. - */ - const dmodelq1_t *modelsq1 = (const dmodelq1_t*)((const uint8_t *)header + header->lumps[LUMP_MODELS].fileofs); - return !modelsq1->numfaces; + */ + const dmodelq1_t *modelsq1 = (const dmodelq1_t*)((const uint8_t *)header + header->lumps[LUMP_MODELS].fileofs); + return !modelsq1->numfaces; } /* @@ -2577,30 +2084,8 @@ const lumpspec_t lumpspec_q2bsp[] = { { "areaportals", sizeof(dareaportal_t) }, }; -const lumpspec_t lumpspec_qbism[] = { - { "entities", sizeof(char) }, - { "planes", sizeof(dplane_t) }, - { "vertexes", sizeof(dvertex_t) }, - { "visibility", sizeof(uint8_t) }, - { "nodes", sizeof(q2_dnode_qbism_t) }, - { "texinfos", sizeof(q2_texinfo_t) }, - { "faces", sizeof(q2_dface_qbism_t) }, - { "lighting", sizeof(uint8_t) }, - { "leafs", sizeof(q2_dleaf_qbism_t) }, - { "leaffaces", sizeof(uint32_t) }, - { "leafbrushes", sizeof(uint32_t) }, - { "edges", sizeof(q2_dedge_qbism_t) }, - { "surfedges", sizeof(int32_t) }, - { "models", sizeof(q2_dmodel_t) }, - { "brushes", sizeof(dbrush_t) }, - { "brushsides", sizeof(q2_dbrushside_qbism_t) }, - { "pop", sizeof(uint8_t) }, - { "areas", sizeof(darea_t) }, - { "areaportals", sizeof(dareaportal_t) }, -}; - static int -CopyLump(const void *header, const bspversion_t *version, const lump_t *lumps, int lumpnum, void *destptr) +CopyLump(const dheader_t *header, int lumpnum, void *destptr) { const lumpspec_t *lumpspec; uint8_t **bufferptr = static_cast(destptr); @@ -2608,29 +2093,29 @@ CopyLump(const void *header, const bspversion_t *version, const lump_t *lumps, i int length; int ofs; - if (version == &bspver_q1 || version == &bspver_h2 || version == &bspver_hl) { + switch (header->version) { + case BSPVERSION: + case BSPHLVERSION: lumpspec = &lumpspec_bsp29[lumpnum]; - } else if (version == &bspver_bsp2rmq) { + break; + case BSP2RMQVERSION: lumpspec = &lumpspec_bsp2rmq[lumpnum]; - } else if (version == &bspver_bsp2) { + break; + case BSP2VERSION: lumpspec = &lumpspec_bsp2[lumpnum]; - } else if (version == &bspver_q2) { - lumpspec = &lumpspec_q2bsp[lumpnum]; - } else if (version == &bspver_qbism) { - lumpspec = &lumpspec_qbism[lumpnum]; - } else { - Error("Unsupported BSP version: %s", BSPVersionString(version)); + break; + default: + Error("Unsupported BSP version: %d", header->version); throw; //mxd. Fixes "Uninitialized variable" warning } - length = lumps[lumpnum].filelen; - ofs = lumps[lumpnum].fileofs; + length = header->lumps[lumpnum].filelen; + ofs = header->lumps[lumpnum].fileofs; if (buffer) free(buffer); - // convert non-Hexen II BSP model hulls over to Hexen II ones - if (lumpnum == LUMP_MODELS && (version == &bspver_q1 || version == &bspver_hl)) + if (lumpnum == LUMP_MODELS && !isHexen2(header)) { /*convert in-place. no need to care about endian here.*/ const dmodelq1_t *in = (const dmodelq1_t*)((const uint8_t *)header + ofs); dmodel_t *out; @@ -2677,6 +2162,45 @@ CopyLump(const void *header, const bspversion_t *version, const lump_t *lumps, i } } +// FIXME: Could merge this with CopyLump once the hexen 2 hack is moved elsewhere +static int +Q2_CopyLump(const q2_dheader_t *header, int lumpnum, void *destptr) +{ + const lumpspec_t *lumpspec; + uint8_t **bufferptr = static_cast(destptr); + uint8_t *buffer = *bufferptr; + int length; + int ofs; + + switch (header->version) { + case Q2_BSPVERSION: + lumpspec = &lumpspec_q2bsp[lumpnum]; + break; + default: + Error("Unsupported BSP version: %d", header->version); + throw; //mxd. Fixes "Uninitialized variable" warning + } + + length = header->lumps[lumpnum].filelen; + ofs = header->lumps[lumpnum].fileofs; + + if (buffer) + free(buffer); + + if (length % lumpspec->size) + Error("%s: odd %s lump size", __func__, lumpspec->name); + + buffer = *bufferptr = static_cast(malloc(length + 1)); + if (!buffer) + Error("%s: allocation of %i bytes failed.", __func__, length); + + memcpy(buffer, (const uint8_t *)header + ofs, length); + buffer[length] = 0; /* In case of corrupt entity lump */ + + return length / lumpspec->size; +} + + void BSPX_AddLump(bspdata_t *bspdata, const char *xname, const void *xdata, size_t xsize) { bspxentry_t *e; @@ -2762,37 +2286,32 @@ LoadBSPFile(char *filename, bspdata_t *bspdata) /* transfer the header data to these variables */ int numlumps; + int32_t version; lump_t *lumps; /* check for IBSP */ - bspversion_t temp_version { LittleLong(((int *)file_data)[0]) }; - - if (temp_version.ident == Q2_BSPIDENT || - temp_version.ident == Q2_QBISMIDENT) { + if (LittleLong(((int *)file_data)[0]) == Q2_BSPIDENT) { q2_dheader_t *q2header = (q2_dheader_t *)file_data; q2header->version = LittleLong(q2header->version); numlumps = Q2_HEADER_LUMPS; - temp_version.version = q2header->version; + version = q2header->version; lumps = q2header->lumps; } else { dheader_t *q1header = (dheader_t *)file_data; q1header->version = LittleLong(q1header->version); numlumps = BSP_LUMPS; + version = q1header->version; lumps = q1header->lumps; - - // not useful for Q1BSP, but we'll initialize it to -1 - temp_version.version = NO_VERSION; } + bspdata->loadversion = version; + /* check the file version */ - if (!BSPVersionSupported(temp_version.ident, temp_version.version, &bspdata->version)) { - logprint("BSP is version %s\n", BSPVersionString(&temp_version)); + logprint("BSP is version %s\n", BSPVersionString(version)); + if (!BSPVersionSupported(version)) Error("Sorry, this bsp version is not supported."); - } else { - logprint("BSP is version %s\n", BSPVersionString(bspdata->version)); - } /* swap the lump headers */ for (i = 0; i < numlumps; i++) { @@ -2800,175 +2319,152 @@ LoadBSPFile(char *filename, bspdata_t *bspdata) lumps[i].filelen = LittleLong(lumps[i].filelen); } + if (isHexen2((dheader_t *)file_data)) + { + logprint("BSP appears to be from hexen2\n"); + bspdata->hullcount = MAX_MAP_HULLS_H2; + } + else + bspdata->hullcount = MAX_MAP_HULLS_Q1; + /* copy the data */ - if (bspdata->version == &bspver_q2) { + if (version == Q2_BSPVERSION) { q2_dheader_t *header = (q2_dheader_t *)file_data; q2bsp_t *bsp = &bspdata->data.q2bsp; - + memset(bsp, 0, sizeof(*bsp)); - - bsp->nummodels = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_MODELS, &bsp->dmodels); - bsp->numvertexes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_VERTEXES, &bsp->dvertexes); - bsp->numplanes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_PLANES, &bsp->dplanes); - bsp->numleafs = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_LEAFS, &bsp->dleafs); - bsp->numnodes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_NODES, &bsp->dnodes); - bsp->numtexinfo = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_TEXINFO, &bsp->texinfo); - bsp->numfaces = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_FACES, &bsp->dfaces); - bsp->numleaffaces = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_LEAFFACES, &bsp->dleaffaces); - bsp->numleafbrushes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_LEAFBRUSHES, &bsp->dleafbrushes); - bsp->numsurfedges = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_SURFEDGES, &bsp->dsurfedges); - bsp->numedges = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_EDGES, &bsp->dedges); - bsp->numbrushes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_BRUSHES, &bsp->dbrushes); - bsp->numbrushsides = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_BRUSHSIDES, &bsp->dbrushsides); - bsp->numareas = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_AREAS, &bsp->dareas); - bsp->numareaportals = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_AREAPORTALS, &bsp->dareaportals); + bspdata->version = header->version; - bsp->visdatasize = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_VISIBILITY, &bsp->dvis); - bsp->lightdatasize = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_LIGHTING, &bsp->dlightdata); - bsp->entdatasize = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_ENTITIES, &bsp->dentdata); + bsp->nummodels = Q2_CopyLump (header, Q2_LUMP_MODELS, &bsp->dmodels); + bsp->numvertexes = Q2_CopyLump (header, Q2_LUMP_VERTEXES, &bsp->dvertexes); + bsp->numplanes = Q2_CopyLump (header, Q2_LUMP_PLANES, &bsp->dplanes); + bsp->numleafs = Q2_CopyLump (header, Q2_LUMP_LEAFS, &bsp->dleafs); + bsp->numnodes = Q2_CopyLump (header, Q2_LUMP_NODES, &bsp->dnodes); + bsp->numtexinfo = Q2_CopyLump (header, Q2_LUMP_TEXINFO, &bsp->texinfo); + bsp->numfaces = Q2_CopyLump (header, Q2_LUMP_FACES, &bsp->dfaces); + bsp->numleaffaces = Q2_CopyLump (header, Q2_LUMP_LEAFFACES, &bsp->dleaffaces); + bsp->numleafbrushes = Q2_CopyLump (header, Q2_LUMP_LEAFBRUSHES, &bsp->dleafbrushes); + bsp->numsurfedges = Q2_CopyLump (header, Q2_LUMP_SURFEDGES, &bsp->dsurfedges); + bsp->numedges = Q2_CopyLump (header, Q2_LUMP_EDGES, &bsp->dedges); + bsp->numbrushes = Q2_CopyLump (header, Q2_LUMP_BRUSHES, &bsp->dbrushes); + bsp->numbrushsides = Q2_CopyLump (header, Q2_LUMP_BRUSHSIDES, &bsp->dbrushsides); + bsp->numareas = Q2_CopyLump (header, Q2_LUMP_AREAS, &bsp->dareas); + bsp->numareaportals = Q2_CopyLump (header, Q2_LUMP_AREAPORTALS, &bsp->dareaportals); - CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_POP, &bsp->dpop); - } else if (bspdata->version == &bspver_qbism) { - q2_dheader_t *header = (q2_dheader_t *)file_data; - q2bsp_qbism_t *bsp = &bspdata->data.q2bsp_qbism; - - memset(bsp, 0, sizeof(*bsp)); - - bsp->nummodels = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_MODELS, &bsp->dmodels); - bsp->numvertexes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_VERTEXES, &bsp->dvertexes); - bsp->numplanes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_PLANES, &bsp->dplanes); - bsp->numleafs = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_LEAFS, &bsp->dleafs); - bsp->numnodes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_NODES, &bsp->dnodes); - bsp->numtexinfo = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_TEXINFO, &bsp->texinfo); - bsp->numfaces = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_FACES, &bsp->dfaces); - bsp->numleaffaces = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_LEAFFACES, &bsp->dleaffaces); - bsp->numleafbrushes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_LEAFBRUSHES, &bsp->dleafbrushes); - bsp->numsurfedges = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_SURFEDGES, &bsp->dsurfedges); - bsp->numedges = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_EDGES, &bsp->dedges); - bsp->numbrushes = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_BRUSHES, &bsp->dbrushes); - bsp->numbrushsides = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_BRUSHSIDES, &bsp->dbrushsides); - bsp->numareas = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_AREAS, &bsp->dareas); - bsp->numareaportals = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_AREAPORTALS, &bsp->dareaportals); + bsp->visdatasize = Q2_CopyLump (header, Q2_LUMP_VISIBILITY, &bsp->dvis); + bsp->lightdatasize = Q2_CopyLump (header, Q2_LUMP_LIGHTING, &bsp->dlightdata); + bsp->entdatasize = Q2_CopyLump (header, Q2_LUMP_ENTITIES, &bsp->dentdata); - bsp->visdatasize = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_VISIBILITY, &bsp->dvis); - bsp->lightdatasize = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_LIGHTING, &bsp->dlightdata); - bsp->entdatasize = CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_ENTITIES, &bsp->dentdata); - - CopyLump (header, bspdata->version, header->lumps, Q2_LUMP_POP, &bsp->dpop); - } else { - // Only Q1-like maps need hullcount - if (isHexen2((dheader_t *)file_data)) { - logprint("BSP appears to be from hexen2\n"); - // swap version over to H2 - bspdata->version = &bspver_h2; - bspdata->hullcount = MAX_MAP_HULLS_H2; - } else { - bspdata->hullcount = MAX_MAP_HULLS_Q1; - } + Q2_CopyLump (header, Q2_LUMP_POP, &bsp->dpop); } - if (bspdata->version == &bspver_q1 || bspdata->version == &bspver_h2 || bspdata->version == &bspver_hl) { + if (version == BSPVERSION || version == BSPHLVERSION) { dheader_t *header = (dheader_t *)file_data; bsp29_t *bsp = &bspdata->data.bsp29; memset(bsp, 0, sizeof(*bsp)); + bspdata->version = header->version; + bsp->nummodels = CopyLump(header, LUMP_MODELS, &bsp->dmodels); + bsp->numvertexes = CopyLump(header, LUMP_VERTEXES, &bsp->dvertexes); + bsp->numplanes = CopyLump(header, LUMP_PLANES, &bsp->dplanes); + bsp->numleafs = CopyLump(header, LUMP_LEAFS, &bsp->dleafs); + bsp->numnodes = CopyLump(header, LUMP_NODES, &bsp->dnodes); + bsp->numtexinfo = CopyLump(header, LUMP_TEXINFO, &bsp->texinfo); + bsp->numclipnodes = CopyLump(header, LUMP_CLIPNODES, &bsp->dclipnodes); + bsp->numfaces = CopyLump(header, LUMP_FACES, &bsp->dfaces); + bsp->nummarksurfaces = CopyLump(header, LUMP_MARKSURFACES, &bsp->dmarksurfaces); + bsp->numsurfedges = CopyLump(header, LUMP_SURFEDGES, &bsp->dsurfedges); + bsp->numedges = CopyLump(header, LUMP_EDGES, &bsp->dedges); - bsp->nummodels = CopyLump(header, bspdata->version, header->lumps, LUMP_MODELS, &bsp->dmodels); - bsp->numvertexes = CopyLump(header, bspdata->version, header->lumps, LUMP_VERTEXES, &bsp->dvertexes); - bsp->numplanes = CopyLump(header, bspdata->version, header->lumps, LUMP_PLANES, &bsp->dplanes); - bsp->numleafs = CopyLump(header, bspdata->version, header->lumps, LUMP_LEAFS, &bsp->dleafs); - bsp->numnodes = CopyLump(header, bspdata->version, header->lumps, LUMP_NODES, &bsp->dnodes); - bsp->numtexinfo = CopyLump(header, bspdata->version, header->lumps, LUMP_TEXINFO, &bsp->texinfo); - bsp->numclipnodes = CopyLump(header, bspdata->version, header->lumps, LUMP_CLIPNODES, &bsp->dclipnodes); - bsp->numfaces = CopyLump(header, bspdata->version, header->lumps, LUMP_FACES, &bsp->dfaces); - bsp->nummarksurfaces = CopyLump(header, bspdata->version, header->lumps, LUMP_MARKSURFACES, &bsp->dmarksurfaces); - bsp->numsurfedges = CopyLump(header, bspdata->version, header->lumps, LUMP_SURFEDGES, &bsp->dsurfedges); - bsp->numedges = CopyLump(header, bspdata->version, header->lumps, LUMP_EDGES, &bsp->dedges); + bsp->texdatasize = CopyLump(header, LUMP_TEXTURES, &bsp->dtexdata); + bsp->visdatasize = CopyLump(header, LUMP_VISIBILITY, &bsp->dvisdata); + bsp->lightdatasize = CopyLump(header, LUMP_LIGHTING, &bsp->dlightdata); + bsp->entdatasize = CopyLump(header, LUMP_ENTITIES, &bsp->dentdata); + } - bsp->texdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_TEXTURES, &bsp->dtexdata); - bsp->visdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_VISIBILITY, &bsp->dvisdata); - bsp->lightdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_LIGHTING, &bsp->dlightdata); - bsp->entdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_ENTITIES, &bsp->dentdata); - } else if (bspdata->version == &bspver_bsp2rmq) { + if (version == BSP2RMQVERSION) { dheader_t *header = (dheader_t *)file_data; bsp2rmq_t *bsp = &bspdata->data.bsp2rmq; memset(bsp, 0, sizeof(*bsp)); + bspdata->version = header->version; + bsp->nummodels = CopyLump(header, LUMP_MODELS, &bsp->dmodels); + bsp->numvertexes = CopyLump(header, LUMP_VERTEXES, &bsp->dvertexes); + bsp->numplanes = CopyLump(header, LUMP_PLANES, &bsp->dplanes); + bsp->numleafs = CopyLump(header, LUMP_LEAFS, &bsp->dleafs); + bsp->numnodes = CopyLump(header, LUMP_NODES, &bsp->dnodes); + bsp->numtexinfo = CopyLump(header, LUMP_TEXINFO, &bsp->texinfo); + bsp->numclipnodes = CopyLump(header, LUMP_CLIPNODES, &bsp->dclipnodes); + bsp->numfaces = CopyLump(header, LUMP_FACES, &bsp->dfaces); + bsp->nummarksurfaces = CopyLump(header, LUMP_MARKSURFACES, &bsp->dmarksurfaces); + bsp->numsurfedges = CopyLump(header, LUMP_SURFEDGES, &bsp->dsurfedges); + bsp->numedges = CopyLump(header, LUMP_EDGES, &bsp->dedges); - bsp->nummodels = CopyLump(header, bspdata->version, header->lumps, LUMP_MODELS, &bsp->dmodels); - bsp->numvertexes = CopyLump(header, bspdata->version, header->lumps, LUMP_VERTEXES, &bsp->dvertexes); - bsp->numplanes = CopyLump(header, bspdata->version, header->lumps, LUMP_PLANES, &bsp->dplanes); - bsp->numleafs = CopyLump(header, bspdata->version, header->lumps, LUMP_LEAFS, &bsp->dleafs); - bsp->numnodes = CopyLump(header, bspdata->version, header->lumps, LUMP_NODES, &bsp->dnodes); - bsp->numtexinfo = CopyLump(header, bspdata->version, header->lumps, LUMP_TEXINFO, &bsp->texinfo); - bsp->numclipnodes = CopyLump(header, bspdata->version, header->lumps, LUMP_CLIPNODES, &bsp->dclipnodes); - bsp->numfaces = CopyLump(header, bspdata->version, header->lumps, LUMP_FACES, &bsp->dfaces); - bsp->nummarksurfaces = CopyLump(header, bspdata->version, header->lumps, LUMP_MARKSURFACES, &bsp->dmarksurfaces); - bsp->numsurfedges = CopyLump(header, bspdata->version, header->lumps, LUMP_SURFEDGES, &bsp->dsurfedges); - bsp->numedges = CopyLump(header, bspdata->version, header->lumps, LUMP_EDGES, &bsp->dedges); + bsp->texdatasize = CopyLump(header, LUMP_TEXTURES, &bsp->dtexdata); + bsp->visdatasize = CopyLump(header, LUMP_VISIBILITY, &bsp->dvisdata); + bsp->lightdatasize = CopyLump(header, LUMP_LIGHTING, &bsp->dlightdata); + bsp->entdatasize = CopyLump(header, LUMP_ENTITIES, &bsp->dentdata); + } - bsp->texdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_TEXTURES, &bsp->dtexdata); - bsp->visdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_VISIBILITY, &bsp->dvisdata); - bsp->lightdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_LIGHTING, &bsp->dlightdata); - bsp->entdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_ENTITIES, &bsp->dentdata); - } else if (bspdata->version == &bspver_bsp2) { + if (version == BSP2VERSION) { dheader_t *header = (dheader_t *)file_data; bsp2_t *bsp = &bspdata->data.bsp2; memset(bsp, 0, sizeof(*bsp)); + bspdata->version = header->version; + bsp->nummodels = CopyLump(header, LUMP_MODELS, &bsp->dmodels); + bsp->numvertexes = CopyLump(header, LUMP_VERTEXES, &bsp->dvertexes); + bsp->numplanes = CopyLump(header, LUMP_PLANES, &bsp->dplanes); + bsp->numleafs = CopyLump(header, LUMP_LEAFS, &bsp->dleafs); + bsp->numnodes = CopyLump(header, LUMP_NODES, &bsp->dnodes); + bsp->numtexinfo = CopyLump(header, LUMP_TEXINFO, &bsp->texinfo); + bsp->numclipnodes = CopyLump(header, LUMP_CLIPNODES, &bsp->dclipnodes); + bsp->numfaces = CopyLump(header, LUMP_FACES, &bsp->dfaces); + bsp->nummarksurfaces = CopyLump(header, LUMP_MARKSURFACES, &bsp->dmarksurfaces); + bsp->numsurfedges = CopyLump(header, LUMP_SURFEDGES, &bsp->dsurfedges); + bsp->numedges = CopyLump(header, LUMP_EDGES, &bsp->dedges); - bsp->nummodels = CopyLump(header, bspdata->version, header->lumps, LUMP_MODELS, &bsp->dmodels); - bsp->numvertexes = CopyLump(header, bspdata->version, header->lumps, LUMP_VERTEXES, &bsp->dvertexes); - bsp->numplanes = CopyLump(header, bspdata->version, header->lumps, LUMP_PLANES, &bsp->dplanes); - bsp->numleafs = CopyLump(header, bspdata->version, header->lumps, LUMP_LEAFS, &bsp->dleafs); - bsp->numnodes = CopyLump(header, bspdata->version, header->lumps, LUMP_NODES, &bsp->dnodes); - bsp->numtexinfo = CopyLump(header, bspdata->version, header->lumps, LUMP_TEXINFO, &bsp->texinfo); - bsp->numclipnodes = CopyLump(header, bspdata->version, header->lumps, LUMP_CLIPNODES, &bsp->dclipnodes); - bsp->numfaces = CopyLump(header, bspdata->version, header->lumps, LUMP_FACES, &bsp->dfaces); - bsp->nummarksurfaces = CopyLump(header, bspdata->version, header->lumps, LUMP_MARKSURFACES, &bsp->dmarksurfaces); - bsp->numsurfedges = CopyLump(header, bspdata->version, header->lumps, LUMP_SURFEDGES, &bsp->dsurfedges); - bsp->numedges = CopyLump(header, bspdata->version, header->lumps, LUMP_EDGES, &bsp->dedges); - - bsp->texdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_TEXTURES, &bsp->dtexdata); - bsp->visdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_VISIBILITY, &bsp->dvisdata); - bsp->lightdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_LIGHTING, &bsp->dlightdata); - bsp->entdatasize = CopyLump(header, bspdata->version, header->lumps, LUMP_ENTITIES, &bsp->dentdata); + bsp->texdatasize = CopyLump(header, LUMP_TEXTURES, &bsp->dtexdata); + bsp->visdatasize = CopyLump(header, LUMP_VISIBILITY, &bsp->dvisdata); + bsp->lightdatasize = CopyLump(header, LUMP_LIGHTING, &bsp->dlightdata); + bsp->entdatasize = CopyLump(header, LUMP_ENTITIES, &bsp->dentdata); } - // detect BSPX - dheader_t *header = (dheader_t *)file_data; + if (version != Q2_BSPVERSION) { + dheader_t *header = (dheader_t *)file_data; - /*bspx header is positioned exactly+4align at the end of the last lump position (regardless of order)*/ - for (i = 0, bspxofs = 0; i < BSP_LUMPS; i++) - { - if (bspxofs < header->lumps[i].fileofs + header->lumps[i].filelen) - bspxofs = header->lumps[i].fileofs + header->lumps[i].filelen; - } - bspxofs = (bspxofs+3) & ~3; - /*okay, so that's where it *should* be if it exists */ - if (bspxofs + sizeof(*bspx) <= flen) - { - int xlumps; - const bspx_lump_t *xlump; - bspx = (const bspx_header_t*)((const uint8_t*)header + bspxofs); - xlump = (const bspx_lump_t*)(bspx+1); - xlumps = LittleLong(bspx->numlumps); - if (!memcmp(&bspx->id,"BSPX",4) && xlumps >= 0 && bspxofs+sizeof(*bspx)+sizeof(*xlump)*xlumps <= flen) + /*bspx header is positioned exactly+4align at the end of the last lump position (regardless of order)*/ + for (i = 0, bspxofs = 0; i < BSP_LUMPS; i++) { - /*header seems valid so far. just add the lumps as we normally would if we were generating them, ensuring that they get written out anew*/ - while(xlumps --> 0) - { - uint32_t ofs = LittleLong(xlump[xlumps].fileofs); - uint32_t len = LittleLong(xlump[xlumps].filelen); - void *lumpdata = malloc(len); - memcpy(lumpdata, (const uint8_t*)header + ofs, len); - BSPX_AddLump(bspdata, xlump[xlumps].lumpname, lumpdata, len); - } + if (bspxofs < header->lumps[i].fileofs + header->lumps[i].filelen) + bspxofs = header->lumps[i].fileofs + header->lumps[i].filelen; } - else + bspxofs = (bspxofs+3) & ~3; + /*okay, so that's where it *should* be if it exists */ + if (bspxofs + sizeof(*bspx) <= flen) { - if (!memcmp(&bspx->id,"BSPX",4)) - printf("invalid bspx header\n"); + int xlumps; + const bspx_lump_t *xlump; + bspx = (const bspx_header_t*)((const uint8_t*)header + bspxofs); + xlump = (const bspx_lump_t*)(bspx+1); + xlumps = LittleLong(bspx->numlumps); + if (!memcmp(&bspx->id,"BSPX",4) && xlumps >= 0 && bspxofs+sizeof(*bspx)+sizeof(*xlump)*xlumps <= flen) + { + /*header seems valid so far. just add the lumps as we normally would if we were generating them, ensuring that they get written out anew*/ + while(xlumps --> 0) + { + uint32_t ofs = LittleLong(xlump[xlumps].fileofs); + uint32_t len = LittleLong(xlump[xlumps].filelen); + void *lumpdata = malloc(len); + memcpy(lumpdata, (const uint8_t*)header + ofs, len); + BSPX_AddLump(bspdata, xlump[xlumps].lumpname, lumpdata, len); + } + } + else + { + if (!memcmp(&bspx->id,"BSPX",4)) + printf("invalid bspx header\n"); + } } } @@ -2982,13 +2478,11 @@ LoadBSPFile(char *filename, bspdata_t *bspdata) /* ========================================================================= */ typedef struct { - const bspversion_t *version; + int version; // which one is used depends on version - union { - dheader_t q1header; - q2_dheader_t q2header; - }; + dheader_t q1header; + q2_dheader_t q2header; FILE *file; } bspfile_t; @@ -2998,33 +2492,33 @@ AddLump(bspfile_t *bspfile, int lumpnum, const void *data, int count) { bool q2 = false; size_t size; - const lumpspec_t *lumpspec; - lump_t *lumps; - - if (bspfile->version == &bspver_q1 || bspfile->version == &bspver_h2 || bspfile->version == &bspver_hl) { - lumpspec = &lumpspec_bsp29[lumpnum]; - lumps = bspfile->q1header.lumps; - } else if (bspfile->version == &bspver_bsp2rmq) { - lumpspec = &lumpspec_bsp2rmq[lumpnum]; - lumps = bspfile->q1header.lumps; - } else if (bspfile->version == &bspver_bsp2) { - lumpspec = &lumpspec_bsp2[lumpnum]; - lumps = bspfile->q1header.lumps; - } else if (bspfile->version == &bspver_q2) { - lumpspec = &lumpspec_q2bsp[lumpnum]; - lumps = bspfile->q2header.lumps; - } else if (bspfile->version == &bspver_qbism) { - lumpspec = &lumpspec_qbism[lumpnum]; - lumps = bspfile->q2header.lumps; - } else { - Error("Unsupported BSP version: %s", BSPVersionString(bspfile->version)); + + switch (bspfile->version) { + case BSPVERSION: + case BSPHLVERSION: + size = lumpspec_bsp29[lumpnum].size * count; + break; + case BSP2RMQVERSION: + size = lumpspec_bsp2rmq[lumpnum].size * count; + break; + case BSP2VERSION: + size = lumpspec_bsp2[lumpnum].size * count; + break; + case Q2_BSPVERSION: + size = lumpspec_q2bsp[lumpnum].size * count; + q2 = true; + break; + default: + Error("Unsupported BSP version: %d", LittleLong(bspfile->version)); throw; //mxd. Fixes "Uninitialized variable" warning } - size = lumpspec->size * count; - uint8_t pad[4] = {0}; - lump_t *lump = &lumps[lumpnum]; + lump_t *lump; + if (q2) + lump = &bspfile->q2header.lumps[lumpnum]; + else + lump = &bspfile->q1header.lumps[lumpnum]; lump->fileofs = LittleLong(ftell(bspfile->file)); lump->filelen = LittleLong(size); @@ -3081,27 +2575,25 @@ WriteBSPFile(const char *filename, bspdata_t *bspdata) SwapBSPFile(bspdata, TO_DISK); bspfile.version = bspdata->version; - - // headers are union'd, so this sets both - bspfile.q2header.ident = LittleLong(bspfile.version->ident); - - if (bspfile.version->version != NO_VERSION) { - bspfile.q2header.version = LittleLong(bspfile.version->version); + if (bspfile.version == Q2_BSPVERSION) { + bspfile.q2header.ident = LittleLong(Q2_BSPIDENT); + bspfile.q2header.version = LittleLong(Q2_BSPVERSION); + } else { + bspfile.q1header.version = LittleLong(bspfile.version); } logprint("Writing %s as BSP version %s\n", filename, BSPVersionString(bspdata->version)); bspfile.file = SafeOpenWrite(filename); /* Save header space, updated after adding the lumps */ - if (bspfile.version->version != NO_VERSION) { + if (bspfile.version == Q2_BSPVERSION) { SafeWrite(bspfile.file, &bspfile.q2header, sizeof(bspfile.q2header)); } else { SafeWrite(bspfile.file, &bspfile.q1header, sizeof(bspfile.q1header)); } - if (bspdata->version == &bspver_q1 || - bspdata->version == &bspver_h2 || - bspdata->version == &bspver_hl) { + if (bspdata->version == BSPVERSION || + bspdata->version == BSPHLVERSION) { bsp29_t *bsp = &bspdata->data.bsp29; AddLump(&bspfile, LUMP_PLANES, bsp->dplanes, bsp->numplanes); @@ -3120,7 +2612,7 @@ WriteBSPFile(const char *filename, bspdata_t *bspdata) AddLump(&bspfile, LUMP_VISIBILITY, bsp->dvisdata, bsp->visdatasize); AddLump(&bspfile, LUMP_ENTITIES, bsp->dentdata, bsp->entdatasize); AddLump(&bspfile, LUMP_TEXTURES, bsp->dtexdata, bsp->texdatasize); - } else if (bspdata->version == &bspver_bsp2rmq) { + } else if (bspdata->version == BSP2RMQVERSION) { bsp2rmq_t *bsp = &bspdata->data.bsp2rmq; AddLump(&bspfile, LUMP_PLANES, bsp->dplanes, bsp->numplanes); @@ -3139,7 +2631,7 @@ WriteBSPFile(const char *filename, bspdata_t *bspdata) AddLump(&bspfile, LUMP_VISIBILITY, bsp->dvisdata, bsp->visdatasize); AddLump(&bspfile, LUMP_ENTITIES, bsp->dentdata, bsp->entdatasize); AddLump(&bspfile, LUMP_TEXTURES, bsp->dtexdata, bsp->texdatasize); - } else if (bspdata->version == &bspver_bsp2) { + } else if (bspdata->version == BSP2VERSION) { bsp2_t *bsp = &bspdata->data.bsp2; AddLump(&bspfile, LUMP_PLANES, bsp->dplanes, bsp->numplanes); @@ -3158,7 +2650,7 @@ WriteBSPFile(const char *filename, bspdata_t *bspdata) AddLump(&bspfile, LUMP_VISIBILITY, bsp->dvisdata, bsp->visdatasize); AddLump(&bspfile, LUMP_ENTITIES, bsp->dentdata, bsp->entdatasize); AddLump(&bspfile, LUMP_TEXTURES, bsp->dtexdata, bsp->texdatasize); - } else if (bspdata->version == &bspver_q2) { + } else if (bspdata->version == Q2_BSPVERSION) { q2bsp_t *bsp = &bspdata->data.q2bsp; AddLump(&bspfile, Q2_LUMP_MODELS, bsp->dmodels, bsp->nummodels); @@ -3177,29 +2669,6 @@ WriteBSPFile(const char *filename, bspdata_t *bspdata) AddLump(&bspfile, Q2_LUMP_AREAS, bsp->dareas, bsp->numareas); AddLump(&bspfile, Q2_LUMP_AREAPORTALS, bsp->dareaportals, bsp->numareaportals); - AddLump(&bspfile, Q2_LUMP_VISIBILITY, bsp->dvis, bsp->visdatasize); - AddLump(&bspfile, Q2_LUMP_LIGHTING, bsp->dlightdata, bsp->lightdatasize); - AddLump(&bspfile, Q2_LUMP_ENTITIES, bsp->dentdata, bsp->entdatasize); - AddLump(&bspfile, Q2_LUMP_POP, bsp->dpop, sizeof(bsp->dpop)); - } else if (bspdata->version == &bspver_qbism) { - q2bsp_qbism_t *bsp = &bspdata->data.q2bsp_qbism; - - AddLump(&bspfile, Q2_LUMP_MODELS, bsp->dmodels, bsp->nummodels); - AddLump(&bspfile, Q2_LUMP_VERTEXES, bsp->dvertexes, bsp->numvertexes); - AddLump(&bspfile, Q2_LUMP_PLANES, bsp->dplanes, bsp->numplanes); - AddLump(&bspfile, Q2_LUMP_LEAFS, bsp->dleafs, bsp->numleafs); - AddLump(&bspfile, Q2_LUMP_NODES, bsp->dnodes, bsp->numnodes); - AddLump(&bspfile, Q2_LUMP_TEXINFO, bsp->texinfo, bsp->numtexinfo); - AddLump(&bspfile, Q2_LUMP_FACES, bsp->dfaces, bsp->numfaces); - AddLump(&bspfile, Q2_LUMP_LEAFFACES, bsp->dleaffaces, bsp->numleaffaces); - AddLump(&bspfile, Q2_LUMP_LEAFBRUSHES, bsp->dleafbrushes, bsp->numleafbrushes); - AddLump(&bspfile, Q2_LUMP_SURFEDGES, bsp->dsurfedges, bsp->numsurfedges); - AddLump(&bspfile, Q2_LUMP_EDGES, bsp->dedges, bsp->numedges); - AddLump(&bspfile, Q2_LUMP_BRUSHES, bsp->dbrushes, bsp->numbrushes); - AddLump(&bspfile, Q2_LUMP_BRUSHSIDES, bsp->dbrushsides, bsp->numbrushsides); - AddLump(&bspfile, Q2_LUMP_AREAS, bsp->dareas, bsp->numareas); - AddLump(&bspfile, Q2_LUMP_AREAPORTALS, bsp->dareaportals, bsp->numareaportals); - AddLump(&bspfile, Q2_LUMP_VISIBILITY, bsp->dvis, bsp->visdatasize); AddLump(&bspfile, Q2_LUMP_LIGHTING, bsp->dlightdata, bsp->lightdatasize); AddLump(&bspfile, Q2_LUMP_ENTITIES, bsp->dentdata, bsp->entdatasize); @@ -3251,7 +2720,7 @@ WriteBSPFile(const char *filename, bspdata_t *bspdata) fseek(bspfile.file, 0, SEEK_SET); // write the real header - if (bspfile.version->version != NO_VERSION) { + if (bspfile.version == Q2_BSPVERSION) { SafeWrite(bspfile.file, &bspfile.q2header, sizeof(bspfile.q2header)); } else { SafeWrite(bspfile.file, &bspfile.q1header, sizeof(bspfile.q1header)); @@ -3280,7 +2749,7 @@ PrintBSPFileSizes(const bspdata_t *bspdata) { int numtextures = 0; - if (bspdata->version == &bspver_q2) { + if (bspdata->version == Q2_BSPVERSION) { const q2bsp_t *bsp = &bspdata->data.q2bsp; const lumpspec_t *lumpspec = lumpspec_q2bsp; @@ -3304,31 +2773,9 @@ PrintBSPFileSizes(const bspdata_t *bspdata) logprint("%7s %-12s %10i\n", "", "lightdata", bsp->lightdatasize); logprint("%7s %-12s %10i\n", "", "visdata", bsp->visdatasize); logprint("%7s %-12s %10i\n", "", "entdata", bsp->entdatasize); - } else if (bspdata->version == &bspver_qbism) { - const q2bsp_qbism_t *bsp = &bspdata->data.q2bsp_qbism; - const lumpspec_t *lumpspec = lumpspec_qbism; - - logprint("%7i %-12s\n", bsp->nummodels, "models"); - - PrintLumpSize(lumpspec, Q2_LUMP_PLANES, bsp->numplanes); - PrintLumpSize(lumpspec, Q2_LUMP_VERTEXES, bsp->numvertexes); - PrintLumpSize(lumpspec, Q2_LUMP_NODES, bsp->numnodes); - PrintLumpSize(lumpspec, Q2_LUMP_TEXINFO, bsp->numtexinfo); - PrintLumpSize(lumpspec, Q2_LUMP_FACES, bsp->numfaces); - PrintLumpSize(lumpspec, Q2_LUMP_LEAFS, bsp->numleafs); - PrintLumpSize(lumpspec, Q2_LUMP_LEAFFACES, bsp->numleaffaces); - PrintLumpSize(lumpspec, Q2_LUMP_LEAFBRUSHES, bsp->numleafbrushes); - PrintLumpSize(lumpspec, Q2_LUMP_EDGES, bsp->numedges); - PrintLumpSize(lumpspec, Q2_LUMP_SURFEDGES, bsp->numsurfedges); - PrintLumpSize(lumpspec, Q2_LUMP_BRUSHES, bsp->numbrushes); - PrintLumpSize(lumpspec, Q2_LUMP_BRUSHSIDES, bsp->numbrushsides); - PrintLumpSize(lumpspec, Q2_LUMP_AREAS, bsp->numareas); - PrintLumpSize(lumpspec, Q2_LUMP_AREAPORTALS, bsp->numareaportals); - - logprint("%7s %-12s %10i\n", "", "lightdata", bsp->lightdatasize); - logprint("%7s %-12s %10i\n", "", "visdata", bsp->visdatasize); - logprint("%7s %-12s %10i\n", "", "entdata", bsp->entdatasize); - } else if (bspdata->version == &bspver_q1 || bspdata->version == &bspver_h2 || bspdata->version == &bspver_hl) { + } + + if (bspdata->version == BSPVERSION || bspdata->version == BSPHLVERSION) { const bsp29_t *bsp = &bspdata->data.bsp29; const lumpspec_t *lumpspec = lumpspec_bsp29; @@ -3352,15 +2799,9 @@ PrintBSPFileSizes(const bspdata_t *bspdata) logprint("%7s %-12s %10i\n", "", "lightdata", bsp->lightdatasize); logprint("%7s %-12s %10i\n", "", "visdata", bsp->visdatasize); logprint("%7s %-12s %10i\n", "", "entdata", bsp->entdatasize); + } - if (bspdata->bspxentries) - { - bspxentry_t *x; - for (x = bspdata->bspxentries; x; x = x->next) { - logprint("%7s %-12s %10i\n", "BSPX", x->lumpname, (int)x->lumpsize); - } - } - } else if (bspdata->version == &bspver_bsp2rmq) { + if (bspdata->version == BSP2RMQVERSION) { const bsp2rmq_t *bsp = &bspdata->data.bsp2rmq; const lumpspec_t *lumpspec = lumpspec_bsp2rmq; @@ -3384,7 +2825,9 @@ PrintBSPFileSizes(const bspdata_t *bspdata) logprint("%7s %-12s %10i\n", "", "lightdata", bsp->lightdatasize); logprint("%7s %-12s %10i\n", "", "visdata", bsp->visdatasize); logprint("%7s %-12s %10i\n", "", "entdata", bsp->entdatasize); - } else if (bspdata->version == &bspver_bsp2) { + } + + if (bspdata->version == BSP2VERSION) { const bsp2_t *bsp = &bspdata->data.bsp2; const lumpspec_t *lumpspec = lumpspec_bsp2; @@ -3409,4 +2852,12 @@ PrintBSPFileSizes(const bspdata_t *bspdata) logprint("%7s %-12s %10i\n", "", "visdata", bsp->visdatasize); logprint("%7s %-12s %10i\n", "", "entdata", bsp->entdatasize); } + + if (bspdata->bspxentries) + { + bspxentry_t *x; + for (x = bspdata->bspxentries; x; x = x->next) { + logprint("%7s %-12s %10i\n", "BSPX", x->lumpname, (int)x->lumpsize); + } + } } diff --git a/common/bsputils.cc b/common/bsputils.cc index 53be82bf..b49cdeec 100644 --- a/common/bsputils.cc +++ b/common/bsputils.cc @@ -188,7 +188,7 @@ bool Face_IsLightmapped(const mbsp_t *bsp, const bsp2_dface_t *face) if (texinfo == nullptr) return false; - if (bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism) { + if (bsp->loadversion == Q2_BSPVERSION) { if (texinfo->flags & (Q2_SURF_WARP|Q2_SURF_SKY|Q2_SURF_NODRAW)) { //mxd. +Q2_SURF_NODRAW return false; } @@ -223,7 +223,7 @@ TextureName_Contents(const char *texname) bool //mxd Contents_IsTranslucent(const mbsp_t *bsp, const int contents) { - if (bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism) + if (bsp->loadversion == Q2_BSPVERSION) return (contents & Q2_SURF_TRANSLUCENT) && ((contents & Q2_SURF_TRANSLUCENT) != Q2_SURF_TRANSLUCENT); // Don't count KMQ2 fence flags combo as translucent else return contents == CONTENTS_WATER || contents == CONTENTS_LAVA || contents == CONTENTS_SLIME; @@ -238,7 +238,7 @@ Face_IsTranslucent(const mbsp_t *bsp, const bsp2_dface_t *face) int //mxd. Returns CONTENTS_ value for Q1, Q2_SURF_ bitflags for Q2... Face_Contents(const mbsp_t *bsp, const bsp2_dface_t *face) { - if (bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism) { + if (bsp->loadversion == Q2_BSPVERSION) { const gtexinfo_t *info = Face_Texinfo(bsp, face); return info->flags; } else { @@ -281,13 +281,8 @@ static bool Light_PointInSolid_r(const mbsp_t *bsp, const int nodenum, const vec { if (nodenum < 0) { const mleaf_t *leaf = BSP_GetLeafFromNodeNum(bsp, nodenum); - - //mxd - if (bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism) { - return leaf->contents & Q2_CONTENTS_SOLID; - } - return (leaf->contents == CONTENTS_SOLID || leaf->contents == CONTENTS_SKY); + return (bsp->loadversion == Q2_BSPVERSION ? leaf->contents & Q2_CONTENTS_SOLID : (leaf->contents == CONTENTS_SOLID || leaf->contents == CONTENTS_SKY)); //mxd } const bsp2_dnode_t *node = &bsp->dnodes[nodenum]; diff --git a/include/common/bspfile.hh b/include/common/bspfile.hh index 9183755b..7a6cb51c 100644 --- a/include/common/bspfile.hh +++ b/include/common/bspfile.hh @@ -52,41 +52,17 @@ #define MAX_ENT_KEY 32 #define MAX_ENT_VALUE 1024 -struct bspversion_t -{ - /* identifier value, the first int32_t in the header */ - int32_t ident; - /* version value, if supported; use NO_VERSION if a version is not required */ - int32_t version; - /* short name used for command line args, etc */ - const char *short_name; - /* full display name for printing */ - const char *name; -}; - -#define NO_VERSION -1 - #define BSPVERSION 29 #define BSP2RMQVERSION (('B' << 24) | ('S' << 16) | ('P' << 8) | '2') #define BSP2VERSION ('B' | ('S' << 8) | ('P' << 16) | ('2' << 24)) #define BSPHLVERSION 30 //24bit lighting, and private palettes in the textures lump. #define Q2_BSPIDENT (('P'<<24)+('S'<<16)+('B'<<8)+'I') #define Q2_BSPVERSION 38 -#define Q2_QBISMIDENT (('P'<<24)+('S'<<16)+('B'<<8)+'Q') -extern const bspversion_t bspver_generic, bspver_q1, bspver_h2, bspver_bsp2, bspver_bsp2rmq, bspver_hl, bspver_q2, bspver_qbism; - -/* table of supported versions */ -constexpr const bspversion_t *const bspversions[] = { - &bspver_generic, - &bspver_q1, - &bspver_h2, - &bspver_bsp2, - &bspver_bsp2rmq, - &bspver_hl, - &bspver_q2, - &bspver_qbism -}; +/* Not an actual file format, but the mbsp_t struct */ +/* TODO: Should probably separate the type tag for bspdata_t from the file + version numbers */ +#define GENERIC_BSP 99 typedef struct { int32_t fileofs; @@ -314,8 +290,6 @@ struct q2_dnode_t { uint16_t numfaces; // counting both sides }; -using q2_dnode_qbism_t = bsp2_dnode_t; - /* * Note that children are interpreted as unsigned values now, so that we can * handle > 32k clipnodes. Values > 0xFFF0 can be assumed to be CONTENTS @@ -413,8 +387,6 @@ typedef struct { uint32_t v[2]; /* vertex numbers */ } bsp2_dedge_t; -using q2_dedge_qbism_t = bsp2_dedge_t; - #define MAXLIGHTMAPS 4 typedef struct { int16_t planenum; @@ -452,18 +424,6 @@ typedef struct { int32_t lightofs; // start of [numstyles*surfsize] samples } q2_dface_t; -typedef struct { - uint32_t planenum; // NOTE: only difference from bsp2_dface_t - int32_t side; - int32_t firstedge; // we must support > 64k edges - int32_t numedges; - int32_t texinfo; - - // lighting info - uint8_t styles[MAXLIGHTMAPS]; - int32_t lightofs; // start of [numstyles*surfsize] samples -} q2_dface_qbism_t; - /* Ambient Sounds */ #define AMBIENT_WATER 0 #define AMBIENT_SKY 1 @@ -521,22 +481,6 @@ typedef struct { uint16_t numleafbrushes; } q2_dleaf_t; -typedef struct { - int32_t contents; // OR of all brushes (not needed?) - - int32_t cluster; - int32_t area; - - float mins[3]; // for frustum culling - float maxs[3]; - - uint32_t firstleafface; - uint32_t numleaffaces; - - uint32_t firstleafbrush; - uint32_t numleafbrushes; -} q2_dleaf_qbism_t; - typedef struct { // bsp2_dleaf_t int32_t contents; @@ -548,10 +492,10 @@ typedef struct { uint8_t ambient_level[NUM_AMBIENTS]; // q2 extras - int32_t cluster; - int32_t area; - uint32_t firstleafbrush; - uint32_t numleafbrushes; + int16_t cluster; + int16_t area; + uint16_t firstleafbrush; + uint16_t numleafbrushes; } mleaf_t; typedef struct { @@ -559,11 +503,6 @@ typedef struct { int16_t texinfo; } dbrushside_t; -typedef struct { - uint32_t planenum; // facing out of the leaf - int32_t texinfo; -} q2_dbrushside_qbism_t; - typedef struct { int32_t firstside; int32_t numsides; @@ -803,66 +742,8 @@ typedef struct { uint8_t dpop[256]; } q2bsp_t; -typedef struct { - int nummodels; - q2_dmodel_t *dmodels; - - int visdatasize; - dvis_t *dvis; - - int lightdatasize; - uint8_t *dlightdata; - - int entdatasize; - char *dentdata; - - int numleafs; - q2_dleaf_qbism_t *dleafs; - - int numplanes; - dplane_t *dplanes; - - int numvertexes; - dvertex_t *dvertexes; - - int numnodes; - q2_dnode_qbism_t *dnodes; - - int numtexinfo; - q2_texinfo_t *texinfo; - - int numfaces; - q2_dface_qbism_t *dfaces; - - int numedges; - q2_dedge_qbism_t *dedges; - - int numleaffaces; - uint32_t *dleaffaces; - - int numleafbrushes; - uint32_t *dleafbrushes; - - int numsurfedges; - int32_t *dsurfedges; - - int numareas; - darea_t *dareas; - - int numareaportals; - dareaportal_t *dareaportals; - - int numbrushes; - dbrush_t *dbrushes; - - int numbrushsides; - q2_dbrushside_qbism_t *dbrushsides; - - uint8_t dpop[256]; -} q2bsp_qbism_t; - struct mbsp_t { - const bspversion_t *loadversion; + int32_t loadversion; int nummodels; dmodelh2_t *dmodels; @@ -911,7 +792,7 @@ struct mbsp_t { uint32_t *dleaffaces; int numleafbrushes; - uint32_t *dleafbrushes; + uint16_t *dleafbrushes; int numsurfedges; int32_t *dsurfedges; @@ -926,7 +807,7 @@ struct mbsp_t { dbrush_t *dbrushes; int numbrushsides; - q2_dbrushside_qbism_t *dbrushsides; + dbrushside_t *dbrushsides; uint8_t dpop[256]; }; // "generic" bsp - superset of all other supported types @@ -943,7 +824,8 @@ typedef struct { } q2_dheader_t; typedef struct { - const bspversion_t *version, *loadversion; + int32_t loadversion; + int32_t version; int hullcount; struct { @@ -952,7 +834,6 @@ typedef struct { bsp2_t bsp2; q2bsp_t q2bsp; mbsp_t mbsp; - q2bsp_qbism_t q2bsp_qbism; } data; bspxentry_t *bspxentries; @@ -961,7 +842,7 @@ typedef struct { void LoadBSPFile(char *filename, bspdata_t *bspdata); //returns the filename as contained inside a bsp void WriteBSPFile(const char *filename, bspdata_t *bspdata); void PrintBSPFileSizes(const bspdata_t *bspdata); -void ConvertBSPFormat(bspdata_t *bspdata, const bspversion_t *to_version); +void ConvertBSPFormat(int32_t version, bspdata_t *bspdata); void BSPX_AddLump(bspdata_t *bspdata, const char *xname, const void *xdata, size_t xsize); const void *BSPX_GetLump(bspdata_t *bspdata, const char *xname, size_t *xsize); diff --git a/light/entities.cc b/light/entities.cc index 5ee1e76e..be2fd378 100644 --- a/light/entities.cc +++ b/light/entities.cc @@ -1579,7 +1579,7 @@ static void MakeSurfaceLights(const mbsp_t *bsp) for (int i = 0; i < bsp->numleafs; i++) { const mleaf_t *leaf = bsp->dleafs + i; - const qboolean underwater = ((bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism) ? leaf->contents & Q2_CONTENTS_LIQUID : leaf->contents != CONTENTS_EMPTY); //mxd + const qboolean underwater = (bsp->loadversion == Q2_BSPVERSION ? leaf->contents & Q2_CONTENTS_LIQUID : leaf->contents != CONTENTS_EMPTY); //mxd for (int k = 0; k < leaf->nummarksurfaces; k++) { const int facenum = bsp->dleaffaces[leaf->firstmarksurface + k]; diff --git a/light/imglib.cc b/light/imglib.cc index 37e9abac..3093db64 100644 --- a/light/imglib.cc +++ b/light/imglib.cc @@ -44,7 +44,7 @@ void // WHO TOUCHED MY PALET? LoadPalette(bspdata_t *bspdata) { // Load Quake 2 palette - if (bspdata->loadversion == &bspver_q2 || bspdata->loadversion == &bspver_qbism) { + if (bspdata->loadversion == Q2_BSPVERSION) { uint8_t *palette; char path[1024]; char colormap[] = "pics/colormap.pcx"; @@ -66,7 +66,7 @@ LoadPalette(bspdata_t *bspdata) for (int i = 0; i < 768; i++) thepalette[i] = palette[i]; - } else if (bspdata->loadversion == &bspver_h2) { + } else if (bspdata->hullcount == MAX_MAP_HULLS_H2) { // Gross hacks // Copy Hexen 2 palette for (int i = 0; i < 768; i++) thepalette[i] = hexen2palette[i]; @@ -721,7 +721,7 @@ void // Expects correct palette and game/mod paths to be set LoadOrConvertTextures(mbsp_t *bsp) { // Load or convert textures... - if (bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism) + if (bsp->loadversion == Q2_BSPVERSION) LoadTextures(bsp); else if (bsp->texdatasize > 0) ConvertTextures(bsp); diff --git a/light/light.cc b/light/light.cc index 4c4c0a90..2851c2b2 100644 --- a/light/light.cc +++ b/light/light.cc @@ -439,7 +439,7 @@ LightWorld(bspdata_t *bspdata, qboolean forcedscale) CalcualateVertexNormals(bsp); const qboolean bouncerequired = cfg_static.bounce.boolValue() && (debugmode == debugmode_none || debugmode == debugmode_bounce || debugmode == debugmode_bouncelights); //mxd - const qboolean isQuake2map = (bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism); //mxd + const qboolean isQuake2map = (bsp->loadversion == Q2_BSPVERSION); //mxd if (bouncerequired || isQuake2map) { MakeTextureColors(bsp); @@ -470,7 +470,7 @@ LightWorld(bspdata_t *bspdata, qboolean forcedscale) // Transfer greyscale lightmap (or color lightmap for Q2/HL) to the bsp and update lightdatasize if (!litonly) { free(bsp->dlightdata); - if (isQuake2map || bsp->loadversion == &bspver_hl) { + if (bsp->loadversion == Q2_BSPVERSION || bsp->loadversion == BSPHLVERSION) { bsp->lightdatasize = lit_file_p; bsp->dlightdata = (uint8_t *)malloc(bsp->lightdatasize); memcpy(bsp->dlightdata, lit_filebase, bsp->lightdatasize); @@ -545,9 +545,9 @@ LoadExtendedTexinfoFlags(const char *sourcefilename, const mbsp_t *bsp) static const char* //mxd GetBaseDirName(bspdata_t *bspdata) { - if (bspdata->loadversion == &bspver_q2 || bspdata->loadversion == &bspver_qbism) + if (bspdata->loadversion == Q2_BSPVERSION) return "BASEQ2"; - if (bspdata->loadversion == &bspver_h2) + if (bspdata->hullcount == MAX_MAP_HULLS_H2) return "DATA1"; return "ID1"; } @@ -951,7 +951,7 @@ light_main(int argc, const char **argv) { bspdata_t bspdata; mbsp_t *const bsp = &bspdata.data.mbsp; - const bspversion_t *loadversion; + int32_t loadversion; int i; double start; double end; @@ -1199,10 +1199,10 @@ light_main(int argc, const char **argv) LoadBSPFile(source, &bspdata); loadversion = bspdata.version; - ConvertBSPFormat(&bspdata, &bspver_generic); + ConvertBSPFormat(GENERIC_BSP, &bspdata); //mxd. Use 1.0 rangescale as a default to better match with qrad3/arghrad - if ((loadversion == &bspver_q2 || loadversion == &bspver_qbism) && !cfg.rangescale.isChanged()) + if (loadversion == Q2_BSPVERSION && !cfg.rangescale.isChanged()) { const auto rs = new lockable_vec_t(cfg.rangescale.primaryName(), 1.0f, 0.0f, 100.0f); cfg.rangescale = *rs; // Gross hacks to avoid displaying this in OptionsSummary... @@ -1242,7 +1242,7 @@ light_main(int argc, const char **argv) if (!onlyents) { - if (loadversion != &bspver_q2 && loadversion != &bspver_qbism && bsp->loadversion != &bspver_hl) //mxd. No lit for Quake 2 + if (loadversion != Q2_BSPVERSION && bsp->loadversion != BSPHLVERSION) //mxd. No lit for Quake 2 CheckLitNeeded(cfg); SetupDirt(cfg); @@ -1281,7 +1281,7 @@ light_main(int argc, const char **argv) WriteEntitiesToString(cfg, bsp); /* Convert data format back if necessary */ - ConvertBSPFormat(&bspdata, loadversion); + ConvertBSPFormat(loadversion, &bspdata); if (!litonly) { WriteBSPFile(source, &bspdata); diff --git a/light/ltface.cc b/light/ltface.cc index 365663f5..6c964877 100644 --- a/light/ltface.cc +++ b/light/ltface.cc @@ -1034,7 +1034,7 @@ GetLightContrib(const globalconfig_t &cfg, const light_t *entity, const vec3_t s if (dist < 0.1) { // Catch 0 distance between sample point and light (produces infinite brightness / nan's) and causes // problems later - dist = 0.1f; + dist = 0.1; VectorSet(surfpointToLightDir_out, 0, 0, 1); } const float add = GetLightValueWithAngle(cfg, entity, surfnorm, surfpointToLightDir_out, dist, twosided); @@ -3081,7 +3081,7 @@ WriteLightmaps(const mbsp_t *bsp, bsp2_dface_t *face, facesup_t *facesup, const continue; // skip lightmaps where all samples have brightness below 1 - if (bsp->loadversion != &bspver_q2 && bsp->loadversion != &bspver_qbism) { // HACK: don't do this on Q2. seems if all styles are 0xff, the face is drawn fullbright instead of black (Q1) + if (bsp->loadversion != Q2_BSPVERSION) { // HACK: don't do this on Q2. seems if all styles are 0xff, the face is drawn fullbright instead of black (Q1) const float maxb = Lightmap_MaxBrightness(&lightmap, lightsurf); if (maxb < 1) continue; @@ -3146,7 +3146,7 @@ WriteLightmaps(const mbsp_t *bsp, bsp2_dface_t *face, facesup_t *facesup, const // q2 support int lightofs; - if (bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism || bsp->loadversion == &bspver_hl) { + if (bsp->loadversion == Q2_BSPVERSION || bsp->loadversion == BSPHLVERSION) { lightofs = lit - lit_filebase; } else { lightofs = out - filebase; diff --git a/light/trace.cc b/light/trace.cc index 4bcf6174..3828cca3 100644 --- a/light/trace.cc +++ b/light/trace.cc @@ -716,7 +716,7 @@ TraceFaces (traceinfo_t *ti, int node, const vec3_t start, const vec3_t end) // only solid and sky faces stop the trace. bool issolid, issky; //mxd - if(bsp_static->loadversion == &bspver_q2 || bsp_static->loadversion == &bspver_qbism) { + if(bsp_static->loadversion == Q2_BSPVERSION) { issolid = !(fi->content & Q2_SURF_TRANSLUCENT); issky = (fi->content & Q2_SURF_SKY); } else { diff --git a/light/trace_embree.cc b/light/trace_embree.cc index f9a5322e..811fe4bc 100644 --- a/light/trace_embree.cc +++ b/light/trace_embree.cc @@ -354,7 +354,7 @@ Embree_FilterFuncN(const struct RTCFilterFunctionNArguments* args) //mxd bool isFence, isGlass; - if(bsp_static->loadversion == &bspver_q2 || bsp_static->loadversion == &bspver_qbism) { + if(bsp_static->loadversion == Q2_BSPVERSION) { const int contents = Face_Contents(bsp_static, face); isFence = ((contents & Q2_SURF_TRANSLUCENT) == Q2_SURF_TRANSLUCENT); // KMQuake 2-specific. Use texture alpha chanel when both flags are set. isGlass = !isFence && (contents & Q2_SURF_TRANSLUCENT); @@ -559,7 +559,7 @@ MakeFaces_r(const mbsp_t *bsp, const int nodenum, std::vector *planes, const int leafnum = -nodenum - 1; const mleaf_t *leaf = &bsp->dleafs[leafnum]; - if ((bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism) ? leaf->contents & Q2_CONTENTS_SOLID : leaf->contents == CONTENTS_SOLID) { + if (bsp->loadversion == Q2_BSPVERSION ? leaf->contents & Q2_CONTENTS_SOLID : leaf->contents == CONTENTS_SOLID) { std::vector leaf_windings = Leaf_MakeFaces(bsp, leaf, *planes); for (winding_t *w : leaf_windings) { result->push_back(w); @@ -631,16 +631,15 @@ Embree_TraceInit(const mbsp_t *bsp) const int contents = Face_Contents(bsp, face); //mxd const gtexinfo_t *texinfo = Face_Texinfo(bsp, face); - const bool is_q2 = bsp->loadversion == &bspver_q2 || bsp->loadversion == &bspver_qbism; //mxd. Skip NODRAW faces, but not SKY ones (Q2's sky01.wal has both flags set) - if(is_q2 && (contents & Q2_SURF_NODRAW) && !(contents & Q2_SURF_SKY)) + if(bsp->loadversion == Q2_BSPVERSION && (contents & Q2_SURF_NODRAW) && !(contents & Q2_SURF_SKY)) continue; // handle glass / water const float alpha = Face_Alpha(model, face); if (alpha < 1.0f - || (is_q2 && (contents & Q2_SURF_TRANSLUCENT))) { //mxd. Both fence and transparent textures are done using SURF_TRANS flags in Q2 + || (bsp->loadversion == Q2_BSPVERSION && (contents & Q2_SURF_TRANSLUCENT))) { //mxd. Both fence and transparent textures are done using SURF_TRANS flags in Q2 filterfaces.push_back(face); continue; } @@ -653,7 +652,7 @@ Embree_TraceInit(const mbsp_t *bsp) } // handle sky - if (is_q2) { + if (bsp->loadversion == Q2_BSPVERSION) { // Q2: arghrad compat: sky faces only emit sunlight if: // sky flag set, light flag set, value nonzero if ((contents & Q2_SURF_SKY) != 0 diff --git a/vis/vis.cc b/vis/vis.cc index afe29eaf..64daa1b8 100644 --- a/vis/vis.cc +++ b/vis/vis.cc @@ -1234,7 +1234,7 @@ main(int argc, char **argv) { bspdata_t bspdata; mbsp_t *const bsp = &bspdata.data.mbsp; - const bspversion_t *loadversion; + int32_t loadversion; int i; init_log("vis.log"); @@ -1309,7 +1309,7 @@ main(int argc, char **argv) LoadBSPFile(sourcefile, &bspdata); loadversion = bspdata.version; - ConvertBSPFormat(&bspdata, &bspver_generic); + ConvertBSPFormat(GENERIC_BSP, &bspdata); strcpy(portalfile, argv[i]); StripExtension(portalfile); @@ -1341,7 +1341,7 @@ main(int argc, char **argv) CalcAmbientSounds(bsp); /* Convert data format back if necessary */ - ConvertBSPFormat(&bspdata, loadversion); + ConvertBSPFormat(loadversion, &bspdata); WriteBSPFile(sourcefile, &bspdata);