common: convert all tools to instanced bsp data
Transition all tools to access the BSP data via the bspdata struct instead of the shared globals. Remove the compatibility code from bspfile which copied the global values to/from the instanced bspdata struct. Mostly the changes just involved passing along the bspdata struct to the various functions which needed to reference the data. TraceLine and MakeTNodes in light got some extra changes so that we cache the node dplane pointer and remove the need to pass the bspdata struct to every trace operation! Signed-off-by: Kevin Shanahan <kmshanah@disenchant.net>
This commit is contained in:
Kevin Shanahan
parent
d0617760f5
commit
89abf25218
|
|
@ -288,7 +288,7 @@ main(int argc, char **argv)
|
|||
Error("couldn't open %s for writing\n", source);
|
||||
|
||||
err = fwrite(bsp.dentdata, sizeof(char), bsp.entdatasize - 1, f);
|
||||
if (err != entdatasize - 1)
|
||||
if (err != bsp.entdatasize - 1)
|
||||
Error("%s", strerror(errno));
|
||||
|
||||
err = fclose(f);
|
||||
|
|
|
|||
146
common/bspfile.c
146
common/bspfile.c
|
|
@ -23,152 +23,6 @@
|
|||
|
||||
/* ========================================================================= */
|
||||
|
||||
int nummodels;
|
||||
dmodel_t *dmodels;
|
||||
|
||||
int visdatasize;
|
||||
byte *dvisdata;
|
||||
|
||||
int lightdatasize;
|
||||
byte *dlightdata;
|
||||
|
||||
int texdatasize;
|
||||
dtexdata_t dtexdata;
|
||||
|
||||
int entdatasize;
|
||||
char *dentdata;
|
||||
|
||||
int numleafs;
|
||||
bsp29_dleaf_t *dleafs;
|
||||
|
||||
int numplanes;
|
||||
dplane_t *dplanes;
|
||||
|
||||
int numvertexes;
|
||||
dvertex_t *dvertexes;
|
||||
|
||||
int numnodes;
|
||||
bsp29_dnode_t *dnodes;
|
||||
|
||||
int numtexinfo;
|
||||
texinfo_t *texinfo;
|
||||
|
||||
int numfaces;
|
||||
bsp29_dface_t *dfaces;
|
||||
|
||||
int numclipnodes;
|
||||
bsp29_dclipnode_t *dclipnodes;
|
||||
|
||||
int numedges;
|
||||
bsp29_dedge_t *dedges;
|
||||
|
||||
int nummarksurfaces;
|
||||
uint16_t *dmarksurfaces;
|
||||
|
||||
int numsurfedges;
|
||||
int32_t *dsurfedges;
|
||||
|
||||
/* Transitional helper functions */
|
||||
void
|
||||
GetBSPGlobals(bspdata_t *bspdata)
|
||||
{
|
||||
bspdata->nummodels = nummodels;
|
||||
bspdata->dmodels = dmodels;
|
||||
|
||||
bspdata->visdatasize = visdatasize;
|
||||
bspdata->dvisdata = dvisdata;
|
||||
|
||||
bspdata->lightdatasize = lightdatasize;
|
||||
bspdata->dlightdata = dlightdata;
|
||||
|
||||
bspdata->texdatasize = texdatasize;
|
||||
bspdata->dtexdata = dtexdata;
|
||||
|
||||
bspdata->entdatasize = entdatasize;
|
||||
bspdata->dentdata = dentdata;
|
||||
|
||||
bspdata->numleafs = numleafs;
|
||||
bspdata->dleafs = dleafs;
|
||||
|
||||
bspdata->numplanes = numplanes;
|
||||
bspdata->dplanes = dplanes;
|
||||
|
||||
bspdata->numvertexes = numvertexes;
|
||||
bspdata->dvertexes = dvertexes;
|
||||
|
||||
bspdata->numnodes = numnodes;
|
||||
bspdata->dnodes = dnodes;
|
||||
|
||||
bspdata->numtexinfo = numtexinfo;
|
||||
bspdata->texinfo = texinfo;
|
||||
|
||||
bspdata->numfaces = numfaces;
|
||||
bspdata->dfaces = dfaces;
|
||||
|
||||
bspdata->numclipnodes = numclipnodes;
|
||||
bspdata->dclipnodes = dclipnodes;
|
||||
|
||||
bspdata->numedges = numedges;
|
||||
bspdata->dedges = dedges;
|
||||
|
||||
bspdata->nummarksurfaces = nummarksurfaces;
|
||||
bspdata->dmarksurfaces = dmarksurfaces;
|
||||
|
||||
bspdata->numsurfedges = numsurfedges;
|
||||
bspdata->dsurfedges = dsurfedges;
|
||||
}
|
||||
|
||||
void
|
||||
SetBSPGlobals(const bspdata_t *bspdata)
|
||||
{
|
||||
nummodels = bspdata->nummodels;
|
||||
dmodels = bspdata->dmodels;
|
||||
|
||||
visdatasize = bspdata->visdatasize;
|
||||
dvisdata = bspdata->dvisdata;
|
||||
|
||||
lightdatasize = bspdata->lightdatasize;
|
||||
dlightdata = bspdata->dlightdata;
|
||||
|
||||
texdatasize = bspdata->texdatasize;
|
||||
dtexdata = bspdata->dtexdata;
|
||||
|
||||
entdatasize = bspdata->entdatasize;
|
||||
dentdata = bspdata->dentdata;
|
||||
|
||||
numleafs = bspdata->numleafs;
|
||||
dleafs = bspdata->dleafs;
|
||||
|
||||
numplanes = bspdata->numplanes;
|
||||
dplanes = bspdata->dplanes;
|
||||
|
||||
numvertexes = bspdata->numvertexes;
|
||||
dvertexes = bspdata->dvertexes;
|
||||
|
||||
numnodes = bspdata->numnodes;
|
||||
dnodes = bspdata->dnodes;
|
||||
|
||||
numtexinfo = bspdata->numtexinfo;
|
||||
texinfo = bspdata->texinfo;
|
||||
|
||||
numfaces = bspdata->numfaces;
|
||||
dfaces = bspdata->dfaces;
|
||||
|
||||
numclipnodes = bspdata->numclipnodes;
|
||||
dclipnodes = bspdata->dclipnodes;
|
||||
|
||||
numedges = bspdata->numedges;
|
||||
dedges = bspdata->dedges;
|
||||
|
||||
nummarksurfaces = bspdata->nummarksurfaces;
|
||||
dmarksurfaces = bspdata->dmarksurfaces;
|
||||
|
||||
numsurfedges = bspdata->numsurfedges;
|
||||
dsurfedges = bspdata->dsurfedges;
|
||||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
|
||||
typedef enum { TO_DISK, TO_CPU } swaptype_t;
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -246,59 +246,13 @@ typedef struct {
|
|||
uint8_t ambient_level[NUM_AMBIENTS];
|
||||
} bsp2_dleaf_t;
|
||||
|
||||
/* ========================================================================= */
|
||||
|
||||
extern int nummodels;
|
||||
extern dmodel_t *dmodels;
|
||||
|
||||
extern int visdatasize;
|
||||
extern byte *dvisdata;
|
||||
|
||||
extern int lightdatasize;
|
||||
extern byte *dlightdata;
|
||||
|
||||
typedef union {
|
||||
byte *base;
|
||||
dmiptexlump_t *header;
|
||||
} dtexdata_t;
|
||||
|
||||
extern int texdatasize;
|
||||
extern dtexdata_t dtexdata;
|
||||
/* ========================================================================= */
|
||||
|
||||
extern int entdatasize;
|
||||
extern char *dentdata;
|
||||
|
||||
extern int numleafs;
|
||||
extern bsp29_dleaf_t *dleafs;
|
||||
|
||||
extern int numplanes;
|
||||
extern dplane_t *dplanes;
|
||||
|
||||
extern int numvertexes;
|
||||
extern dvertex_t *dvertexes;
|
||||
|
||||
extern int numnodes;
|
||||
extern bsp29_dnode_t *dnodes;
|
||||
|
||||
extern int numtexinfo;
|
||||
extern texinfo_t *texinfo;
|
||||
|
||||
extern int numfaces;
|
||||
extern bsp29_dface_t *dfaces;
|
||||
|
||||
extern int numclipnodes;
|
||||
extern bsp29_dclipnode_t *dclipnodes;
|
||||
|
||||
extern int numedges;
|
||||
extern bsp29_dedge_t *dedges;
|
||||
|
||||
extern int nummarksurfaces;
|
||||
extern unsigned short *dmarksurfaces;
|
||||
|
||||
extern int numsurfedges;
|
||||
extern int *dsurfedges;
|
||||
|
||||
/* TODO - Transition utils over to using an instanced struct for bsp data */
|
||||
typedef struct {
|
||||
int nummodels;
|
||||
dmodel_t *dmodels;
|
||||
|
|
@ -346,10 +300,6 @@ typedef struct {
|
|||
int32_t *dsurfedges;
|
||||
} bspdata_t;
|
||||
|
||||
/* Transitional helper functions */
|
||||
void GetBSPGlobals(bspdata_t *bspdata);
|
||||
void SetBSPGlobals(const bspdata_t *bspdata);
|
||||
|
||||
/* LoadBSPFile returns the BSP version... */
|
||||
int LoadBSPFile(const char *filename, bspdata_t *bsp);
|
||||
void WriteBSPFile(const char *filename, bspdata_t *bsp, int version);
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ entity_t *FindEntityWithKeyPair(const char *key, const char *value);
|
|||
const char *ValueForKey(const entity_t *ent, const char *key);
|
||||
void GetVectorForKey(const entity_t *ent, const char *key, vec3_t vec);
|
||||
|
||||
void LoadEntities(void);
|
||||
void WriteEntitiesToString(void);
|
||||
void LoadEntities(const bspdata_t *bsp);
|
||||
void WriteEntitiesToString(bspdata_t *bsp);
|
||||
|
||||
#endif /* __LIGHT_ENTITIES_H__ */
|
||||
|
|
|
|||
|
|
@ -87,8 +87,9 @@ typedef struct {
|
|||
/* tracelist is a null terminated array of BSP models to use for LOS tests */
|
||||
extern const dmodel_t *const *tracelist;
|
||||
|
||||
void LightFace(bsp29_dface_t *face, const modelinfo_t *modelinfo);
|
||||
void MakeTnodes(void);
|
||||
void LightFace(bsp29_dface_t *face, const modelinfo_t *modelinfo,
|
||||
const bspdata_t *bsp);
|
||||
void MakeTnodes(const bspdata_t *bsp);
|
||||
|
||||
extern float scaledist;
|
||||
extern float rangescale;
|
||||
|
|
|
|||
|
|
@ -136,12 +136,11 @@ extern char portalfile[1024];
|
|||
extern char statefile[1024];
|
||||
extern char statetmpfile[1024];
|
||||
|
||||
void LeafFlow(int leafnum);
|
||||
void BasePortalVis(void);
|
||||
|
||||
void PortalFlow(portal_t *p);
|
||||
|
||||
void CalcAmbientSounds(void);
|
||||
void CalcAmbientSounds(bspdata_t *bsp);
|
||||
|
||||
extern double starttime, endtime, statetime;
|
||||
|
||||
|
|
|
|||
|
|
@ -282,7 +282,7 @@ CountEntities(const char *entitystring)
|
|||
* ==================
|
||||
*/
|
||||
void
|
||||
LoadEntities(void)
|
||||
LoadEntities(const bspdata_t *bsp)
|
||||
{
|
||||
char *data;
|
||||
entity_t *entity;
|
||||
|
|
@ -292,7 +292,7 @@ LoadEntities(void)
|
|||
int memsize, num_lights;
|
||||
|
||||
/* Count the entities and allocate memory */
|
||||
max_entities = CountEntities(dentdata);
|
||||
max_entities = CountEntities(bsp->dentdata);
|
||||
memsize = max_entities * sizeof(*entities);
|
||||
entities = malloc(memsize);
|
||||
if (!entities)
|
||||
|
|
@ -302,7 +302,7 @@ LoadEntities(void)
|
|||
/* start parsing */
|
||||
num_entities = 0;
|
||||
num_lights = 0;
|
||||
data = dentdata;
|
||||
data = bsp->dentdata;
|
||||
|
||||
/* go through all the entities */
|
||||
while (1) {
|
||||
|
|
@ -508,7 +508,7 @@ Get_EntityStringSize(const entity_t *entities, int num_entities)
|
|||
* ================
|
||||
*/
|
||||
void
|
||||
WriteEntitiesToString(void)
|
||||
WriteEntitiesToString(bspdata_t *bsp)
|
||||
{
|
||||
const entity_t *entity;
|
||||
const epair_t *epair;
|
||||
|
|
@ -516,19 +516,20 @@ WriteEntitiesToString(void)
|
|||
char *pos;
|
||||
int i;
|
||||
|
||||
if (dentdata)
|
||||
free(dentdata);
|
||||
if (bsp->dentdata)
|
||||
free(bsp->dentdata);
|
||||
|
||||
/* FIXME - why are we printing this here? */
|
||||
logprint("%i switchable light styles\n", numlighttargets);
|
||||
|
||||
entdatasize = Get_EntityStringSize(entities, num_entities);
|
||||
dentdata = malloc(entdatasize);
|
||||
if (!dentdata)
|
||||
Error("%s: allocation of %d bytes failed\n", __func__, entdatasize);
|
||||
bsp->entdatasize = Get_EntityStringSize(entities, num_entities);
|
||||
bsp->dentdata = malloc(bsp->entdatasize);
|
||||
if (!bsp->dentdata)
|
||||
Error("%s: allocation of %d bytes failed\n", __func__,
|
||||
bsp->entdatasize);
|
||||
|
||||
space = entdatasize;
|
||||
pos = dentdata;
|
||||
space = bsp->entdatasize;
|
||||
pos = bsp->dentdata;
|
||||
for (i = 0, entity = entities; i < num_entities; i++, entity++) {
|
||||
if (!entity->epairs)
|
||||
continue;
|
||||
|
|
|
|||
|
|
@ -77,10 +77,11 @@ GetFileSpace(byte **lightdata, byte **colordata, int size)
|
|||
}
|
||||
|
||||
static void *
|
||||
LightThread(void *junk)
|
||||
LightThread(void *arg)
|
||||
{
|
||||
int facenum, i;
|
||||
dmodel_t *model;
|
||||
const bspdata_t *bsp = arg;
|
||||
|
||||
while (1) {
|
||||
facenum = GetThreadWork();
|
||||
|
|
@ -88,25 +89,25 @@ LightThread(void *junk)
|
|||
break;
|
||||
|
||||
/* Find the correct model offset */
|
||||
for (i = 0, model = dmodels; i < nummodels; i++, model++) {
|
||||
for (i = 0, model = bsp->dmodels; i < bsp->nummodels; i++, model++) {
|
||||
if (facenum < model->firstface)
|
||||
continue;
|
||||
if (facenum < model->firstface + model->numfaces)
|
||||
break;
|
||||
}
|
||||
if (i == nummodels) {
|
||||
if (i == bsp->nummodels) {
|
||||
logprint("warning: no model has face %d\n", facenum);
|
||||
continue;
|
||||
}
|
||||
|
||||
LightFace(dfaces + facenum, &modelinfo[i]);
|
||||
LightFace(bsp->dfaces + facenum, &modelinfo[i], bsp);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
FindModelInfo(void)
|
||||
FindModelInfo(const bspdata_t *bsp)
|
||||
{
|
||||
int i, shadow, numshadowmodels;
|
||||
entity_t *entity;
|
||||
|
|
@ -115,18 +116,18 @@ FindModelInfo(void)
|
|||
const dmodel_t **shadowmodels;
|
||||
modelinfo_t *info;
|
||||
|
||||
shadowmodels = malloc(sizeof(dmodel_t *) * (nummodels + 1));
|
||||
memset(shadowmodels, 0, sizeof(dmodel_t *) * (nummodels + 1));
|
||||
shadowmodels = malloc(sizeof(dmodel_t *) * (bsp->nummodels + 1));
|
||||
memset(shadowmodels, 0, sizeof(dmodel_t *) * (bsp->nummodels + 1));
|
||||
|
||||
/* The world always casts shadows */
|
||||
shadowmodels[0] = &dmodels[0];
|
||||
shadowmodels[0] = &bsp->dmodels[0];
|
||||
numshadowmodels = 1;
|
||||
|
||||
memset(modelinfo, 0, sizeof(*modelinfo) * nummodels);
|
||||
modelinfo[0].model = &dmodels[0];
|
||||
memset(modelinfo, 0, sizeof(*modelinfo) * bsp->nummodels);
|
||||
modelinfo[0].model = &bsp->dmodels[0];
|
||||
|
||||
for (i = 1, info = modelinfo + 1; i < nummodels; i++, info++) {
|
||||
info->model = &dmodels[i];
|
||||
for (i = 1, info = modelinfo + 1; i < bsp->nummodels; i++, info++) {
|
||||
info->model = &bsp->dmodels[i];
|
||||
|
||||
/* Find the entity for the model */
|
||||
snprintf(modelname, sizeof(modelname), "*%d", i);
|
||||
|
|
@ -138,7 +139,7 @@ FindModelInfo(void)
|
|||
/* Check if this model will cast shadows (shadow => shadowself) */
|
||||
shadow = atoi(ValueForKey(entity, "_shadow"));
|
||||
if (shadow) {
|
||||
shadowmodels[numshadowmodels++] = &dmodels[i];
|
||||
shadowmodels[numshadowmodels++] = &bsp->dmodels[i];
|
||||
} else {
|
||||
shadow = atoi(ValueForKey(entity, "_shadowself"));
|
||||
if (shadow)
|
||||
|
|
@ -172,33 +173,34 @@ FindModelInfo(void)
|
|||
* =============
|
||||
*/
|
||||
static void
|
||||
LightWorld(void)
|
||||
LightWorld(bspdata_t *bsp)
|
||||
{
|
||||
if (dlightdata)
|
||||
free(dlightdata);
|
||||
if (bsp->dlightdata)
|
||||
free(bsp->dlightdata);
|
||||
|
||||
/* FIXME - remove this limit */
|
||||
lightdatasize = MAX_MAP_LIGHTING;
|
||||
dlightdata = malloc(lightdatasize + 16); /* for alignment */
|
||||
if (!dlightdata)
|
||||
Error("%s: allocation of %i bytes failed.", __func__, lightdatasize);
|
||||
memset(dlightdata, 0, lightdatasize + 16);
|
||||
lightdatasize /= 4;
|
||||
bsp->lightdatasize = MAX_MAP_LIGHTING;
|
||||
bsp->dlightdata = malloc(bsp->lightdatasize + 16); /* for alignment */
|
||||
if (!bsp->dlightdata)
|
||||
Error("%s: allocation of %i bytes failed.",
|
||||
__func__, bsp->lightdatasize);
|
||||
memset(bsp->dlightdata, 0, bsp->lightdatasize + 16);
|
||||
bsp->lightdatasize /= 4;
|
||||
|
||||
/* align filebase to a 4 byte boundary */
|
||||
filebase = file_p = (byte *)(((uintptr_t)dlightdata + 3) & ~3);
|
||||
file_end = filebase + lightdatasize;
|
||||
filebase = file_p = (byte *)(((uintptr_t)bsp->dlightdata + 3) & ~3);
|
||||
file_end = filebase + bsp->lightdatasize;
|
||||
|
||||
/* litfile data stored in dlightdata, after the white light */
|
||||
lit_filebase = file_end + 12 - ((uintptr_t)file_end % 12);
|
||||
lit_file_p = lit_filebase;
|
||||
lit_file_end = lit_filebase + 3 * (MAX_MAP_LIGHTING / 4);
|
||||
|
||||
RunThreadsOn(0, numfaces, LightThread, NULL);
|
||||
RunThreadsOn(0, bsp->numfaces, LightThread, bsp);
|
||||
logprint("Lighting Completed.\n\n");
|
||||
|
||||
lightdatasize = file_p - filebase;
|
||||
logprint("lightdatasize: %i\n", lightdatasize);
|
||||
bsp->lightdatasize = file_p - filebase;
|
||||
logprint("lightdatasize: %i\n", bsp->lightdatasize);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -291,22 +293,19 @@ main(int argc, const char **argv)
|
|||
StripExtension(source);
|
||||
DefaultExtension(source, ".bsp");
|
||||
bsp_version = LoadBSPFile(source, &bsp);
|
||||
SetBSPGlobals(&bsp); /* FIXME */
|
||||
|
||||
LoadEntities();
|
||||
MakeTnodes();
|
||||
modelinfo = malloc(nummodels * sizeof(*modelinfo));
|
||||
FindModelInfo();
|
||||
LightWorld();
|
||||
LoadEntities(&bsp);
|
||||
MakeTnodes(&bsp);
|
||||
modelinfo = malloc(bsp.nummodels * sizeof(*modelinfo));
|
||||
FindModelInfo(&bsp);
|
||||
LightWorld(&bsp);
|
||||
free(modelinfo);
|
||||
|
||||
WriteEntitiesToString();
|
||||
WriteEntitiesToString(&bsp);
|
||||
|
||||
if (write_litfile)
|
||||
WriteLitFile(&bsp, source, LIT_VERSION);
|
||||
|
||||
/* Still need to update from globals */
|
||||
GetBSPGlobals(&bsp);
|
||||
WriteBSPFile(source, &bsp, bsp_version);
|
||||
|
||||
end = I_FloatTime();
|
||||
|
|
|
|||
119
light/ltface.c
119
light/ltface.c
|
|
@ -194,26 +194,26 @@ TriArea(const dvertex_t *v0, const dvertex_t *v1, const dvertex_t *v2)
|
|||
}
|
||||
|
||||
static vec_t
|
||||
FaceArea(const bsp29_dface_t *f)
|
||||
FaceArea(const bsp29_dface_t *face, const bspdata_t *bsp)
|
||||
{
|
||||
int i, e;
|
||||
int i, edgenum;
|
||||
dvertex_t *v0, *v1, *v2;
|
||||
vec_t poly_area = 0;
|
||||
|
||||
e = dsurfedges[f->firstedge];
|
||||
if (e >= 0)
|
||||
v0 = dvertexes + dedges[e].v[0];
|
||||
edgenum = bsp->dsurfedges[face->firstedge];
|
||||
if (edgenum >= 0)
|
||||
v0 = bsp->dvertexes + bsp->dedges[edgenum].v[0];
|
||||
else
|
||||
v0 = dvertexes + dedges[-e].v[1];
|
||||
v0 = bsp->dvertexes + bsp->dedges[-edgenum].v[1];
|
||||
|
||||
for (i = 1; i < f->numedges - 1; i++) {
|
||||
e = dsurfedges[f->firstedge + i];
|
||||
if (e >= 0) {
|
||||
v1 = dvertexes + dedges[e].v[0];
|
||||
v2 = dvertexes + dedges[e].v[1];
|
||||
for (i = 1; i < face->numedges - 1; i++) {
|
||||
edgenum = bsp->dsurfedges[face->firstedge + i];
|
||||
if (edgenum >= 0) {
|
||||
v1 = bsp->dvertexes + bsp->dedges[edgenum].v[0];
|
||||
v2 = bsp->dvertexes + bsp->dedges[edgenum].v[1];
|
||||
} else {
|
||||
v1 = dvertexes + dedges[-e].v[1];
|
||||
v2 = dvertexes + dedges[-e].v[0];
|
||||
v1 = bsp->dvertexes + bsp->dedges[-edgenum].v[1];
|
||||
v2 = bsp->dvertexes + bsp->dedges[-edgenum].v[0];
|
||||
}
|
||||
poly_area += TriArea(v0, v1, v2);
|
||||
}
|
||||
|
|
@ -222,9 +222,9 @@ FaceArea(const bsp29_dface_t *f)
|
|||
}
|
||||
|
||||
static void
|
||||
FaceCentroid(const bsp29_dface_t *f, vec3_t out)
|
||||
FaceCentroid(const bsp29_dface_t *face, const bspdata_t *bsp, vec3_t out)
|
||||
{
|
||||
int i, e;
|
||||
int i, edgenum;
|
||||
dvertex_t *v0, *v1, *v2;
|
||||
vec3_t centroid, poly_centroid;
|
||||
vec_t area, poly_area;
|
||||
|
|
@ -232,20 +232,20 @@ FaceCentroid(const bsp29_dface_t *f, vec3_t out)
|
|||
VectorCopy(vec3_origin, poly_centroid);
|
||||
poly_area = 0;
|
||||
|
||||
e = dsurfedges[f->firstedge];
|
||||
if (e >= 0)
|
||||
v0 = dvertexes + dedges[e].v[0];
|
||||
edgenum = bsp->dsurfedges[face->firstedge];
|
||||
if (edgenum >= 0)
|
||||
v0 = bsp->dvertexes + bsp->dedges[edgenum].v[0];
|
||||
else
|
||||
v0 = dvertexes + dedges[-e].v[1];
|
||||
v0 = bsp->dvertexes + bsp->dedges[-edgenum].v[1];
|
||||
|
||||
for (i = 1; i < f->numedges - 1; i++) {
|
||||
e = dsurfedges[f->firstedge + i];
|
||||
if (e >= 0) {
|
||||
v1 = dvertexes + dedges[e].v[0];
|
||||
v2 = dvertexes + dedges[e].v[1];
|
||||
for (i = 1; i < face->numedges - 1; i++) {
|
||||
edgenum = bsp->dsurfedges[face->firstedge + i];
|
||||
if (edgenum >= 0) {
|
||||
v1 = bsp->dvertexes + bsp->dedges[edgenum].v[0];
|
||||
v2 = bsp->dvertexes + bsp->dedges[edgenum].v[1];
|
||||
} else {
|
||||
v1 = dvertexes + dedges[-e].v[1];
|
||||
v2 = dvertexes + dedges[-e].v[0];
|
||||
v1 = bsp->dvertexes + bsp->dedges[-edgenum].v[1];
|
||||
v2 = bsp->dvertexes + bsp->dedges[-edgenum].v[0];
|
||||
}
|
||||
|
||||
area = TriArea(v0, v1, v2);
|
||||
|
|
@ -265,15 +265,16 @@ FaceCentroid(const bsp29_dface_t *f, vec3_t out)
|
|||
* ================
|
||||
*/
|
||||
static void
|
||||
CreateFaceTransform(const bsp29_dface_t *face, pmatrix3_t *transform)
|
||||
CreateFaceTransform(const bsp29_dface_t *face, const bspdata_t *bsp,
|
||||
pmatrix3_t *transform)
|
||||
{
|
||||
const dplane_t *plane;
|
||||
const texinfo_t *tex;
|
||||
int i;
|
||||
|
||||
/* Prepare the transform matrix and init row/column permutations */
|
||||
plane = &dplanes[face->planenum];
|
||||
tex = &texinfo[face->texinfo];
|
||||
plane = &bsp->dplanes[face->planenum];
|
||||
tex = &bsp->texinfo[face->texinfo];
|
||||
for (i = 0; i < 3; i++) {
|
||||
transform->data[0][i] = tex->vecs[0][i];
|
||||
transform->data[1][i] = tex->vecs[1][i];
|
||||
|
|
@ -285,10 +286,10 @@ CreateFaceTransform(const bsp29_dface_t *face, pmatrix3_t *transform)
|
|||
|
||||
/* Decompose the matrix. If we can't, texture axes are invalid. */
|
||||
if (!PMatrix3_LU_Decompose(transform)) {
|
||||
const vec_t *p = dvertexes[dedges[face->firstedge].v[0]].point;
|
||||
const vec_t *p = bsp->dvertexes[bsp->dedges[face->firstedge].v[0]].point;
|
||||
Error("Bad texture axes on face:\n"
|
||||
" face point at (%s)\n"
|
||||
" face area = %5.3f\n", VecStr(p), FaceArea(face));
|
||||
" face area = %5.3f\n", VecStr(p), FaceArea(face, bsp));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -319,24 +320,24 @@ WorldToTexCoord(const vec3_t world, const texinfo_t *tex, vec_t coord[2])
|
|||
#if 0
|
||||
/* Debug helper - move elsewhere? */
|
||||
static void
|
||||
PrintFaceInfo(const bsp29_dface_t *face)
|
||||
PrintFaceInfo(const bsp29_dface_t *face, const bspdata_t *bsp)
|
||||
{
|
||||
const texinfo_t *tex = &texinfo[face->texinfo];
|
||||
const int offset = dtexdata.header->dataofs[tex->miptex];
|
||||
const miptex_t *miptex = (const miptex_t *)(dtexdata.base + offset);
|
||||
const texinfo_t *tex = &bsp->texinfo[face->texinfo];
|
||||
const int offset = bsp->dtexdata.header->dataofs[tex->miptex];
|
||||
const miptex_t *miptex = (const miptex_t *)(bsp->dtexdata.base + offset);
|
||||
int i;
|
||||
|
||||
logprint("face %d, texture %s, %d edges...\n"
|
||||
" vectors (%3.3f, %3.3f, %3.3f) (%3.3f)\n"
|
||||
" (%3.3f, %3.3f, %3.3f) (%3.3f)\n",
|
||||
(int)(face - dfaces), miptex->name, face->numedges,
|
||||
(int)(face - bsp->dfaces), miptex->name, face->numedges,
|
||||
tex->vecs[0][0], tex->vecs[0][1], tex->vecs[0][2], tex->vecs[0][3],
|
||||
tex->vecs[1][0], tex->vecs[1][1], tex->vecs[1][2], tex->vecs[1][3]);
|
||||
|
||||
for (i = 0; i < face->numedges; i++) {
|
||||
int edge = dsurfedges[face->firstedge + i];
|
||||
int vert = (edge >= 0) ? dedges[edge].v[0] : dedges[-edge].v[1];
|
||||
const float *point = dvertexes[vert].point;
|
||||
int edge = bsp->dsurfedges[face->firstedge + i];
|
||||
int vert = (edge >= 0) ? bsp->dedges[edge].v[0] : bsp->dedges[-edge].v[1];
|
||||
const float *point = bsp->dvertexes[vert].point;
|
||||
|
||||
logprint("%s %3d (%3.3f, %3.3f, %3.3f) :: edge %d\n",
|
||||
i ? " " : " verts ", vert,
|
||||
|
|
@ -353,7 +354,8 @@ PrintFaceInfo(const bsp29_dface_t *face)
|
|||
*/
|
||||
__attribute__((noinline))
|
||||
static void
|
||||
CalcFaceExtents(const bsp29_dface_t *face, const vec3_t offset, lightsurf_t *surf)
|
||||
CalcFaceExtents(const bsp29_dface_t *face, const vec3_t offset,
|
||||
const bspdata_t *bsp, lightsurf_t *surf)
|
||||
{
|
||||
vec_t mins[2], maxs[2], texcoord[2];
|
||||
vec3_t worldpoint;
|
||||
|
|
@ -363,12 +365,12 @@ CalcFaceExtents(const bsp29_dface_t *face, const vec3_t offset, lightsurf_t *sur
|
|||
|
||||
mins[0] = mins[1] = VECT_MAX;
|
||||
maxs[0] = maxs[1] = -VECT_MAX;
|
||||
tex = &texinfo[face->texinfo];
|
||||
tex = &bsp->texinfo[face->texinfo];
|
||||
|
||||
for (i = 0; i < face->numedges; i++) {
|
||||
edge = dsurfedges[face->firstedge + i];
|
||||
vert = (edge >= 0) ? dedges[edge].v[0] : dedges[-edge].v[1];
|
||||
dvertex = &dvertexes[vert];
|
||||
edge = bsp->dsurfedges[face->firstedge + i];
|
||||
vert = (edge >= 0) ? bsp->dedges[edge].v[0] : bsp->dedges[-edge].v[1];
|
||||
dvertex = &bsp->dvertexes[vert];
|
||||
|
||||
VectorAdd(dvertex->point, offset, worldpoint);
|
||||
WorldToTexCoord(worldpoint, tex, texcoord);
|
||||
|
|
@ -380,7 +382,7 @@ CalcFaceExtents(const bsp29_dface_t *face, const vec3_t offset, lightsurf_t *sur
|
|||
}
|
||||
}
|
||||
|
||||
FaceCentroid(face, worldpoint);
|
||||
FaceCentroid(face, bsp, worldpoint);
|
||||
VectorAdd(worldpoint, offset, worldpoint);
|
||||
WorldToTexCoord(worldpoint, tex, surf->exactmid);
|
||||
|
||||
|
|
@ -390,14 +392,14 @@ CalcFaceExtents(const bsp29_dface_t *face, const vec3_t offset, lightsurf_t *sur
|
|||
surf->texmins[i] = mins[i];
|
||||
surf->texsize[i] = maxs[i] - mins[i];
|
||||
if (surf->texsize[i] > 17) {
|
||||
const dplane_t *plane = dplanes + face->planenum;
|
||||
const int offset = dtexdata.header->dataofs[tex->miptex];
|
||||
const miptex_t *miptex = (const miptex_t *)(dtexdata.base + offset);
|
||||
const dplane_t *plane = bsp->dplanes + face->planenum;
|
||||
const int offset = bsp->dtexdata.header->dataofs[tex->miptex];
|
||||
const miptex_t *miptex = (const miptex_t *)(bsp->dtexdata.base + offset);
|
||||
Error("Bad surface extents:\n"
|
||||
" surface %d, %s extents = %d\n"
|
||||
" texture %s at (%s)\n"
|
||||
" surface normal (%s)\n",
|
||||
(int)(face - dfaces), i ? "t" : "s", surf->texsize[i],
|
||||
(int)(face - bsp->dfaces), i ? "t" : "s", surf->texsize[i],
|
||||
miptex->name, VecStr(worldpoint), VecStrf(plane->normal));
|
||||
}
|
||||
}
|
||||
|
|
@ -491,7 +493,7 @@ CalcPoints(const dmodel_t *model, const texorg_t *texorg, lightsurf_t *surf)
|
|||
__attribute__((noinline))
|
||||
static void
|
||||
Lightsurf_Init(const modelinfo_t *modelinfo, const bsp29_dface_t *face,
|
||||
lightsurf_t *lightsurf)
|
||||
const bspdata_t *bsp, lightsurf_t *lightsurf)
|
||||
{
|
||||
plane_t *plane;
|
||||
vec3_t planepoint;
|
||||
|
|
@ -502,8 +504,8 @@ Lightsurf_Init(const modelinfo_t *modelinfo, const bsp29_dface_t *face,
|
|||
|
||||
/* Set up the plane, including model offset */
|
||||
plane = &lightsurf->plane;
|
||||
VectorCopy(dplanes[face->planenum].normal, plane->normal);
|
||||
plane->dist = dplanes[face->planenum].dist;
|
||||
VectorCopy(bsp->dplanes[face->planenum].normal, plane->normal);
|
||||
plane->dist = bsp->dplanes[face->planenum].dist;
|
||||
VectorScale(plane->normal, plane->dist, planepoint);
|
||||
VectorAdd(planepoint, modelinfo->offset, planepoint);
|
||||
plane->dist = DotProduct(plane->normal, planepoint);
|
||||
|
|
@ -513,12 +515,12 @@ Lightsurf_Init(const modelinfo_t *modelinfo, const bsp29_dface_t *face,
|
|||
}
|
||||
|
||||
/* Set up the texorg for coordinate transformation */
|
||||
CreateFaceTransform(face, &texorg.transform);
|
||||
texorg.texinfo = &texinfo[face->texinfo];
|
||||
CreateFaceTransform(face, bsp, &texorg.transform);
|
||||
texorg.texinfo = &bsp->texinfo[face->texinfo];
|
||||
texorg.planedist = plane->dist;
|
||||
|
||||
/* Set up the surface points */
|
||||
CalcFaceExtents(face, modelinfo->offset, lightsurf);
|
||||
CalcFaceExtents(face, modelinfo->offset, bsp, lightsurf);
|
||||
CalcPoints(modelinfo->model, &texorg, lightsurf);
|
||||
}
|
||||
|
||||
|
|
@ -953,7 +955,8 @@ WriteLightmaps(bsp29_dface_t *face, const lightsurf_t *lightsurf,
|
|||
* ============
|
||||
*/
|
||||
void
|
||||
LightFace(bsp29_dface_t *face, const modelinfo_t *modelinfo)
|
||||
LightFace(bsp29_dface_t *face, const modelinfo_t *modelinfo,
|
||||
const bspdata_t *bsp)
|
||||
{
|
||||
int i, j, k;
|
||||
const entity_t *entity;
|
||||
|
|
@ -967,10 +970,10 @@ LightFace(bsp29_dface_t *face, const modelinfo_t *modelinfo)
|
|||
face->lightofs = -1;
|
||||
for (i = 0; i < MAXLIGHTMAPS; i++)
|
||||
face->styles[i] = 255;
|
||||
if (texinfo[face->texinfo].flags & TEX_SPECIAL)
|
||||
if (bsp->texinfo[face->texinfo].flags & TEX_SPECIAL)
|
||||
return;
|
||||
|
||||
Lightsurf_Init(modelinfo, face, &lightsurf);
|
||||
Lightsurf_Init(modelinfo, face, bsp, &lightsurf);
|
||||
Lightmaps_Init(lightmaps, MAXLIGHTMAPS + 1);
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -20,11 +20,11 @@
|
|||
#include <light/light.h>
|
||||
|
||||
typedef struct tnode_s {
|
||||
int type;
|
||||
vec3_t normal;
|
||||
vec_t dist;
|
||||
int type;
|
||||
int children[2];
|
||||
int pad;
|
||||
const dplane_t *plane;
|
||||
} tnode_t;
|
||||
|
||||
static tnode_t *tnodes;
|
||||
|
|
@ -37,40 +37,39 @@ static tnode_t *tnode_p;
|
|||
* ==============
|
||||
*/
|
||||
static void
|
||||
MakeTnodes_r(int nodenum)
|
||||
MakeTnodes_r(int nodenum, const bspdata_t *bsp)
|
||||
{
|
||||
tnode_t *t;
|
||||
dplane_t *plane;
|
||||
tnode_t *tnode;
|
||||
int i;
|
||||
bsp29_dnode_t *node;
|
||||
|
||||
t = tnode_p++;
|
||||
tnode = tnode_p++;
|
||||
|
||||
node = dnodes + nodenum;
|
||||
plane = dplanes + node->planenum;
|
||||
node = bsp->dnodes + nodenum;
|
||||
tnode->plane = bsp->dplanes + node->planenum;
|
||||
|
||||
t->type = plane->type;
|
||||
VectorCopy(plane->normal, t->normal);
|
||||
t->dist = plane->dist;
|
||||
tnode->type = tnode->plane->type;
|
||||
VectorCopy(tnode->plane->normal, tnode->normal);
|
||||
tnode->dist = tnode->plane->dist;
|
||||
|
||||
for (i = 0; i < 2; i++) {
|
||||
if (node->children[i] < 0) {
|
||||
t->children[i] = dleafs[-node->children[i] - 1].contents;
|
||||
tnode->children[i] = bsp->dleafs[-node->children[i] - 1].contents;
|
||||
} else {
|
||||
t->children[i] = tnode_p - tnodes;
|
||||
MakeTnodes_r(node->children[i]);
|
||||
tnode->children[i] = tnode_p - tnodes;
|
||||
MakeTnodes_r(node->children[i], bsp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
MakeTnodes(void)
|
||||
MakeTnodes(const bspdata_t *bsp)
|
||||
{
|
||||
int i;
|
||||
|
||||
tnode_p = tnodes = malloc(numnodes * sizeof(tnode_t));
|
||||
for (i = 0; i < nummodels; i++)
|
||||
MakeTnodes_r(dmodels[i].headnode[0]);
|
||||
tnode_p = tnodes = malloc(bsp->numnodes * sizeof(tnode_t));
|
||||
for (i = 0; i < bsp->nummodels; i++)
|
||||
MakeTnodes_r(bsp->dmodels[i].headnode[0], bsp);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -86,11 +85,12 @@ typedef struct {
|
|||
vec3_t front;
|
||||
int node;
|
||||
int side;
|
||||
const dplane_t *plane;
|
||||
} tracestack_t;
|
||||
|
||||
/*
|
||||
* ==============
|
||||
* TestLineOrSky
|
||||
* TraceLine
|
||||
* ==============
|
||||
*/
|
||||
#define MAX_TSTACK 128
|
||||
|
|
@ -149,8 +149,7 @@ TraceLine(const dmodel_t *model, const int traceflags,
|
|||
if (!crossnode)
|
||||
return -tracehit;
|
||||
if (hitpoint) {
|
||||
const int planenum = dnodes[crossnode->node].planenum;
|
||||
hitpoint->dplane = dplanes + planenum;
|
||||
hitpoint->dplane = crossnode->plane;
|
||||
hitpoint->side = crossnode->side;
|
||||
VectorCopy(crossnode->back, hitpoint->point);
|
||||
}
|
||||
|
|
@ -204,6 +203,7 @@ TraceLine(const dmodel_t *model, const int traceflags,
|
|||
Error("%s: tstack overflow\n", __func__);
|
||||
tstack->node = node;
|
||||
tstack->side = 0;
|
||||
tstack->plane = tnode->plane;
|
||||
VectorCopy(front, tstack->front);
|
||||
VectorCopy(back, tstack->back);
|
||||
crossnode = tstack++;
|
||||
|
|
@ -224,6 +224,7 @@ TraceLine(const dmodel_t *model, const int traceflags,
|
|||
side = frontdist < 0;
|
||||
tstack->node = node;
|
||||
tstack->side = side;
|
||||
tstack->plane = tnode->plane;
|
||||
VectorCopy(front, tstack->front);
|
||||
VectorCopy(back, tstack->back);
|
||||
crossnode = tstack;
|
||||
|
|
@ -239,6 +240,7 @@ TraceLine(const dmodel_t *model, const int traceflags,
|
|||
side = frontdist < 0;
|
||||
tstack->node = node;
|
||||
tstack->side = side;
|
||||
tstack->plane = tnode->plane;
|
||||
VectorCopy(back, tstack->back);
|
||||
VectorSubtract(back, front, back);
|
||||
VectorMA(front, frontdist / (frontdist - backdist), back, back);
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@
|
|||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#include <vis/vis.h>
|
||||
|
||||
|
|
@ -34,29 +35,30 @@ Find an aproximate distance to the nearest emiter of each class for each leaf.
|
|||
====================
|
||||
*/
|
||||
static void
|
||||
SurfaceBBox(const bsp29_dface_t *s, vec3_t mins, vec3_t maxs)
|
||||
SurfaceBBox(const bspdata_t *bsp, const bsp29_dface_t *surf,
|
||||
vec3_t mins, vec3_t maxs)
|
||||
{
|
||||
int i, j;
|
||||
int e;
|
||||
int vi;
|
||||
const float *v;
|
||||
int edgenum;
|
||||
int vertnum;
|
||||
const float *vert;
|
||||
|
||||
mins[0] = mins[1] = 999999;
|
||||
maxs[0] = maxs[1] = -99999;
|
||||
mins[0] = mins[1] = FLT_MAX;
|
||||
maxs[0] = maxs[1] = -FLT_MAX;
|
||||
|
||||
for (i = 0; i < s->numedges; i++) {
|
||||
e = dsurfedges[s->firstedge + i];
|
||||
if (e >= 0)
|
||||
vi = dedges[e].v[0];
|
||||
for (i = 0; i < surf->numedges; i++) {
|
||||
edgenum = bsp->dsurfedges[surf->firstedge + i];
|
||||
if (edgenum >= 0)
|
||||
vertnum = bsp->dedges[edgenum].v[0];
|
||||
else
|
||||
vi = dedges[-e].v[1];
|
||||
v = dvertexes[vi].point;
|
||||
vertnum = bsp->dedges[-edgenum].v[1];
|
||||
vert = bsp->dvertexes[vertnum].point;
|
||||
|
||||
for (j = 0; j < 3; j++) {
|
||||
if (v[j] < mins[j])
|
||||
mins[j] = v[j];
|
||||
if (v[j] > maxs[j])
|
||||
maxs[j] = v[j];
|
||||
if (vert[j] < mins[j])
|
||||
mins[j] = vert[j];
|
||||
if (vert[j] > maxs[j])
|
||||
maxs[j] = vert[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -68,7 +70,7 @@ SurfaceBBox(const bsp29_dface_t *s, vec3_t mins, vec3_t maxs)
|
|||
====================
|
||||
*/
|
||||
void
|
||||
CalcAmbientSounds(void)
|
||||
CalcAmbientSounds(bspdata_t *bsp)
|
||||
{
|
||||
const bsp29_dface_t *surf;
|
||||
const texinfo_t *info;
|
||||
|
|
@ -84,7 +86,7 @@ CalcAmbientSounds(void)
|
|||
float vol;
|
||||
|
||||
for (i = 0; i < portalleafs_real; i++) {
|
||||
leaf = &dleafs[i + 1];
|
||||
leaf = &bsp->dleafs[i + 1];
|
||||
|
||||
//
|
||||
// clear ambients
|
||||
|
|
@ -101,13 +103,13 @@ CalcAmbientSounds(void)
|
|||
//
|
||||
// check this leaf for sound textures
|
||||
//
|
||||
hit = &dleafs[j + 1];
|
||||
hit = &bsp->dleafs[j + 1];
|
||||
|
||||
for (k = 0; k < hit->nummarksurfaces; k++) {
|
||||
surf = &dfaces[dmarksurfaces[hit->firstmarksurface + k]];
|
||||
info = &texinfo[surf->texinfo];
|
||||
ofs = dtexdata.header->dataofs[info->miptex];
|
||||
miptex = (const miptex_t *)(dtexdata.base + ofs);
|
||||
surf = &bsp->dfaces[bsp->dmarksurfaces[hit->firstmarksurface + k]];
|
||||
info = &bsp->texinfo[surf->texinfo];
|
||||
ofs = bsp->dtexdata.header->dataofs[info->miptex];
|
||||
miptex = (const miptex_t *)(bsp->dtexdata.base + ofs);
|
||||
|
||||
if (!strncasecmp(miptex->name, "sky", 3) && ambientsky)
|
||||
ambient_type = AMBIENT_SKY;
|
||||
|
|
@ -123,7 +125,7 @@ CalcAmbientSounds(void)
|
|||
continue;
|
||||
|
||||
// find distance from source leaf to polygon
|
||||
SurfaceBBox(surf, mins, maxs);
|
||||
SurfaceBBox(bsp, surf, mins, maxs);
|
||||
maxd = 0;
|
||||
for (l = 0; l < 3; l++) {
|
||||
if (mins[l] > leaf->maxs[l])
|
||||
|
|
|
|||
45
vis/vis.c
45
vis/vis.c
|
|
@ -499,7 +499,7 @@ static double stateinterval;
|
|||
==============
|
||||
*/
|
||||
void *
|
||||
LeafThread(void *unused)
|
||||
LeafThread(void *arg)
|
||||
{
|
||||
double now;
|
||||
portal_t *p;
|
||||
|
|
@ -571,8 +571,8 @@ CompressRow(const byte *vis, const int numbytes, byte *out)
|
|||
*/
|
||||
int totalvis;
|
||||
|
||||
void
|
||||
LeafFlow(int leafnum)
|
||||
static void
|
||||
LeafFlow(int leafnum, bsp29_dleaf_t *dleaf)
|
||||
{
|
||||
leaf_t *leaf;
|
||||
byte *outbuffer;
|
||||
|
|
@ -624,7 +624,7 @@ LeafFlow(int leafnum)
|
|||
Error("Vismap expansion overflow");
|
||||
|
||||
/* leaf 0 is a common solid */
|
||||
dleafs[leafnum + 1].visofs = dest - vismap;
|
||||
dleaf->visofs = dest - vismap;
|
||||
|
||||
memcpy(dest, compressed, len);
|
||||
free(compressed);
|
||||
|
|
@ -632,7 +632,7 @@ LeafFlow(int leafnum)
|
|||
|
||||
|
||||
void
|
||||
ClusterFlow(int leafnum, leafbits_t *buffer)
|
||||
ClusterFlow(int leafnum, leafbits_t *buffer, bsp29_dleaf_t *dleaf)
|
||||
{
|
||||
leaf_t *leaf;
|
||||
byte *outbuffer;
|
||||
|
|
@ -688,7 +688,7 @@ ClusterFlow(int leafnum, leafbits_t *buffer)
|
|||
Error("Vismap expansion overflow");
|
||||
|
||||
/* leaf 0 is a common solid */
|
||||
dleafs[leafnum + 1].visofs = dest - vismap;
|
||||
dleaf->visofs = dest - vismap;
|
||||
|
||||
memcpy(dest, compressed, len);
|
||||
free(compressed);
|
||||
|
|
@ -700,7 +700,7 @@ ClusterFlow(int leafnum, leafbits_t *buffer)
|
|||
==================
|
||||
*/
|
||||
void
|
||||
CalcPortalVis(void)
|
||||
CalcPortalVis(const bspdata_t *bsp)
|
||||
{
|
||||
int i, startcount;
|
||||
portal_t *p;
|
||||
|
|
@ -739,7 +739,7 @@ CalcPortalVis(void)
|
|||
==================
|
||||
*/
|
||||
void
|
||||
CalcVis(void)
|
||||
CalcVis(const bspdata_t *bsp)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
|
@ -751,14 +751,14 @@ CalcVis(void)
|
|||
}
|
||||
|
||||
logprint("Calculating Full Vis:\n");
|
||||
CalcPortalVis();
|
||||
CalcPortalVis(bsp);
|
||||
|
||||
//
|
||||
// assemble the leaf vis lists by oring and compressing the portal lists
|
||||
//
|
||||
if (portalleafs == portalleafs_real) {
|
||||
for (i = 0; i < portalleafs; i++)
|
||||
LeafFlow(i);
|
||||
LeafFlow(i, &bsp->dleafs[i + 1]);
|
||||
} else {
|
||||
leafbits_t *buffer;
|
||||
|
||||
|
|
@ -766,7 +766,7 @@ CalcVis(void)
|
|||
buffer = malloc(LeafbitsSize(portalleafs));
|
||||
for (i = 0; i < portalleafs_real; i++) {
|
||||
memset(buffer, 0, LeafbitsSize(portalleafs));
|
||||
ClusterFlow(i, buffer);
|
||||
ClusterFlow(i, buffer, &bsp->dleafs[i + 1]);
|
||||
}
|
||||
free(buffer);
|
||||
}
|
||||
|
|
@ -1001,7 +1001,7 @@ SetWindingSphere(winding_t *w)
|
|||
============
|
||||
*/
|
||||
void
|
||||
LoadPortals(char *name)
|
||||
LoadPortals(char *name, bspdata_t *bsp)
|
||||
{
|
||||
int i, j, count;
|
||||
portal_t *p;
|
||||
|
|
@ -1064,13 +1064,13 @@ LoadPortals(char *name)
|
|||
originalvismapsize = portalleafs_real * ((portalleafs_real + 7) / 8);
|
||||
|
||||
// FIXME - more intelligent allocation?
|
||||
dvisdata = malloc(MAX_MAP_VISIBILITY);
|
||||
if (!dvisdata)
|
||||
bsp->dvisdata = malloc(MAX_MAP_VISIBILITY);
|
||||
if (!bsp->dvisdata)
|
||||
Error("%s: dvisdata allocation failed (%i bytes)", __func__,
|
||||
MAX_MAP_VISIBILITY);
|
||||
memset(dvisdata, 0, MAX_MAP_VISIBILITY);
|
||||
memset(bsp->dvisdata, 0, MAX_MAP_VISIBILITY);
|
||||
|
||||
vismap = vismap_p = dvisdata;
|
||||
vismap = vismap_p = bsp->dvisdata;
|
||||
vismap_end = vismap + MAX_MAP_VISIBILITY;
|
||||
|
||||
for (i = 0, p = portals; i < numportals; i++) {
|
||||
|
|
@ -1239,13 +1239,12 @@ main(int argc, char **argv)
|
|||
DefaultExtension(sourcefile, ".bsp");
|
||||
|
||||
bsp_version = LoadBSPFile(sourcefile, &bsp);
|
||||
SetBSPGlobals(&bsp); /* FIXME */
|
||||
|
||||
strcpy(portalfile, argv[i]);
|
||||
StripExtension(portalfile);
|
||||
strcat(portalfile, ".prt");
|
||||
|
||||
LoadPortals(portalfile);
|
||||
LoadPortals(portalfile, &bsp);
|
||||
|
||||
strcpy(statefile, sourcefile);
|
||||
StripExtension(statefile);
|
||||
|
|
@ -1260,19 +1259,17 @@ main(int argc, char **argv)
|
|||
|
||||
// CalcPassages ();
|
||||
|
||||
CalcVis();
|
||||
CalcVis(&bsp);
|
||||
|
||||
logprint("c_noclip: %i\n", c_noclip);
|
||||
logprint("c_chains: %lu\n", c_chains);
|
||||
|
||||
visdatasize = vismap_p - dvisdata;
|
||||
bsp.visdatasize = vismap_p - bsp.dvisdata;
|
||||
logprint("visdatasize:%i compressed from %i\n",
|
||||
visdatasize, originalvismapsize);
|
||||
bsp.visdatasize, originalvismapsize);
|
||||
|
||||
CalcAmbientSounds();
|
||||
CalcAmbientSounds(&bsp);
|
||||
|
||||
/* still need to update from globals */
|
||||
GetBSPGlobals(&bsp);
|
||||
WriteBSPFile(sourcefile, &bsp, bsp_version);
|
||||
|
||||
// unlink (portalfile);
|
||||
|
|
|
|||
Loading…
Reference in New Issue