yquake2/yquake2remaster
0
0
Fork 0
mirror of https://github.com/yquake2/yquake2remaster.git synced 2025-02-01 05:30:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

Sync allocation sizes between renders

Browse source
This commit is contained in:
Denis Pauk 2023-10-11 00:19:52 +03:00
parent bd19960ddf
commit 3e7b568ec9
10 changed files with 239 additions and 152 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
src/client/refresh/files/models.c
View file

@ -1423,7 +1423,7 @@ Mod_LoadNodes(const char *name, cplane_t *planes, int numplanes, mleaf_t *leafs,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_NODES) * sizeof(*out));
*nodes = out;
*numnodes = count;
@ -1505,7 +1505,7 @@ Mod_LoadQNodes(const char *name, cplane_t *planes, int numplanes, mleaf_t *leafs
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_NODES) * sizeof(*out));
*nodes = out;
*numnodes = count;
@ -1594,7 +1594,7 @@ extra for skybox
*/
void
Mod_LoadVertexes(const char *name, mvertex_t **vertexes, int *numvertexes,
const byte *mod_base, const lump_t *l, int extra)
const byte *mod_base, const lump_t *l)
{
dvertex_t *in;
mvertex_t *out;
@ -1609,14 +1609,14 @@ Mod_LoadVertexes(const char *name, mvertex_t **vertexes, int *numvertexes,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc((count + extra)*sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_VERTEXES) * sizeof(*out));
/*
* FIXME: Recheck with soft render
* Fix for the problem where the games dumped core
* when changing levels.
*/
memset(out, 0, (count + extra) * sizeof(*out));
memset(out, 0, (count + EXTRA_LUMP_VERTEXES) * sizeof(*out));
*vertexes = out;
*numvertexes = count;
@ -1753,7 +1753,7 @@ extra for skybox in soft render
void
Mod_LoadTexinfo(const char *name, mtexinfo_t **texinfo, int *numtexinfo,
const byte *mod_base, const lump_t *l, findimage_t find_image,
struct image_s *notexture, int extra)
struct image_s *notexture)
{
texinfo_t *in;
mtexinfo_t *out, *step;
@ -1768,7 +1768,7 @@ Mod_LoadTexinfo(const char *name, mtexinfo_t **texinfo, int *numtexinfo,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc((count + extra)*sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_TEXINFO) * sizeof(*out));
*texinfo = out;
*numtexinfo = count;
@ -1832,7 +1832,7 @@ extra is used for skybox, which adds 6 surfaces
*/
static void
Mod_LoadEdges(const char *name, medge_t **edges, int *numedges,
const byte *mod_base, const lump_t *l, int extra)
const byte *mod_base, const lump_t *l)
{
dedge_t *in;
medge_t *out;
@ -1846,7 +1846,7 @@ Mod_LoadEdges(const char *name, medge_t **edges, int *numedges,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc((count + extra) * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_EDGES) * sizeof(*out));
*edges = out;
*numedges = count;
@ -1867,7 +1867,7 @@ extra is used for skybox, which adds 6 surfaces
*/
static void
Mod_LoadQEdges(const char *name, medge_t **edges, int *numedges,
const byte *mod_base, const lump_t *l, int extra)
const byte *mod_base, const lump_t *l)
{
dqedge_t *in;
medge_t *out;
@ -1881,7 +1881,7 @@ Mod_LoadQEdges(const char *name, medge_t **edges, int *numedges,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc((count + extra) * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_EDGES) * sizeof(*out));
*edges = out;
*numedges = count;
@ -1895,15 +1895,15 @@ Mod_LoadQEdges(const char *name, medge_t **edges, int *numedges,
void
Mod_LoadQBSPEdges(const char *name, medge_t **edges, int *numedges,
const byte *mod_base, const lump_t *l, int extra, int ident)
const byte *mod_base, const lump_t *l, int ident)
{
if (ident == IDBSPHEADER)
{
Mod_LoadEdges(name, edges, numedges, mod_base, l, extra);
Mod_LoadEdges(name, edges, numedges, mod_base, l);
}
else
{
Mod_LoadQEdges(name, edges, numedges, mod_base, l, extra);
Mod_LoadQEdges(name, edges, numedges, mod_base, l);
}
}
@ -1914,7 +1914,7 @@ Mod_LoadSurfedges
*/
void
Mod_LoadSurfedges(const char *name, int **surfedges, int *numsurfedges,
const byte *mod_base, const lump_t *l, int extra)
const byte *mod_base, const lump_t *l)
{
int i, count;
int *in, *out;
@ -1928,7 +1928,7 @@ Mod_LoadSurfedges(const char *name, int **surfedges, int *numsurfedges,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc((count + extra)*sizeof(*out)); // extra for skybox
out = Hunk_Alloc((count + EXTRA_LUMP_SURFEDGES) * sizeof(*out)); // extra for skybox
*surfedges = out;
*numsurfedges = count;

60
src/client/refresh/gl1/gl1_model.c
View file

@ -356,7 +356,7 @@ Mod_LoadFaces(model_t *loadmodel, const byte *mod_base, const lump_t *l,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out));
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -482,7 +482,7 @@ Mod_LoadQFaces(model_t *loadmodel, const byte *mod_base, const lump_t *l,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out));
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -634,42 +634,56 @@ Mod_LoadBrushModel(model_t *mod, const void *buffer, int modfilelen)
// calculate the needed hunksize from the lumps
int hunkSize = 0;
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES], sizeof(dvertex_t), sizeof(mvertex_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES],
sizeof(dvertex_t), sizeof(mvertex_t), EXTRA_LUMP_VERTEXES);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dedge_t), sizeof(medge_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dqedge_t), sizeof(medge_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dqedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
}
hunkSize += sizeof(medge_t) + 31; // for count+1 in Mod_LoadEdges()
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES], sizeof(int), sizeof(int), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES],
sizeof(int), sizeof(int), EXTRA_LUMP_SURFEDGES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING],
1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_PLANES],
sizeof(dplane_t), sizeof(cplane_t), 12);
sizeof(dplane_t), sizeof(cplane_t), EXTRA_LUMP_PLANES);
if (header->ident == IDBSPHEADER)
{
hunkSize += calcTexinfoAndFacesSize(mod_base, &header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += calcTexinfoAndFacesSize(mod_base,
&header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
}
else
{
hunkSize += calcTexinfoAndQFacesSize(mod_base, &header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(int), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += calcTexinfoAndQFacesSize(mod_base,
&header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(int), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
}
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY],
1, 1, 0);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dqleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dqnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dqleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dqnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
}
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS], sizeof(dmodel_t), sizeof(model_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS],
sizeof(dmodel_t), sizeof(model_t), 0);
/* Get size of octree on disk, need to recheck real size */
if (Mod_LoadBSPXFindLump(bspx_header, "LIGHTGRID_OCTREE", &lightgridsize, mod_base))
@ -691,18 +705,18 @@ Mod_LoadBrushModel(model_t *mod, const void *buffer, int modfilelen)
/* load into heap */
Mod_LoadVertexes(mod->name, &mod->vertexes, &mod->numvertexes, mod_base,
&header->lumps[LUMP_VERTEXES], 0);
&header->lumps[LUMP_VERTEXES]);
Mod_LoadQBSPEdges(mod->name, &mod->edges, &mod->numedges,
mod_base, &header->lumps[LUMP_EDGES], 1, header->ident);
mod_base, &header->lumps[LUMP_EDGES], header->ident);
Mod_LoadSurfedges(mod->name, &mod->surfedges, &mod->numsurfedges,
mod_base, &header->lumps[LUMP_SURFEDGES], 0);
mod_base, &header->lumps[LUMP_SURFEDGES]);
Mod_LoadLighting(&mod->lightdata, &mod->numlightdata, mod_base,
&header->lumps[LUMP_LIGHTING]);
Mod_LoadPlanes(mod->name, &mod->planes, &mod->numplanes,
mod_base, &header->lumps[LUMP_PLANES]);
Mod_LoadTexinfo(mod->name, &mod->texinfo, &mod->numtexinfo,
mod_base, &header->lumps[LUMP_TEXINFO], (findimage_t)R_FindImage,
r_notexture, 0);
r_notexture);
if (header->ident == IDBSPHEADER)
{
Mod_LoadFaces(mod, mod_base, &header->lumps[LUMP_FACES], bspx_header);

60
src/client/refresh/gl3/gl3_model.c
View file

@ -352,7 +352,7 @@ Mod_LoadFaces(gl3model_t *loadmodel, const byte *mod_base, const lump_t *l,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out));
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -461,7 +461,7 @@ Mod_LoadQFaces(gl3model_t *loadmodel, const byte *mod_base, const lump_t *l,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out));
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -597,42 +597,56 @@ Mod_LoadBrushModel(gl3model_t *mod, const void *buffer, int modfilelen)
// calculate the needed hunksize from the lumps
int hunkSize = 0;
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES], sizeof(dvertex_t), sizeof(mvertex_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES],
sizeof(dvertex_t), sizeof(mvertex_t), EXTRA_LUMP_VERTEXES);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dedge_t), sizeof(medge_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dqedge_t), sizeof(medge_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dqedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
}
hunkSize += sizeof(medge_t) + 31; // for count+1 in Mod_LoadEdges()
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES], sizeof(int), sizeof(int), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES],
sizeof(int), sizeof(int), EXTRA_LUMP_SURFEDGES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING],
1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_PLANES],
sizeof(dplane_t), sizeof(cplane_t), 12);
sizeof(dplane_t), sizeof(cplane_t), EXTRA_LUMP_PLANES);
if (header->ident == IDBSPHEADER)
{
hunkSize += calcTexinfoAndFacesSize(mod_base, &header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += calcTexinfoAndFacesSize(mod_base,
&header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
}
else
{
hunkSize += calcTexinfoAndQFacesSize(mod_base, &header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(int), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += calcTexinfoAndQFacesSize(mod_base,
&header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(int), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
}
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY],
1, 1, 0);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dqleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dqnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dqleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dqnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
}
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS], sizeof(dmodel_t), sizeof(gl3model_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS],
sizeof(dmodel_t), sizeof(gl3model_t), 0);
/* Get size of octree on disk, need to recheck real size */
if (Mod_LoadBSPXFindLump(bspx_header, "LIGHTGRID_OCTREE", &lightgridsize, mod_base))
@ -654,18 +668,18 @@ Mod_LoadBrushModel(gl3model_t *mod, const void *buffer, int modfilelen)
/* load into heap */
Mod_LoadVertexes(mod->name, &mod->vertexes, &mod->numvertexes, mod_base,
&header->lumps[LUMP_VERTEXES], 0);
&header->lumps[LUMP_VERTEXES]);
Mod_LoadQBSPEdges(mod->name, &mod->edges, &mod->numedges,
mod_base, &header->lumps[LUMP_EDGES], 1, header->ident);
mod_base, &header->lumps[LUMP_EDGES], header->ident);
Mod_LoadSurfedges(mod->name, &mod->surfedges, &mod->numsurfedges,
mod_base, &header->lumps[LUMP_SURFEDGES], 0);
mod_base, &header->lumps[LUMP_SURFEDGES]);
Mod_LoadLighting(&mod->lightdata, &mod->numlightdata, mod_base,
&header->lumps[LUMP_LIGHTING]);
Mod_LoadPlanes(mod->name, &mod->planes, &mod->numplanes,
mod_base, &header->lumps[LUMP_PLANES]);
Mod_LoadTexinfo(mod->name, &mod->texinfo, &mod->numtexinfo,
mod_base, &header->lumps[LUMP_TEXINFO], (findimage_t)GL3_FindImage,
gl3_notexture, 0);
gl3_notexture);
if (header->ident == IDBSPHEADER)
{
Mod_LoadFaces(mod, mod_base, &header->lumps[LUMP_FACES], bspx_header);

43
src/client/refresh/gl4/gl4_model.c
View file

@ -274,7 +274,7 @@ Mod_LoadFaces(gl4model_t *loadmodel, byte *mod_base, lump_t *l)
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out));
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -444,19 +444,28 @@ Mod_LoadBrushModel(gl4model_t *mod, void *buffer, int modfilelen)
// calculate the needed hunksize from the lumps
int hunkSize = 0;
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES], sizeof(dvertex_t), sizeof(mvertex_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dedge_t), sizeof(medge_t), 0);
hunkSize += sizeof(medge_t) + 31; // for count+1 in Mod_LoadEdges()
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES], sizeof(int), sizeof(int), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES],
sizeof(dvertex_t), sizeof(mvertex_t), EXTRA_LUMP_VERTEXES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES],
sizeof(int), sizeof(int), EXTRA_LUMP_SURFEDGES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING],
1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_PLANES],
sizeof(dplane_t), sizeof(cplane_t), 12);
hunkSize += calcTexinfoAndFacesSize(mod_base, &header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS], sizeof(dmodel_t), sizeof(gl4model_t), 0);
sizeof(dplane_t), sizeof(cplane_t), EXTRA_LUMP_PLANES);
hunkSize += calcTexinfoAndFacesSize(mod_base,
&header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY],
1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS],
sizeof(dmodel_t), sizeof(gl4model_t), 0);
/* Get size of octree on disk, need to recheck real size */
if (Mod_LoadBSPXFindLump(bspx_header, "LIGHTGRID_OCTREE", &lightgridsize, mod_base))
@ -478,18 +487,18 @@ Mod_LoadBrushModel(gl4model_t *mod, void *buffer, int modfilelen)
/* load into heap */
Mod_LoadVertexes(mod->name, &mod->vertexes, &mod->numvertexes, mod_base,
&header->lumps[LUMP_VERTEXES], 0);
&header->lumps[LUMP_VERTEXES]);
Mod_LoadQBSPEdges(mod->name, &mod->edges, &mod->numedges,
mod_base, &header->lumps[LUMP_EDGES], 1, header->ident);
mod_base, &header->lumps[LUMP_EDGES], header->ident);
Mod_LoadSurfedges(mod->name, &mod->surfedges, &mod->numsurfedges,
mod_base, &header->lumps[LUMP_SURFEDGES], 0);
mod_base, &header->lumps[LUMP_SURFEDGES]);
Mod_LoadLighting(&mod->lightdata, &mod->numlightdata, mod_base,
&header->lumps[LUMP_LIGHTING]);
Mod_LoadPlanes (mod->name, &mod->planes, &mod->numplanes,
mod_base, &header->lumps[LUMP_PLANES]);
Mod_LoadTexinfo (mod->name, &mod->texinfo, &mod->numtexinfo,
mod_base, &header->lumps[LUMP_TEXINFO], (findimage_t)GL4_FindImage,
gl4_notexture, 0);
gl4_notexture);
Mod_LoadFaces(mod, mod_base, &header->lumps[LUMP_FACES]);
Mod_LoadQBSPMarksurfaces(mod->name, &mod->marksurfaces, &mod->nummarksurfaces,
mod->surfaces, mod->numsurfaces, mod_base, &header->lumps[LUMP_LEAFFACES],

8
src/client/refresh/ref_shared.h
View file

@ -340,18 +340,18 @@ extern void Mod_LoadQBSPLeafs(const char *name, mleaf_t **leafs, int *numleafs,
msurface_t **marksurfaces, int nummarksurfaces,
const byte *mod_base, const lump_t *l, int ident);
extern void Mod_LoadQBSPEdges(const char *name, medge_t **edges, int *numedges,
const byte *mod_base, const lump_t *l, int extra, int ident);
const byte *mod_base, const lump_t *l, int ident);
extern void Mod_LoadVertexes(const char *name, mvertex_t **vertexes, int *numvertexes,
const byte *mod_base, const lump_t *l, int extra);
const byte *mod_base, const lump_t *l);
extern void Mod_LoadLighting(byte **lightdata, int *size, const byte *mod_base, const lump_t *l);
extern void Mod_LoadSetSurfaceLighting(byte *lightdata, int size, msurface_t *out, byte *styles, int lightofs);
extern void Mod_CalcSurfaceExtents(int *surfedges, mvertex_t *vertexes, medge_t *edges,
msurface_t *s);
extern void Mod_LoadTexinfo(const char *name, mtexinfo_t **texinfo, int *numtexinfo,
const byte *mod_base, const lump_t *l, findimage_t find_image,
struct image_s *notexture, int extra);
struct image_s *notexture);
extern void Mod_LoadSurfedges(const char *name, int **surfedges, int *numsurfedges,
const byte *mod_base, const lump_t *l, int extra);
const byte *mod_base, const lump_t *l);
extern mleaf_t *Mod_PointInLeaf(const vec3_t p, mnode_t *node);
extern const void *Mod_LoadBSPXFindLump(const bspx_header_t *bspx_header,
const char *lumpname, int *plumpsize, const byte *mod_base);

