olegpz
/
ericw-tools
mirror of https://github.com/ericwa/ericw-tools.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use variant instead of having all BSP types allocated at once (even though they are smol) 

Move ownership of pointers to the bsp structures themselves for now.
This commit is contained in:
Jonathan 2021-09-16 11:52:37 -04:00
parent e8bd554cc0
commit 17606fde4b
7 changed files with 1108 additions and 1190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bspinfo/bspinfo.cc
View File

@ -160,7 +160,7 @@ int main(int argc, char **argv)
strcat(source, ".json");
ConvertBSPFormat(&bsp, &bspver_generic);
serialize_bsp(bsp.data.mbsp, source);
serialize_bsp(std::get<mbsp_t>(bsp.bsp), source);
printf("---------------------\n");
}

39
bsputil/bsputil.cc
View File

@ -436,27 +436,27 @@ static void CheckBSPFile(const mbsp_t *bsp)
bsp->dmodels[0].mins[2], bsp->dmodels[0].maxs[0], bsp->dmodels[0].maxs[1], bsp->dmodels[0].maxs[2]);
}
static void CompareBSPFiles(const mbsp_t *refBsp, const mbsp_t *bsp)
static void CompareBSPFiles(const mbsp_t &refBsp, const mbsp_t &bsp)
{
printf("comparing %d with %d faces\n", refBsp->numfaces, bsp->numfaces);
printf("comparing %d with %d faces\n", refBsp.numfaces, bsp.numfaces);
const dmodel_t *world = BSP_GetWorldModel(bsp);
const dmodel_t *refWorld = BSP_GetWorldModel(refBsp);
const dmodel_t *world = BSP_GetWorldModel(&bsp);
const dmodel_t *refWorld = BSP_GetWorldModel(&refBsp);
// iterate through the refBsp world faces
for (int i = 0; i < refWorld->numfaces; i++) {
auto *refFace = BSP_GetFace(refBsp, refWorld->firstface + i);
qvec3f refFaceCentroid = Face_Centroid(refBsp, refFace);
auto *refFace = BSP_GetFace(&refBsp, refWorld->firstface + i);
qvec3f refFaceCentroid = Face_Centroid(&refBsp, refFace);
// FIXME:
vec3_t wantedPoint;
VectorCopy(refFaceCentroid, wantedPoint);
vec3_t wantedNormal;
Face_Normal(refBsp, refFace, wantedNormal);
Face_Normal(&refBsp, refFace, wantedNormal);
// Search for a face in bsp touching refFaceCentroid.
auto *matchedFace = BSP_FindFaceAtPoint(bsp, world, wantedPoint, wantedNormal);
auto *matchedFace = BSP_FindFaceAtPoint(&bsp, world, wantedPoint, wantedNormal);
if (matchedFace == nullptr) {
printf("couldn't find a face at %f %f %f normal %f %f %f\n", wantedPoint[0], wantedPoint[1], wantedPoint[2],
wantedNormal[0], wantedNormal[1], wantedNormal[2]);
@ -490,7 +490,8 @@ static void FindFaces(const mbsp_t *bsp, const vec3_t &pos, const vec3_t &normal
int main(int argc, char **argv)
{
bspdata_t bspdata;
mbsp_t *const bsp = &bspdata.data.mbsp;
mbsp_t &bsp = bspdata.bsp.emplace<mbsp_t>();
char source[1024];
FILE *f;
int i, err;
@ -530,7 +531,7 @@ int main(int argc, char **argv)
printf("comparing reference bsp %s with test bsp %s\n", refbspname, source);
CompareBSPFiles(&refbspdata.data.mbsp, &bspdata.data.mbsp);
CompareBSPFiles(std::get<mbsp_t>(refbspdata.bsp), bsp);
break;
} else if (!strcmp(argv[i], "--convert")) {
@ -570,8 +571,8 @@ int main(int argc, char **argv)
if (!f)
Error("couldn't open %s for writing\n", source);
err = fwrite(bsp->dentdata, sizeof(char), bsp->entdatasize - 1, f);
if (err != bsp->entdatasize - 1)
err = fwrite(bsp.dentdata, sizeof(char), bsp.entdatasize - 1, f);
if (err != bsp.entdatasize - 1)
Error("%s", strerror(errno));
err = fclose(f);
@ -588,7 +589,7 @@ int main(int argc, char **argv)
if (!f)
Error("couldn't open %s for writing\n", source);
ExportWad(f, bsp);
ExportWad(f, &bsp);
err = fclose(f);
if (err)
@ -597,11 +598,11 @@ int main(int argc, char **argv)
printf("done.\n");
} else if (!strcmp(argv[i], "--check")) {
printf("Beginning BSP data check...\n");
CheckBSPFile(bsp);
CheckBSPFacesPlanar(bsp);
CheckBSPFile(&bsp);
CheckBSPFacesPlanar(&bsp);
printf("Done.\n");
} else if (!strcmp(argv[i], "--modelinfo")) {
PrintModelInfo(bsp);
PrintModelInfo(&bsp);
} else if (!strcmp(argv[i], "--findfaces")) {
// (i + 1) ... (i + 6) = x y z nx ny nz
// i + 7 = bsp file
@ -613,7 +614,7 @@ int main(int argc, char **argv)
try {
const vec3_t pos = {std::stof(argv[i + 1]), std::stof(argv[i + 2]), std::stof(argv[i + 3])};
const vec3_t normal = {std::stof(argv[i + 4]), std::stof(argv[i + 5]), std::stof(argv[i + 6])};
FindFaces(bsp, pos, normal);
FindFaces(&bsp, pos, normal);
}
catch (const std::exception &) {
printf("Error reading position/normal\n");
@ -630,7 +631,7 @@ int main(int argc, char **argv)
const int fnum = std::stoi(argv[i + 1]);
const int texinfonum = std::stoi(argv[i + 2]);
bsp2_dface_t *face = BSP_GetFace(bsp, fnum);
bsp2_dface_t *face = BSP_GetFace(&bsp, fnum);
face->texinfo = texinfonum;
ConvertBSPFormat(&bspdata, bspdata.loadversion);
@ -653,7 +654,7 @@ int main(int argc, char **argv)
decomp_options options;
options.geometryOnly = geomOnly;
DecompileBSP(bsp, options, f);
DecompileBSP(&bsp, options, f);
fclose(f);
printf("done.\n");

1940
common/bspfile.cc
View File

File diff suppressed because it is too large Load Diff

162
include/common/bspfile.hh
View File

@ -21,6 +21,7 @@
#include <cstdint>
#include <array>
#include <variant>
#include <common/cmdlib.hh>
#include <common/log.hh>
@ -730,6 +731,15 @@ struct bspxentry_t
bspxentry_t *next;
};
// this is just temporary until the types use typesafe
// containers.
#define IMPL_MOVE_COPY(T) \
T() { memset(this, 0, sizeof(*this)); } \
T(T &&move) { memcpy(this, &move, sizeof(move)); memset(&move, 0, sizeof(move)); } \
T(const T &copy) { memcpy(this, &copy, sizeof(copy)); } \
T &operator=(T &&move) { memcpy(this, &move, sizeof(move)); memset(&move, 0, sizeof(move)); return *this; } \
T &operator=(const T &copy) { memcpy(this, &copy, sizeof(copy)); return *this; }
struct bsp29_t
{
int nummodels;
@ -777,6 +787,28 @@ struct bsp29_t
int numsurfedges;
int32_t *dsurfedges;
IMPL_MOVE_COPY(bsp29_t);
~bsp29_t()
{
delete[] dmodels_q;
delete[] dmodels_h2;
delete[] dvisdata;
delete[] dlightdata;
delete[] dtexdata;
delete[] dentdata;
delete[] dleafs;
delete[] dplanes;
delete[] dvertexes;
delete[] dnodes;
delete[] texinfo;
delete[] dfaces;
delete[] dclipnodes;
delete[] dedges;
delete[] dmarksurfaces;
delete[] dsurfedges;
}
};
struct bsp2rmq_t
@ -826,6 +858,28 @@ struct bsp2rmq_t
int numsurfedges;
int32_t *dsurfedges;
IMPL_MOVE_COPY(bsp2rmq_t);
~bsp2rmq_t()
{
delete[] dmodels_q;
delete[] dmodels_h2;
delete[] dvisdata;
delete[] dlightdata;
delete[] dtexdata;
delete[] dentdata;
delete[] dleafs;
delete[] dplanes;
delete[] dvertexes;
delete[] dnodes;
delete[] texinfo;
delete[] dfaces;
delete[] dclipnodes;
delete[] dedges;
delete[] dmarksurfaces;
delete[] dsurfedges;
}
};
struct bsp2_t
@ -875,6 +929,28 @@ struct bsp2_t
int numsurfedges;
int32_t *dsurfedges;
IMPL_MOVE_COPY(bsp2_t);
~bsp2_t()
{
delete[] dmodels_q;
delete[] dmodels_h2;
delete[] dvisdata;
delete[] dlightdata;
delete[] dtexdata;
delete[] dentdata;
delete[] dleafs;
delete[] dplanes;
delete[] dvertexes;
delete[] dnodes;
delete[] texinfo;
delete[] dfaces;
delete[] dclipnodes;
delete[] dedges;
delete[] dmarksurfaces;
delete[] dsurfedges;
}
};
struct q2bsp_t
@ -937,6 +1013,30 @@ struct q2bsp_t
dbrushside_t *dbrushsides;
uint8_t dpop[256];
IMPL_MOVE_COPY(q2bsp_t);
~q2bsp_t()
{
delete[] dmodels;
delete[] dvis;
delete[] dlightdata;
delete[] dentdata;
delete[] dleafs;
delete[] dplanes;
delete[] dvertexes;
delete[] dnodes;
delete[] texinfo;
delete[] dfaces;
delete[] dedges;
delete[] dleaffaces;
delete[] dleafbrushes;
delete[] dsurfedges;
delete[] dareas;
delete[] dareaportals;
delete[] dbrushes;
delete[] dbrushsides;
}
};
struct q2bsp_qbism_t
@ -999,6 +1099,30 @@ struct q2bsp_qbism_t
q2_dbrushside_qbism_t *dbrushsides;
uint8_t dpop[256];
IMPL_MOVE_COPY(q2bsp_qbism_t);
~q2bsp_qbism_t()
{
delete[] dmodels;
delete[] dvis;
delete[] dlightdata;
delete[] dentdata;
delete[] dleafs;
delete[] dplanes;
delete[] dvertexes;
delete[] dnodes;
delete[] texinfo;
delete[] dfaces;
delete[] dedges;
delete[] dleaffaces;
delete[] dleafbrushes;
delete[] dsurfedges;
delete[] dareas;
delete[] dareaportals;
delete[] dbrushes;
delete[] dbrushsides;
}
};
struct bspversion_t;
@ -1072,6 +1196,33 @@ struct mbsp_t
q2_dbrushside_qbism_t *dbrushsides;
uint8_t dpop[256];
IMPL_MOVE_COPY(mbsp_t);
~mbsp_t()
{
delete[] dmodels;
delete[] dvisdata;
delete[] dlightdata;
delete[] dtexdata;
delete[] drgbatexdata; // mxd
delete[] dentdata;
delete[] dleafs;
delete[] dplanes;
delete[] dvertexes;
delete[] dnodes;
delete[] texinfo;
delete[] dfaces;
delete[] dclipnodes;
delete[] dedges;
delete[] dleaffaces;
delete[] dleafbrushes;
delete[] dsurfedges;
delete[] dareas;
delete[] dareaportals;
delete[] dbrushes;
delete[] dbrushsides;
}
}; // "generic" bsp - superset of all other supported types
struct dheader_t
@ -1091,15 +1242,8 @@ struct bspdata_t
{
const bspversion_t *version, *loadversion;
struct
{
bsp29_t bsp29;
bsp2rmq_t bsp2rmq;
bsp2_t bsp2;
q2bsp_t q2bsp;
mbsp_t mbsp;
q2bsp_qbism_t q2bsp_qbism;
} data;
// Stay in monostate until a BSP type is requested.
std::variant<std::monostate, mbsp_t, bsp29_t, bsp2rmq_t, bsp2_t, q2bsp_t, q2bsp_qbism_t> bsp;
bspxentry_t *bspxentries;
};

