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

Vulkan: Calculate needed hunk size in Mod_LoadBrushModel()

Browse source 
Based on ec6d743d
This commit is contained in:
Denis Pauk 2020-12-23 11:48:41 +02:00
parent 278f9104cd
commit 462633d3d9
3 changed files with 298 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/client/refresh/vk/header/local.h
View file

@ -197,7 +197,7 @@ void R_RenderDlights (void);
void R_DrawAlphaSurfaces (void);
void RE_InitParticleTexture (void);
void Draw_InitLocal (void);
void Vk_SubdivideSurface (msurface_t *fa);
void Vk_SubdivideSurface (msurface_t *fa, model_t *loadmodel);
qboolean R_CullBox (vec3_t mins, vec3_t maxs);
void R_RotateForEntity (entity_t *e, float *mvMatrix);
void R_MarkLeaves (void);

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

@ -23,11 +23,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "header/local.h"
model_t *loadmodel;
int modfilelen;
static void Mod_LoadSpriteModel (model_t *mod, void *buffer);
static void Mod_LoadBrushModel (model_t *mod, void *buffer);
static void Mod_LoadAliasModel (model_t *mod, void *buffer);
static void Mod_LoadSpriteModel(model_t *loadmodel, void *buffer, int modfilelen);
static void Mod_LoadBrushModel(model_t *loadmodel, void *buffer, int modfilelen);
static void Mod_LoadAliasModel(model_t *loadmodel, void *buffer, int modfilelen);
static void Mod_Free (model_t *mod);
@ -138,10 +137,12 @@ static model_t *Mod_ForName (char *name, qboolean crash)
{
model_t *mod;
unsigned *buf;
int i;
int i, modfilelen;
if (!name[0])
ri.Sys_Error (ERR_DROP, "%s: NULL name", __func__);
{
ri.Sys_Error(ERR_DROP, "%s: NULL name", __func__);
}
//
// inline models are grabbed only from worldmodel
@ -176,7 +177,7 @@ static model_t *Mod_ForName (char *name, qboolean crash)
if (i == mod_numknown)
{
if (mod_numknown == MAX_MOD_KNOWN)
ri.Sys_Error (ERR_DROP, "mod_numknown == MAX_MOD_KNOWN");
ri.Sys_Error(ERR_DROP, "%s: mod_numknown == MAX_MOD_KNOWN", __func__);
mod_numknown++;
}
strcpy (mod->name, name);
@ -188,7 +189,11 @@ static model_t *Mod_ForName (char *name, qboolean crash)
if (!buf)
{
if (crash)
ri.Sys_Error (ERR_DROP, "Mod_NumForName: %s not found", mod->name);
{
ri.Sys_Error(ERR_DROP, "%s: %s not found",
__func__, mod->name);
}
memset (mod->name, 0, sizeof(mod->name));
return NULL;
}
@ -205,28 +210,26 @@ static model_t *Mod_ForName (char *name, qboolean crash)
switch (LittleLong(*(unsigned *)buf))
{
case IDALIASHEADER:
loadmodel->extradata = Hunk_Begin (0x200000);
Mod_LoadAliasModel (mod, buf);
Mod_LoadAliasModel(mod, buf, modfilelen);
break;
case IDSPRITEHEADER:
loadmodel->extradata = Hunk_Begin (0x10000);
Mod_LoadSpriteModel (mod, buf);
Mod_LoadSpriteModel(mod, buf, modfilelen);
break;
case IDBSPHEADER:
loadmodel->extradata = Hunk_Begin (0x2000000);
Mod_LoadBrushModel (mod, buf);
Mod_LoadBrushModel(mod, buf, modfilelen);
break;
default:
ri.Sys_Error (ERR_DROP,"Mod_NumForName: unknown fileid for %s", mod->name);
ri.Sys_Error(ERR_DROP, "%s: unknown fileid for %s",
__func__, mod->name);
break;
}
loadmodel->extradatasize = Hunk_End ();
mod->extradatasize = Hunk_End ();
ri.FS_FreeFile (buf);
ri.FS_FreeFile(buf);
return mod;
}
@ -298,7 +301,11 @@ static void Mod_LoadVertexes (lump_t *l)
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( count*sizeof(*out));
@ -345,7 +352,11 @@ static void Mod_LoadSubmodels (lump_t *l)
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( count*sizeof(*out));
@ -380,7 +391,11 @@ static void Mod_LoadEdges (lump_t *l)
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( (count + 1) * sizeof(*out));
@ -408,7 +423,11 @@ static void Mod_LoadTexinfo (lump_t *l)
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( count*sizeof(*out));
@ -467,8 +486,7 @@ Fills in s->texturemins[] and s->extents[]
static void CalcSurfaceExtents (msurface_t *s)
{
float mins[2], maxs[2], val;
int i,j;
mvertex_t *v;
int i;
mtexinfo_t *tex;
int bmins[2], bmaxs[2];
@ -479,7 +497,8 @@ static void CalcSurfaceExtents (msurface_t *s)
for (i=0 ; i<s->numedges ; i++)
{
int e;
int e, j;
mvertex_t *v;
e = loadmodel->surfedges[s->firstedge+i];
if (e >= 0)
@ -516,6 +535,81 @@ void Vk_CreateSurfaceLightmap (msurface_t *surf);
void Vk_EndBuildingLightmaps (void);
void Vk_BeginBuildingLightmaps (model_t *m);
static int calcTexinfoAndFacesSize(const lump_t *fl, byte *mod_base, const lump_t *tl)
{
dface_t* face_in = (void *)(mod_base + fl->fileofs);
texinfo_t* texinfo_in = (void *)(mod_base + tl->fileofs);
if (fl->filelen % sizeof(*face_in) || tl->filelen % sizeof(*texinfo_in))
{
// will error out when actually loading it
return 0;
}
int ret = 0;
int face_count = fl->filelen / sizeof(*face_in);
int texinfo_count = tl->filelen / sizeof(*texinfo_in);
{
// out = Hunk_Alloc(count * sizeof(*out));
int baseSize = face_count * sizeof(msurface_t);
baseSize = (baseSize + 31) & ~31;
ret += baseSize;
int ti_size = texinfo_count * sizeof(mtexinfo_t);
ti_size = (ti_size + 31) & ~31;
ret += ti_size;
}
int numWarpFaces = 0;
for (int surfnum = 0; surfnum < face_count; surfnum++, face_in++)
{
int numverts = LittleShort(face_in->numedges);
int ti = LittleShort(face_in->texinfo);
if ((ti < 0) || (ti >= texinfo_count))
{
return 0; // will error out
}
int texFlags = LittleLong(texinfo_in[ti].flags);
/* set the drawing flags */
if (texFlags & SURF_WARP)
{
if (numverts > 60)
return 0; // will error out in R_SubdividePolygon()
// Vk_SubdivideSurface(out, loadmodel); /* cut up polygon for warps */
// for each (pot. recursive) call to R_SubdividePolygon():
// sizeof(glpoly_t) + ((numverts - 4) + 2) * VERTEXSIZE*sizeof(float)
// this is tricky, how much is allocated depends on the size of the surface
// which we don't know (we'd need the vertices etc to know, but we can't load
// those without allocating...)
// so we just count warped faces and use a generous estimate below
++numWarpFaces;
}
else
{
// Vk_BuildPolygonFromSurface(out);
// => poly = Hunk_Alloc(sizeof(vkpoly_t) + (numverts - 4) * VERTEXSIZE*sizeof(float));
int polySize = sizeof(vkpoly_t) + (numverts - 4) * VERTEXSIZE*sizeof(float);
polySize = (polySize + 31) & ~31;
ret += polySize;
}
}
// yeah, this is a bit hacky, but it looks like for each warped face
// 256-55000 bytes are allocated (usually on the lower end),
// so just assume 48k per face to be safe
ret += numWarpFaces * 49152;
ret += 1000000; // and 1MB extra just in case
return ret;
}
/*
=================
Mod_LoadFaces
@ -529,7 +623,11 @@ static void Mod_LoadFaces (lump_t *l)
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
@ -546,6 +644,11 @@ static void Mod_LoadFaces (lump_t *l)
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
if (out->numedges < 3)
{
ri.Sys_Error(ERR_DROP, "%s: Surface with %d edges",
__func__, out->numedges);
}
out->flags = 0;
out->polys = NULL;
@ -558,7 +661,9 @@ static void Mod_LoadFaces (lump_t *l)
ti = LittleShort(in->texinfo);
if (ti < 0 || ti >= loadmodel->numtexinfo)
{
ri.Sys_Error(ERR_DROP, "%s: bad texinfo number", __func__);
}
out->texinfo = loadmodel->texinfo + ti;
CalcSurfaceExtents(out);
@ -583,7 +688,7 @@ static void Mod_LoadFaces (lump_t *l)
out->extents[i] = 16384;
out->texturemins[i] = -8192;
}
Vk_SubdivideSurface(out); // cut up polygon for warps
Vk_SubdivideSurface(out, loadmodel); // cut up polygon for warps
}
if (out->texinfo->flags & SURF_SKY)
@ -631,7 +736,11 @@ static void Mod_LoadNodes (lump_t *l)
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( count*sizeof(*out));
@ -681,7 +790,11 @@ static void Mod_LoadLeafs (lump_t *l)
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( count*sizeof(*out));
@ -690,7 +803,6 @@ static void Mod_LoadLeafs (lump_t *l)
for ( i=0 ; i<count ; i++, in++, out++)
{
int p;
unsigned firstleafface;
for (j=0 ; j<3 ; j++)
@ -699,9 +811,7 @@ static void Mod_LoadLeafs (lump_t *l)
out->minmaxs[3+j] = LittleShort (in->maxs[j]);
}
p = LittleLong(in->contents);
out->contents = p;
out->contents = LittleLong(in->contents);
out->cluster = LittleShort(in->cluster);
out->area = LittleShort(in->area);
@ -712,7 +822,8 @@ static void Mod_LoadLeafs (lump_t *l)
out->firstmarksurface = loadmodel->marksurfaces + firstleafface;
if ((firstleafface + out->nummarksurfaces) > loadmodel->nummarksurfaces)
{
ri.Sys_Error (ERR_DROP, "%s: wrong marksurfaces position in %s", __func__, loadmodel->name);
ri.Sys_Error(ERR_DROP, "%s: wrong marksurfaces position in %s",
__func__, loadmodel->name);
}
// gl underwater warp
@ -742,8 +853,13 @@ static void Mod_LoadMarksurfaces (lump_t *l)
msurface_t **out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( count*sizeof(*out));
@ -756,7 +872,9 @@ static void Mod_LoadMarksurfaces (lump_t *l)
j = LittleShort(in[i]);
if (j < 0 || j >= loadmodel->numsurfaces)
ri.Sys_Error (ERR_DROP, "Mod_ParseMarksurfaces: bad surface number");
{
ri.Sys_Error(ERR_DROP, "%s: bad surface number", __func__);
}
out[i] = loadmodel->surfaces + j;
}
}
@ -773,7 +891,11 @@ static void Mod_LoadSurfedges (lump_t *l)
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
if (count < 1 || count >= MAX_MAP_SURFEDGES)
ri.Sys_Error (ERR_DROP, "%s: bad surfedges count in %s: %i",
@ -796,14 +918,19 @@ Mod_LoadPlanes
*/
static void Mod_LoadPlanes (lump_t *l)
{
int i, j;
int i;
cplane_t *out;
dplane_t *in;
int count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "%s: funny lump size in %s", __func__, loadmodel->name);
{
ri.Sys_Error(ERR_DROP, "%s: funny lump size in %s",
__func__, loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( count*2*sizeof(*out));
@ -812,7 +939,7 @@ static void Mod_LoadPlanes (lump_t *l)
for ( i=0 ; i<count ; i++, in++, out++)
{
int bits;
int bits, j;
bits = 0;
for (j=0 ; j<3 ; j++)
@ -828,32 +955,78 @@ static void Mod_LoadPlanes (lump_t *l)
}
}
// calculate the size that Hunk_Alloc(), called by Mod_Load*() from Mod_LoadBrushModel(),
// will use (=> includes its padding), so we'll know how big the hunk needs to be
static int calcLumpHunkSize(const lump_t *l, int inSize, int outSize)
{
if (l->filelen % inSize)
{
// Mod_Load*() will error out on this because of "funny size"
// don't error out here because in Mod_Load*() it can print the functionname
// (=> tells us what kind of lump) before shutting down the game
return 0;
}
int count = l->filelen / inSize;
int size = count * outSize;
// round to cacheline, like Hunk_Alloc() does
size = (size + 31) & ~31;
return size;
}
/*
=================
Mod_LoadBrushModel
=================
*/
static void Mod_LoadBrushModel (model_t *mod, void *buffer)
static void Mod_LoadBrushModel (model_t *mod, void *buffer, int modfilelen)
{
int i;
dheader_t *header;
mmodel_t *bm;
loadmodel->type = mod_brush;
if (loadmodel != mod_known)
ri.Sys_Error (ERR_DROP, "Loaded a brush model after the world");
ri.Sys_Error(ERR_DROP, "%s: Loaded a brush model after the world", __func__);
header = (dheader_t *)buffer;
i = LittleLong (header->version);
i = LittleLong(header->version);
if (i != BSPVERSION)
ri.Sys_Error (ERR_DROP, "%s: %s has wrong version number (%i should be %i)", __func__, mod->name, i, BSPVERSION);
{
ri.Sys_Error(ERR_DROP, "%s: %s has wrong version number (%i should be %i)",
__func__, loadmodel->name, i, BSPVERSION);
}
// swap all the lumps
mod_base = (byte *)header;
for (i=0 ; i<sizeof(dheader_t)/4 ; i++)
((int *)header)[i] = LittleLong ( ((int *)header)[i]);
for (i = 0; i < sizeof(dheader_t) / 4; i++)
{
((int *)header)[i] = LittleLong(((int *)header)[i]);
}
// calculate the needed hunksize from the lumps
int hunkSize = 0;
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_VERTEXES], sizeof(dvertex_t), sizeof(mvertex_t));
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_EDGES], sizeof(dedge_t), sizeof(medge_t));
hunkSize += sizeof(medge_t) + 31; // for count+1 in Mod_LoadEdges()
int surfEdgeCount = (header->lumps[LUMP_SURFEDGES].filelen+sizeof(int)-1)/sizeof(int);
if(surfEdgeCount < MAX_MAP_SURFEDGES) // else it errors out later anyway
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_SURFEDGES], sizeof(int), sizeof(int));
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_LIGHTING], 1, 1);
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_PLANES], sizeof(dplane_t), sizeof(cplane_t)*2);
hunkSize += calcTexinfoAndFacesSize(&header->lumps[LUMP_FACES], mod_base, &header->lumps[LUMP_TEXINFO]);
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_LEAFFACES], sizeof(short), sizeof(msurface_t *)); // yes, out is indeeed a pointer!
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_VISIBILITY], 1, 1);
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_LEAFS], sizeof(dleaf_t), sizeof(mleaf_t));
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_NODES], sizeof(dnode_t), sizeof(mnode_t));
hunkSize += calcLumpHunkSize(&header->lumps[LUMP_MODELS], sizeof(dmodel_t), sizeof(mmodel_t));
loadmodel->extradata = Hunk_Begin(hunkSize);
loadmodel->type = mod_brush;
// load into heap
Mod_LoadVertexes (&header->lumps[LUMP_VERTEXES]);
@ -870,10 +1043,10 @@ static void Mod_LoadBrushModel (model_t *mod, void *buffer)
Mod_LoadSubmodels (&header->lumps[LUMP_MODELS]);
mod->numframes = 2; // regular and alternate animation
//
// set up the submodels
//
for (i=0 ; i<mod->numsubmodels ; i++)
//
// set up the submodels
//
for (i = 0; i < mod->numsubmodels; i++)
{
model_t *starmod;
@ -886,14 +1059,19 @@ static void Mod_LoadBrushModel (model_t *mod, void *buffer)
starmod->nummodelsurfaces = bm->numfaces;
starmod->firstnode = bm->headnode;
if (starmod->firstnode >= loadmodel->numnodes)
ri.Sys_Error (ERR_DROP, "Inline model %i has bad firstnode", i);
{
ri.Sys_Error(ERR_DROP, "%s: Inline model %i has bad firstnode",
__func__, i);
}
VectorCopy (bm->maxs, starmod->maxs);
VectorCopy (bm->mins, starmod->mins);
starmod->radius = bm->radius;
if (i == 0)
{
*loadmodel = *starmod;
}
starmod->numleafs = bm->visleafs;
}
@ -912,50 +1090,78 @@ ALIAS MODELS
Mod_LoadAliasModel
=================
*/
static void Mod_LoadAliasModel (model_t *mod, void *buffer)
static void Mod_LoadAliasModel (model_t *mod, void *buffer, int modfilelen)
{
int i, j;
dmdl_t *pinmodel, *pheader;
dstvert_t *pinst, *poutst;
dtriangle_t *pintri, *pouttri;
int *pincmd, *poutcmd;
int version;
int i, j;
dmdl_t *pinmodel, *pheader;
dstvert_t *pinst, *poutst;
dtriangle_t *pintri, *pouttri;
int *pincmd, *poutcmd;
int version;
int ofs_end;
pinmodel = (dmdl_t *)buffer;
version = LittleLong (pinmodel->version);
if (version != ALIAS_VERSION)
ri.Sys_Error (ERR_DROP, "%s has wrong version number (%i should be %i)",
mod->name, version, ALIAS_VERSION);
{
ri.Sys_Error(ERR_DROP, "%s: %s has wrong version number (%i should be %i)",
__func__, mod->name, version, ALIAS_VERSION);
}
pheader = Hunk_Alloc (LittleLong(pinmodel->ofs_end));
ofs_end = LittleLong(pinmodel->ofs_end);
if (ofs_end < 0 || ofs_end > modfilelen)
{
ri.Sys_Error(ERR_DROP, "%s: model %s file size(%d) too small, should be %d", mod->name,
__func__, modfilelen, ofs_end);
}
loadmodel->extradata = Hunk_Begin(modfilelen);
pheader = Hunk_Alloc(ofs_end);
// byte swap the header fields and sanity check
for (i=0 ; i<sizeof(dmdl_t)/4 ; i++)
((int *)pheader)[i] = LittleLong (((int *)buffer)[i]);
if (pheader->skinheight > MAX_LBM_HEIGHT)
ri.Sys_Error (ERR_DROP, "model %s has a skin taller than %d", mod->name,
MAX_LBM_HEIGHT);
{
ri.Sys_Error(ERR_DROP, "%s: model %s has a skin taller than %d",
__func__, mod->name, MAX_LBM_HEIGHT);
}
if (pheader->num_xyz <= 0)
ri.Sys_Error (ERR_DROP, "model %s has no vertices", mod->name);
{
ri.Sys_Error(ERR_DROP, "%s: model %s has no vertices",
__func__, mod->name);
}
if (pheader->num_xyz > MAX_VERTS)
ri.Sys_Error (ERR_DROP, "model %s has too many vertices", mod->name);
{
ri.Sys_Error(ERR_DROP, "%s: model %s has too many vertices",
__func__, mod->name);
}
if (pheader->num_st <= 0)
ri.Sys_Error (ERR_DROP, "model %s has no st vertices", mod->name);
{
ri.Sys_Error(ERR_DROP, "%s: model %s has no st vertices",
__func__, mod->name);
}
if (pheader->num_tris <= 0)
ri.Sys_Error (ERR_DROP, "model %s has no triangles", mod->name);
{
ri.Sys_Error(ERR_DROP, "%s: model %s has no triangles",
__func__, mod->name);
}
if (pheader->num_frames <= 0)
ri.Sys_Error (ERR_DROP, "model %s has no frames", mod->name);
{
ri.Sys_Error(ERR_DROP, "%s: model %s has no frames",
__func__, mod->name);
}
//
// load base s and t vertices (not used in gl version)
//
//
// load base s and t vertices (not used in gl version)
//
pinst = (dstvert_t *) ((byte *)pinmodel + pheader->ofs_st);
poutst = (dstvert_t *) ((byte *)pheader + pheader->ofs_st);
@ -965,9 +1171,9 @@ static void Mod_LoadAliasModel (model_t *mod, void *buffer)
poutst[i].t = LittleShort (pinst[i].t);
}
//
// load triangle lists
//
//
// load triangle lists
//
pintri = (dtriangle_t *) ((byte *)pinmodel + pheader->ofs_tris);
pouttri = (dtriangle_t *) ((byte *)pheader + pheader->ofs_tris);
@ -980,9 +1186,9 @@ static void Mod_LoadAliasModel (model_t *mod, void *buffer)
}
}
//
// load the frames
//
//
// load the frames
//
for (i=0 ; i<pheader->num_frames ; i++)
{
daliasframe_t *pinframe, *poutframe;
@ -1045,25 +1251,30 @@ SPRITE MODELS
Mod_LoadSpriteModel
=================
*/
static void Mod_LoadSpriteModel (model_t *mod, void *buffer)
static void Mod_LoadSpriteModel (model_t *mod, void *buffer, int modfilelen)
{
dsprite_t *sprin, *sprout;
int i;
sprin = (dsprite_t *)buffer;
sprout = Hunk_Alloc (modfilelen);
loadmodel->extradata = Hunk_Begin(modfilelen);
sprout = Hunk_Alloc(modfilelen);
sprout->ident = LittleLong (sprin->ident);
sprout->version = LittleLong (sprin->version);
sprout->numframes = LittleLong (sprin->numframes);
if (sprout->version != SPRITE_VERSION)
ri.Sys_Error (ERR_DROP, "%s has wrong version number (%i should be %i)",
mod->name, sprout->version, SPRITE_VERSION);
{
ri.Sys_Error(ERR_DROP, "%s: %s has wrong version number (%i should be %i)",
__func__, mod->name, sprout->version, SPRITE_VERSION);
}
if (sprout->numframes > MAX_MD2SKINS)
ri.Sys_Error (ERR_DROP, "%s has too many frames (%i > %i)",
mod->name, sprout->numframes, MAX_MD2SKINS);
{
ri.Sys_Error(ERR_DROP, "%s: %s has too many frames (%i > %i)",
__func__, mod->name, sprout->numframes, MAX_MD2SKINS);
}
// byte swap everything
for (i=0 ; i<sprout->numframes ; i++)
@ -1120,7 +1331,6 @@ RE_RegisterModel
struct model_s *RE_RegisterModel (char *name)
{
model_t *mod;
dmdl_t *pheader;
mod = Mod_ForName (name, false);
if (mod)
@ -1140,6 +1350,8 @@ struct model_s *RE_RegisterModel (char *name)
}
else if (mod->type == mod_alias)
{
dmdl_t *pheader;
pheader = (dmdl_t *)mod->extradata;
for (i=0 ; i<pheader->num_skins ; i++)
mod->skins[i] = Vk_FindImage ((char *)pheader + pheader->ofs_skins + i*MAX_SKINNAME, it_skin);

4
src/client/refresh/vk/vk_warp.c
View file

@ -21,8 +21,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// vk_warp.c -- sky and water polygons
#include "header/local.h"
extern model_t *loadmodel;
static char skyname[MAX_QPATH];
static float skyrotate;
static vec3_t skyaxis;
@ -162,7 +160,7 @@ boundaries so that turbulent and sky warps
can be done reasonably.
================
*/
void Vk_SubdivideSurface (msurface_t *fa)
void Vk_SubdivideSurface (msurface_t *fa, model_t *loadmodel)
{
vec3_t verts[64];
int numverts;