64
src/client/refresh/soft/sw_model.c
View file

@ -202,7 +202,7 @@ Mod_LoadFaces(model_t *loadmodel, const byte *mod_base, const lump_t *l,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc((count + 6) * sizeof(*out)); // extra for skybox
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out)); // extra for skybox
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -311,7 +311,7 @@ Mod_LoadQFaces(model_t *loadmodel, const byte *mod_base, const lump_t *l,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc((count + 6) * sizeof(*out)); // extra for skybox
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out)); // extra for skybox
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -447,44 +447,58 @@ Mod_LoadBrushModel(model_t *mod, const void *buffer, int modfilelen)
// calculate the needed hunksize from the lumps
int hunkSize = 0;
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES], sizeof(dvertex_t), sizeof(mvertex_t), 8);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES],
sizeof(dvertex_t), sizeof(mvertex_t), EXTRA_LUMP_VERTEXES);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dedge_t), sizeof(medge_t), 13);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dqedge_t), sizeof(medge_t), 13);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dqedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
}
hunkSize += sizeof(medge_t) + 31; // for count+1 in Mod_LoadEdges()
int surfEdgeCount = (header->lumps[LUMP_SURFEDGES].filelen+sizeof(int)-1)/sizeof(int);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES], sizeof(int), sizeof(int), 24);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_TEXINFO], sizeof(texinfo_t), sizeof(mtexinfo_t), 6);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES],
sizeof(int), sizeof(int), EXTRA_LUMP_SURFEDGES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_TEXINFO],
sizeof(texinfo_t), sizeof(mtexinfo_t), EXTRA_LUMP_TEXINFO);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING],
1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_PLANES],
sizeof(dplane_t), sizeof(cplane_t), 12);
sizeof(dplane_t), sizeof(cplane_t), EXTRA_LUMP_PLANES);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_FACES], sizeof(dface_t), sizeof(msurface_t), 6);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_FACES],
sizeof(dface_t), sizeof(msurface_t), EXTRA_LUMP_FACES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_FACES], sizeof(dqface_t), sizeof(msurface_t), 6);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(int), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_FACES],
sizeof(dqface_t), sizeof(msurface_t), EXTRA_LUMP_FACES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(int), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
}
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY],
1, 1, 0);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dqleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dqnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dqleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dqnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
}
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS], sizeof(dmodel_t), sizeof(model_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS],
sizeof(dmodel_t), sizeof(model_t), 0);
hunkSize += 5000000; // and 5MB extra just in case
@ -508,18 +522,18 @@ Mod_LoadBrushModel(model_t *mod, const void *buffer, int modfilelen)
/* load into heap */
Mod_LoadVertexes(mod->name, &mod->vertexes, &mod->numvertexes, mod_base,
&header->lumps[LUMP_VERTEXES], 8);
&header->lumps[LUMP_VERTEXES]);
Mod_LoadQBSPEdges(mod->name, &mod->edges, &mod->numedges,
mod_base, &header->lumps[LUMP_EDGES], 13, header->ident);
mod_base, &header->lumps[LUMP_EDGES], header->ident);
Mod_LoadSurfedges(mod->name, &mod->surfedges, &mod->numsurfedges,
mod_base, &header->lumps[LUMP_SURFEDGES], 24);
mod_base, &header->lumps[LUMP_SURFEDGES]);
Mod_LoadLighting(&mod->lightdata, &mod->numlightdata, mod_base,
&header->lumps[LUMP_LIGHTING]);
Mod_LoadPlanes(mod->name, &mod->planes, &mod->numplanes,
mod_base, &header->lumps[LUMP_PLANES]);
Mod_LoadTexinfo(mod->name, &mod->texinfo, &mod->numtexinfo,
mod_base, &header->lumps[LUMP_TEXINFO], (findimage_t)R_FindImage,
r_notexture_mip, 6);
r_notexture_mip);
if (header->ident == IDBSPHEADER)
{
Mod_LoadFaces(mod, mod_base, &header->lumps[LUMP_FACES], bspx_header);

60
src/client/refresh/vk/vk_model.c
View file

@ -326,7 +326,7 @@ Mod_LoadFaces(model_t *loadmodel, const byte *mod_base, const lump_t *l,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out));
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -452,7 +452,7 @@ Mod_LoadQFaces(model_t *loadmodel, const byte *mod_base, const lump_t *l,
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_FACES) * sizeof(*out));
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
@ -604,42 +604,56 @@ Mod_LoadBrushModel(model_t *mod, const void *buffer, int modfilelen)
// calculate the needed hunksize from the lumps
int hunkSize = 0;
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES], sizeof(dvertex_t), sizeof(mvertex_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VERTEXES],
sizeof(dvertex_t), sizeof(mvertex_t), EXTRA_LUMP_VERTEXES);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dedge_t), sizeof(medge_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dqedge_t), sizeof(medge_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_EDGES],
sizeof(dqedge_t), sizeof(medge_t), EXTRA_LUMP_EDGES);
}
hunkSize += sizeof(medge_t) + 31; // for count+1 in Mod_LoadEdges()
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES], sizeof(int), sizeof(int), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_SURFEDGES],
sizeof(int), sizeof(int), EXTRA_LUMP_SURFEDGES);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LIGHTING],
1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_PLANES],
sizeof(dplane_t), sizeof(cplane_t), 12);
sizeof(dplane_t), sizeof(cplane_t), EXTRA_LUMP_PLANES);
if (header->ident == IDBSPHEADER)
{
hunkSize += calcTexinfoAndFacesSize(mod_base, &header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += calcTexinfoAndFacesSize(mod_base,
&header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(short), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
}
else
{
hunkSize += calcTexinfoAndQFacesSize(mod_base, &header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(int), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
hunkSize += calcTexinfoAndQFacesSize(mod_base,
&header->lumps[LUMP_FACES], &header->lumps[LUMP_TEXINFO]);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFFACES],
sizeof(int), sizeof(msurface_t *), 0); // yes, out is indeed a pointer!
}
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY], 1, 1, 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_VISIBILITY],
1, 1, 0);
if (header->ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dqleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dqnode_t), sizeof(mnode_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_LEAFS],
sizeof(dqleaf_t), sizeof(mleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_NODES],
sizeof(dqnode_t), sizeof(mnode_t), EXTRA_LUMP_NODES);
}
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS], sizeof(dmodel_t), sizeof(model_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header->lumps[LUMP_MODELS],
sizeof(dmodel_t), sizeof(model_t), 0);
/* Get size of octree on disk, need to recheck real size */
if (Mod_LoadBSPXFindLump(bspx_header, "LIGHTGRID_OCTREE", &lightgridsize, mod_base))
@ -661,18 +675,18 @@ Mod_LoadBrushModel(model_t *mod, const void *buffer, int modfilelen)
/* load into heap */
Mod_LoadVertexes(mod->name, &mod->vertexes, &mod->numvertexes, mod_base,
&header->lumps[LUMP_VERTEXES], 0);
&header->lumps[LUMP_VERTEXES]);
Mod_LoadQBSPEdges(mod->name, &mod->edges, &mod->numedges,
mod_base, &header->lumps[LUMP_EDGES], 1, header->ident);
mod_base, &header->lumps[LUMP_EDGES], header->ident);
Mod_LoadSurfedges(mod->name, &mod->surfedges, &mod->numsurfedges,
mod_base, &header->lumps[LUMP_SURFEDGES], 0);
mod_base, &header->lumps[LUMP_SURFEDGES]);
Mod_LoadLighting(&mod->lightdata, &mod->numlightdata, mod_base,
&header->lumps[LUMP_LIGHTING]);
Mod_LoadPlanes(mod->name, &mod->planes, &mod->numplanes,
mod_base, &header->lumps[LUMP_PLANES]);
Mod_LoadTexinfo(mod->name, &mod->texinfo, &mod->numtexinfo,
mod_base, &header->lumps[LUMP_TEXINFO], (findimage_t)Vk_FindImage,
r_notexture, 0);
r_notexture);
if (header->ident == IDBSPHEADER)
{
Mod_LoadFaces(mod, mod_base, &header->lumps[LUMP_FACES], bspx_header);

3
src/common/cmodels.c
View file

@ -25,6 +25,7 @@
*/
#include "header/common.h"
#include "header/cmodel.h"
/*
=================
@ -119,7 +120,7 @@ Mod_LoadPlanes(const char *name, cplane_t **planes, int *numplanes,
Com_Error(ERR_DROP, "%s: Map %s with no planes", __func__, name);
}
out = Hunk_Alloc((count + 12) * sizeof(*out));
out = Hunk_Alloc((count + EXTRA_LUMP_PLANES) * sizeof(*out));
*planes = out;
*numplanes = count;

50
src/common/collision.c
View file

@ -439,7 +439,12 @@ CM_PointLeafnum_r(vec3_t p, int num)
cnode_t *node;
cplane_t *plane;
while (num >= 0 && num < cmod.numnodes)
if (!cmod.numnodes)
{
return 0;
}
while (num >= 0 && num < (cmod.numnodes + EXTRA_LUMP_NODES))
{
node = cmod.map_nodes + num;
plane = node->plane;
@ -835,7 +840,7 @@ CM_TraceToLeaf(int leafnum)
leaf = &cmod.map_leafs[leafnum];
if (!(leaf->contents & trace_contents))
if (!(leaf->contents & trace_contents) || !cmod.numleafbrushes)
{
return;
}
@ -843,7 +848,7 @@ CM_TraceToLeaf(int leafnum)
/* trace line against all brushes in the leaf */
for (k = 0; k < leaf->numleafbrushes; k++)
{
if (leaf->firstleafbrush + k > cmod.numleafbrushes)
if ((leaf->firstleafbrush + k) > (cmod.numleafbrushes + EXTRA_LUMP_LEAFBRUSHES))
{
Com_Error(ERR_FATAL, "%s: broken leaf!\n", __func__);
}
@ -883,7 +888,7 @@ CM_TestInLeaf(int leafnum)
leaf = &cmod.map_leafs[leafnum];
if (!(leaf->contents & trace_contents))
if (!(leaf->contents & trace_contents) || !cmod.numleafbrushes)
{
return;
}
@ -891,6 +896,11 @@ CM_TestInLeaf(int leafnum)
/* trace line against all brushes in the leaf */
for (k = 0; k < leaf->numleafbrushes; k++)
{
if ((leaf->firstleafbrush + k) > (cmod.numleafbrushes + EXTRA_LUMP_LEAFBRUSHES))
{
Com_Error(ERR_FATAL, "%s: broken leaf!\n", __func__);
}
brushnum = cmod.map_leafbrushes[leaf->firstleafbrush + k];
b = &cmod.map_brushes[brushnum];
@ -1316,7 +1326,7 @@ CMod_LoadNodes(const char *name, cnode_t **map_nodes, int *numnodes,
Com_Error(ERR_DROP, "%s: Map %s has no nodes", __func__, name);
}
out = *map_nodes = Hunk_Alloc((count + 6) * sizeof(*out));
out = *map_nodes = Hunk_Alloc((count + EXTRA_LUMP_NODES) * sizeof(*out));
*numnodes = count;
for (i = 0; i < count; i++, out++, in++)
@ -1354,7 +1364,7 @@ CMod_LoadQNodes(const char *name, cnode_t **map_nodes, int *numnodes,
Com_Error(ERR_DROP, "%s: Map %s with no nodes", __func__, name);
}
out = *map_nodes = Hunk_Alloc((count + 6) * sizeof(*out));
out = *map_nodes = Hunk_Alloc((count + EXTRA_LUMP_NODES) * sizeof(*out));
*numnodes = count;
@ -1392,7 +1402,7 @@ CMod_LoadBrushes(const char* name, cbrush_t **map_brushes, int *numbrushes,
Com_Error(ERR_DROP, "%s: Map %s has no brushes", __func__, name);
}
out = *map_brushes = Hunk_Alloc((count + 1) * sizeof(*out));
out = *map_brushes = Hunk_Alloc((count + EXTRA_LUMP_BRUSHES) * sizeof(*out));
*numbrushes = count;
@ -1553,7 +1563,7 @@ CMod_LoadLeafBrushes(const char *name, unsigned int **map_leafbrushes,
Com_Error(ERR_DROP, "%s: Map %s with no planes", __func__, name);
}
out = *map_leafbrushes = Hunk_Alloc((count + 1) * sizeof(*out));
out = *map_leafbrushes = Hunk_Alloc((count + EXTRA_LUMP_LEAFBRUSHES) * sizeof(*out));
*numleafbrushes = count;
for (i = 0; i < count; i++, in++, out++)
@ -1585,7 +1595,7 @@ CMod_LoadQLeafBrushes(const char *name, unsigned int **map_leafbrushes,
Com_Error(ERR_DROP, "%s: Map %s with no planes", __func__, name);
}
out = *map_leafbrushes = Hunk_Alloc((count + 1) * sizeof(*out));
out = *map_leafbrushes = Hunk_Alloc((count + EXTRA_LUMP_LEAFBRUSHES) * sizeof(*out));
*numleafbrushes = count;
for (i = 0; i < count; i++, in++, out++)
@ -1619,7 +1629,7 @@ CMod_LoadBrushSides(const char *name, cbrushside_t **map_brushsides, int *numbru
Com_Error(ERR_DROP, "%s: Map %s with no planes", __func__, name);
}
out = *map_brushsides = Hunk_Alloc((count + 6) * sizeof(*out));
out = *map_brushsides = Hunk_Alloc((count + EXTRA_LUMP_BRUSHSIDES) * sizeof(*out));
*numbrushsides = count;
for (i = 0; i < count; i++, in++, out++)
@ -1664,7 +1674,7 @@ CMod_LoadQBrushSides(const char *name, cbrushside_t **map_brushsides, int *numbr
Com_Error(ERR_DROP, "%s: Map %s with no planes", __func__, name);
}
out = *map_brushsides = Hunk_Alloc((count + 6) * sizeof(*out));
out = *map_brushsides = Hunk_Alloc((count + EXTRA_LUMP_BRUSHSIDES) * sizeof(*out));
*numbrushsides = count;
for (i = 0; i < count; i++, in++, out++)
@ -1916,41 +1926,41 @@ CM_LoadMap(char *name, qboolean clientload, unsigned *checksum)
int hunkSize = 0;
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_TEXINFO],
sizeof(texinfo_t), sizeof(mapsurface_t), 0);
sizeof(texinfo_t), sizeof(mapsurface_t), EXTRA_LUMP_TEXINFO);
if (header.ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_LEAFS],
sizeof(dleaf_t), sizeof(cleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_LEAFBRUSHES],
sizeof(short), sizeof(int), 1);
sizeof(short), sizeof(int), EXTRA_LUMP_LEAFBRUSHES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_LEAFS],
sizeof(dqleaf_t), sizeof(cleaf_t), 0);
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_LEAFBRUSHES],
sizeof(int), sizeof(int), 1);
sizeof(int), sizeof(int), EXTRA_LUMP_LEAFBRUSHES);
}
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_PLANES],
sizeof(dplane_t), sizeof(cplane_t), 12);
sizeof(dplane_t), sizeof(cplane_t), EXTRA_LUMP_PLANES);
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_BRUSHES],
sizeof(dbrush_t), sizeof(cbrush_t), 1);
sizeof(dbrush_t), sizeof(cbrush_t), EXTRA_LUMP_BRUSHES);
if (header.ident == IDBSPHEADER)
{
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_BRUSHSIDES],
sizeof(dbrushside_t), sizeof(cbrushside_t), 0);
sizeof(dbrushside_t), sizeof(cbrushside_t), EXTRA_LUMP_BRUSHSIDES);
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_NODES],
sizeof(dnode_t), sizeof(cnode_t), 6);
sizeof(dnode_t), sizeof(cnode_t), EXTRA_LUMP_NODES);
}
else
{
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_BRUSHSIDES],
sizeof(dqbrushside_t), sizeof(cbrushside_t), 0);
sizeof(dqbrushside_t), sizeof(cbrushside_t), EXTRA_LUMP_BRUSHSIDES);
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_NODES],
sizeof(dqnode_t), sizeof(cnode_t), 6);
sizeof(dqnode_t), sizeof(cnode_t), EXTRA_LUMP_NODES);
}
hunkSize += Mod_CalcLumpHunkSize(&header.lumps[LUMP_AREAS],

11
src/common/header/cmodel.h
View file

@ -27,6 +27,17 @@
#ifndef COMMON_CMODEL_H
#define COMMON_CMODEL_H
#define EXTRA_LUMP_VERTEXES 8
#define EXTRA_LUMP_TEXINFO 6
#define EXTRA_LUMP_SURFEDGES 24
#define EXTRA_LUMP_EDGES 13
#define EXTRA_LUMP_FACES 6
#define EXTRA_LUMP_PLANES 12
#define EXTRA_LUMP_LEAFBRUSHES 1
#define EXTRA_LUMP_BRUSHES 1
#define EXTRA_LUMP_NODES 6
#define EXTRA_LUMP_BRUSHSIDES 6
extern int Mod_CalcLumpHunkSize(const lump_t *l, int inSize, int outSize, int extra);
extern void Mod_LoadVisibility(const char *name, dvis_t **vis, int *numvisibility,
const byte *mod_base, const lump_t *l);