88
light/light.cc
View File

@ -380,7 +380,8 @@ static void LightWorld(bspdata_t *bspdata, qboolean forcedscale)
{
logprint("--- LightWorld ---\n");
mbsp_t *const bsp = &bspdata->data.mbsp;
mbsp_t &bsp = std::get<mbsp_t>(bspdata->bsp);
delete[] filebase;
delete[] lit_filebase;
delete[] lux_filebase;
@ -413,30 +414,30 @@ static void LightWorld(bspdata_t *bspdata, qboolean forcedscale)
if (!lmshift_lump && write_litfile != ~0)
faces_sup = nullptr; // no scales, no lit2
else { // we have scales or lit2 output. yay...
faces_sup = new facesup_t[bsp->numfaces] { };
faces_sup = new facesup_t[bsp.numfaces] { };
if (lmshift_lump) {
for (int i = 0; i < bsp->numfaces; i++)
for (int i = 0; i < bsp.numfaces; i++)
faces_sup[i].lmscale = 1 << lmshift_lump[i];
} else {
for (int i = 0; i < bsp->numfaces; i++)
for (int i = 0; i < bsp.numfaces; i++)
faces_sup[i].lmscale = modelinfo.at(0)->lightmapscale;
}
}
CalculateVertexNormals(bsp);
CalculateVertexNormals(&bsp);
const qboolean bouncerequired =
cfg_static.bounce.boolValue() &&
(debugmode == debugmode_none || debugmode == debugmode_bounce || debugmode == debugmode_bouncelights); // mxd
const qboolean isQuake2map = bsp->loadversion->game->id == GAME_QUAKE_II; // mxd
const qboolean isQuake2map = bsp.loadversion->game->id == GAME_QUAKE_II; // mxd
if (bouncerequired || isQuake2map) {
MakeTextureColors(bsp);
MakeTextureColors(&bsp);
if (isQuake2map)
MakeSurfaceLights(cfg_static, bsp);
MakeSurfaceLights(cfg_static, &bsp);
if (bouncerequired)
MakeBounceLights(cfg_static, bsp);
MakeBounceLights(cfg_static, &bsp);
}
#if 0
@ -447,7 +448,7 @@ static void LightWorld(bspdata_t *bspdata, qboolean forcedscale)
RunThreadsOn(0, info.all_batches.size(), LightBatchThread, &info);
#else
logprint("--- LightThread ---\n"); // mxd
RunThreadsOn(0, bsp->numfaces, LightThread, bsp);
RunThreadsOn(0, bsp.numfaces, LightThread, &bsp);
#endif
if (bouncerequired || isQuake2map) { // mxd. Print some extra stats...
@ -460,31 +461,31 @@ static void LightWorld(bspdata_t *bspdata, qboolean forcedscale)
// Transfer greyscale lightmap (or color lightmap for Q2/HL) to the bsp and update lightdatasize
if (!litonly) {
delete[] bsp->dlightdata;
if (bsp->loadversion->game->has_rgb_lightmap) {
bsp->lightdatasize = lit_file_p;
bsp->dlightdata = new uint8_t[bsp->lightdatasize];
memcpy(bsp->dlightdata, lit_filebase, bsp->lightdatasize);
delete[] bsp.dlightdata;
if (bsp.loadversion->game->has_rgb_lightmap) {
bsp.lightdatasize = lit_file_p;
bsp.dlightdata = new uint8_t[bsp.lightdatasize];
memcpy(bsp.dlightdata, lit_filebase, bsp.lightdatasize);
} else {
bsp->lightdatasize = file_p;
bsp->dlightdata = new uint8_t[bsp->lightdatasize];
memcpy(bsp->dlightdata, filebase, bsp->lightdatasize);
bsp.lightdatasize = file_p;
bsp.dlightdata = new uint8_t[bsp.lightdatasize];
memcpy(bsp.dlightdata, filebase, bsp.lightdatasize);
}
} else {
// NOTE: bsp->lightdatasize is already valid in the -litonly case
// NOTE: bsp.lightdatasize is already valid in the -litonly case
}
logprint("lightdatasize: %i\n", bsp->lightdatasize);
logprint("lightdatasize: %i\n", bsp.lightdatasize);
if (faces_sup) {
uint8_t *styles = new uint8_t[4 * bsp->numfaces];
int32_t *offsets = new int32_t[bsp->numfaces];
for (int i = 0; i < bsp->numfaces; i++) {
uint8_t *styles = new uint8_t[4 * bsp.numfaces];
int32_t *offsets = new int32_t[bsp.numfaces];
for (int i = 0; i < bsp.numfaces; i++) {
offsets[i] = faces_sup[i].lightofs;
for (int j = 0; j < MAXLIGHTMAPS; j++)
styles[i * 4 + j] = faces_sup[i].styles[j];
}
BSPX_AddLump(bspdata, "LMSTYLE", styles, sizeof(*styles) * 4 * bsp->numfaces);
BSPX_AddLump(bspdata, "LMOFFSET", offsets, sizeof(*offsets) * bsp->numfaces);
BSPX_AddLump(bspdata, "LMSTYLE", styles, sizeof(*styles) * 4 * bsp.numfaces);
BSPX_AddLump(bspdata, "LMOFFSET", offsets, sizeof(*offsets) * bsp.numfaces);
} else {
// kill this stuff if its somehow found.
BSPX_AddLump(bspdata, "LMSTYLE", NULL, 0);
@ -914,7 +915,6 @@ static const char *ParseString(int *i_inout, int argc, const char **argv)
int light_main(int argc, const char **argv)
{
bspdata_t bspdata;
mbsp_t *const bsp = &bspdata.data.mbsp;
const bspversion_t *loadversion;
int i;
double start;
@ -1158,6 +1158,8 @@ int light_main(int argc, const char **argv)
loadversion = bspdata.version;
ConvertBSPFormat(&bspdata, &bspver_generic);
mbsp_t &bsp = std::get<mbsp_t>(bspdata.bsp);
// mxd. Use 1.0 rangescale as a default to better match with qrad3/arghrad
if ((loadversion->game->id == GAME_QUAKE_II) && !cfg.rangescale.isChanged()) {
const auto rs = new lockable_vec_t(cfg.rangescale.primaryName(), 1.0f, 0.0f, 100.0f);
@ -1167,32 +1169,32 @@ int light_main(int argc, const char **argv)
// mxd. Load or convert textures...
SetQdirFromPath(GetBaseDirName(&bspdata), source);
LoadPalette(&bspdata);
LoadOrConvertTextures(bsp);
LoadOrConvertTextures(&bsp);
LoadExtendedTexinfoFlags(source, bsp);
LoadEntities(cfg, bsp);
LoadExtendedTexinfoFlags(source, &bsp);
LoadEntities(cfg, &bsp);
PrintOptionsSummary();
FindModelInfo(bsp, lmscaleoverride);
FindModelInfo(&bsp, lmscaleoverride);
FindDebugFace(bsp);
FindDebugVert(bsp);
FindDebugFace(&bsp);
FindDebugVert(&bsp);
MakeTnodes(bsp);
MakeTnodes(&bsp);
if (debugmode == debugmode_phong_obj) {
StripExtension(source);
DefaultExtension(source, ".obj");
CalculateVertexNormals(bsp);
ExportObj(source, bsp);
CalculateVertexNormals(&bsp);
ExportObj(source, &bsp);
close_log();
return 0;
}
SetupLights(cfg, bsp);
SetupLights(cfg, &bsp);
// PrintLights();
@ -1209,30 +1211,30 @@ int light_main(int argc, const char **argv)
BSPX_AddLump(&bspdata, "LIGHTINGDIR", NULL, 0);
if (write_litfile == ~0) {
WriteLitFile(bsp, faces_sup, source, 2);
WriteLitFile(&bsp, faces_sup, source, 2);
return 0; // run away before any files are written
} else {
/*fixme: add a new per-surface offset+lmscale lump for compat/versitility?*/
if (write_litfile & 1)
WriteLitFile(bsp, faces_sup, source, LIT_VERSION);
WriteLitFile(&bsp, faces_sup, source, LIT_VERSION);
if (write_litfile & 2)
BSPX_AddLump(&bspdata, "RGBLIGHTING", lit_filebase, bsp->lightdatasize * 3);
BSPX_AddLump(&bspdata, "RGBLIGHTING", lit_filebase, bsp.lightdatasize * 3);
if (write_luxfile & 1)
WriteLuxFile(bsp, source, LIT_VERSION);
WriteLuxFile(&bsp, source, LIT_VERSION);
if (write_luxfile & 2)
BSPX_AddLump(&bspdata, "LIGHTINGDIR", lux_filebase, bsp->lightdatasize * 3);
BSPX_AddLump(&bspdata, "LIGHTINGDIR", lux_filebase, bsp.lightdatasize * 3);
}
}
/* -novanilla + internal lighting = no grey lightmap */
if (scaledonly && (write_litfile & 2))
bsp->lightdatasize = 0;
bsp.lightdatasize = 0;
#if 0
ExportObj(source, bsp);
#endif
WriteEntitiesToString(cfg, bsp);
WriteEntitiesToString(cfg, &bsp);
/* Convert data format back if necessary */
ConvertBSPFormat(&bspdata, loadversion);

50
qbsp/writebsp.cc
View File

@ -400,27 +400,28 @@ WriteBSPFile
*/
static void WriteBSPFile()
{
bspdata_t bspdata{};
bspdata_t bspdata { };
mbsp_t &bsp = bspdata.bsp.emplace<mbsp_t>();
bspdata.version = &bspver_generic;
CopyVector(map.exported_planes, &bspdata.data.mbsp.numplanes, &bspdata.data.mbsp.dplanes);
CopyVector(map.exported_leafs, &bspdata.data.mbsp.numleafs, &bspdata.data.mbsp.dleafs);
CopyVector(map.exported_vertexes, &bspdata.data.mbsp.numvertexes, &bspdata.data.mbsp.dvertexes);
CopyVector(map.exported_nodes, &bspdata.data.mbsp.numnodes, &bspdata.data.mbsp.dnodes);
CopyVector(map.exported_texinfos, &bspdata.data.mbsp.numtexinfo, &bspdata.data.mbsp.texinfo);
CopyVector(map.exported_faces, &bspdata.data.mbsp.numfaces, &bspdata.data.mbsp.dfaces);
CopyVector(map.exported_clipnodes, &bspdata.data.mbsp.numclipnodes, &bspdata.data.mbsp.dclipnodes);
CopyVector(map.exported_marksurfaces, &bspdata.data.mbsp.numleaffaces, &bspdata.data.mbsp.dleaffaces);
CopyVector(map.exported_surfedges, &bspdata.data.mbsp.numsurfedges, &bspdata.data.mbsp.dsurfedges);
CopyVector(map.exported_edges, &bspdata.data.mbsp.numedges, &bspdata.data.mbsp.dedges);
CopyVector(map.exported_models, &bspdata.data.mbsp.nummodels, &bspdata.data.mbsp.dmodels);
CopyVector(map.exported_leafbrushes, &bspdata.data.mbsp.numleafbrushes, &bspdata.data.mbsp.dleafbrushes);
CopyVector(map.exported_brushsides, &bspdata.data.mbsp.numbrushsides, &bspdata.data.mbsp.dbrushsides);
CopyVector(map.exported_brushes, &bspdata.data.mbsp.numbrushes, &bspdata.data.mbsp.dbrushes);
CopyVector(map.exported_planes, &bsp.numplanes, &bsp.dplanes);
CopyVector(map.exported_leafs, &bsp.numleafs, &bsp.dleafs);
CopyVector(map.exported_vertexes, &bsp.numvertexes, &bsp.dvertexes);
CopyVector(map.exported_nodes, &bsp.numnodes, &bsp.dnodes);
CopyVector(map.exported_texinfos, &bsp.numtexinfo, &bsp.texinfo);
CopyVector(map.exported_faces, &bsp.numfaces, &bsp.dfaces);
CopyVector(map.exported_clipnodes, &bsp.numclipnodes, &bsp.dclipnodes);
CopyVector(map.exported_marksurfaces, &bsp.numleaffaces, &bsp.dleaffaces);
CopyVector(map.exported_surfedges, &bsp.numsurfedges, &bsp.dsurfedges);
CopyVector(map.exported_edges, &bsp.numedges, &bsp.dedges);
CopyVector(map.exported_models, &bsp.nummodels, &bsp.dmodels);
CopyVector(map.exported_leafbrushes, &bsp.numleafbrushes, &bsp.dleafbrushes);
CopyVector(map.exported_brushsides, &bsp.numbrushsides, &bsp.dbrushsides);
CopyVector(map.exported_brushes, &bsp.numbrushes, &bsp.dbrushes);
CopyString(map.exported_entities, true, &bspdata.data.mbsp.entdatasize, (void **)&bspdata.data.mbsp.dentdata);
CopyString(map.exported_texdata, false, &bspdata.data.mbsp.texdatasize, (void **)&bspdata.data.mbsp.dtexdata);
CopyString(map.exported_entities, true, &bsp.entdatasize, (void **)&bsp.dentdata);
CopyString(map.exported_texdata, false, &bsp.texdatasize, (void **)&bsp.dtexdata);
if (map.needslmshifts) {
BSPX_AddLump(&bspdata, "LMSHIFT", map.exported_lmshifts.data(), map.exported_lmshifts.size());
@ -430,12 +431,12 @@ static void WriteBSPFile()
}
// FIXME: temp
bspdata.data.mbsp.numareaportals = 1;
bspdata.data.mbsp.dareaportals = new dareaportal_t[bspdata.data.mbsp.numareaportals] { };
bsp.numareaportals = 1;
bsp.dareaportals = new dareaportal_t[bsp.numareaportals] { };
bspdata.data.mbsp.numareas = 2;
bspdata.data.mbsp.dareas = new darea_t[bspdata.data.mbsp.numareas] { };
bspdata.data.mbsp.dareas[1].firstareaportal = 1;
bsp.numareas = 2;
bsp.dareas = new darea_t[bsp.numareas] { };
bsp.dareas[1].firstareaportal = 1;
if (!ConvertBSPFormat(&bspdata, options.target_version)) {
const bspversion_t *highLimitsFormat = nullptr;
@ -488,6 +489,7 @@ UpdateBSPFileEntitiesLump
void UpdateBSPFileEntitiesLump()
{
bspdata_t bspdata;
StripExtension(options.szBSPName);
DefaultExtension(options.szBSPName, ".bsp");
@ -495,8 +497,10 @@ void UpdateBSPFileEntitiesLump()
LoadBSPFile(options.szBSPName, &bspdata);
ConvertBSPFormat(&bspdata, &bspver_generic);
mbsp_t &bsp = std::get<mbsp_t>(bspdata.bsp);
// replace the existing entities lump with map.exported_entities
CopyString(map.exported_entities, true, &bspdata.data.mbsp.entdatasize, (void **)&bspdata.data.mbsp.dentdata);
CopyString(map.exported_entities, true, &bsp.entdatasize, (void **)&bsp.dentdata);
// write the .bsp back to disk
ConvertBSPFormat(&bspdata, bspdata.loadversion);

17
vis/vis.cc
View File

@ -1196,7 +1196,6 @@ char statetmpfile[1024];
int main(int argc, char **argv)
{
bspdata_t bspdata;
mbsp_t *const bsp = &bspdata.data.mbsp;
const bspversion_t *loadversion;
int i;
@ -1274,11 +1273,13 @@ int main(int argc, char **argv)
loadversion = bspdata.version;
ConvertBSPFormat(&bspdata, &bspver_generic);
mbsp_t &bsp = std::get<mbsp_t>(bspdata.bsp);
strcpy(portalfile, argv[i]);
StripExtension(portalfile);
strcat(portalfile, ".prt");
LoadPortals(portalfile, bsp);
LoadPortals(portalfile, &bsp);
strcpy(statefile, sourcefile);
StripExtension(statefile);
@ -1288,7 +1289,7 @@ int main(int argc, char **argv)
StripExtension(statetmpfile);
DefaultExtension(statetmpfile, ".vi0");
if (bsp->loadversion->game->id != GAME_QUAKE_II) {
if (bsp.loadversion->game->id != GAME_QUAKE_II) {
uncompressed = new uint8_t[portalleafs * leafbytes_real] { };
} else {
uncompressed_q2 = new uint8_t[portalleafs * leafbytes] { };
@ -1296,17 +1297,17 @@ int main(int argc, char **argv)
// CalcPassages ();
CalcVis(bsp);
CalcVis(&bsp);
logprint("c_noclip: %i\n", c_noclip);
logprint("c_chains: %lu\n", c_chains);
bsp->visdatasize = vismap_p - bsp->dvisdata;
logprint("visdatasize:%i compressed from %u\n", bsp->visdatasize, originalvismapsize);
bsp.visdatasize = vismap_p - bsp.dvisdata;
logprint("visdatasize:%i compressed from %u\n", bsp.visdatasize, originalvismapsize);
// no ambient sounds for Q2
if (bsp->loadversion->game->id != GAME_QUAKE_II) {
CalcAmbientSounds(bsp);
if (bsp.loadversion->game->id != GAME_QUAKE_II) {
CalcAmbientSounds(&bsp);
}
/* Convert data format back if necessary */