if (model == NULL)
return NULL;
- Mod_CheckLoaded(model);
-
// LordHavoc: modified to start at first clip node,
// in other words: first node of the (sub)model
node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode;
return (mleaf_t *)node;
}
-static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, qbyte *out, int outsize)
+static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, unsigned char *out, int outsize)
{
int i;
mleaf_t *leaf;
memset(out, 0, outsize);
}
-static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
+{
+ int numclusters = 0;
+ int nodestackindex = 0;
+ mnode_t *node, *nodestack[1024];
+ if (!model->brush.num_pvsclusters)
+ return -1;
+ node = model->brush.data_nodes;
+ for (;;)
+ {
+#if 1
+ if (node->plane)
+ {
+ // node - recurse down the BSP tree
+ int side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
+ if (side < 2)
+ {
+ // box is on one side of plane, take that path
+ node = node->children[side];
+ }
+ else
+ {
+ // box crosses plane, take one path and remember the other
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
+ node = node->children[1];
+ }
+ continue;
+ }
+ else
+ {
+ // leaf - add clusterindex to list
+ if (numclusters < maxclusters)
+ clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
+ numclusters++;
+ }
+#else
+ if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
+ {
+ if (node->plane)
+ {
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
+ node = node->children[1];
+ continue;
+ }
+ else
+ {
+ // leaf - add clusterindex to list
+ if (numclusters < maxclusters)
+ clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
+ numclusters++;
+ }
+ }
+#endif
+ // try another path we didn't take earlier
+ if (nodestackindex == 0)
+ break;
+ node = nodestack[--nodestackindex];
+ }
+ // return number of clusters found (even if more than the maxclusters)
+ return numclusters;
+}
+
+static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
{
- int clusterindex, side, nodestackindex = 0;
+ int nodestackindex = 0;
mnode_t *node, *nodestack[1024];
if (!model->brush.num_pvsclusters)
return true;
node = model->brush.data_nodes;
for (;;)
{
+#if 1
if (node->plane)
{
// node - recurse down the BSP tree
- side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
+ int side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
if (side < 2)
{
// box is on one side of plane, take that path
nodestack[nodestackindex++] = node->children[0];
node = node->children[1];
}
+ continue;
}
else
{
// leaf - check cluster bit
- clusterindex = ((mleaf_t *)node)->clusterindex;
+ int clusterindex = ((mleaf_t *)node)->clusterindex;
if (CHECKPVSBIT(pvs, clusterindex))
{
// it is visible, return immediately with the news
return true;
}
+ }
+#else
+ if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
+ {
+ if (node->plane)
+ {
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
+ node = node->children[1];
+ continue;
+ }
else
{
- // nothing to see here, try another path we didn't take earlier
- if (nodestackindex == 0)
- break;
- node = nodestack[--nodestackindex];
+ // leaf - check cluster bit
+ int clusterindex = ((mleaf_t *)node)->clusterindex;
+ if (CHECKPVSBIT(pvs, clusterindex))
+ {
+ // it is visible, return immediately with the news
+ return true;
+ }
}
}
+#endif
+ // nothing to see here, try another path we didn't take earlier
+ if (nodestackindex == 0)
+ break;
+ node = nodestack[--nodestackindex];
}
// it is not visible
return false;
}
-static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
{
- int clusterindex, side, nodestackindex = 0;
+ int nodestackindex = 0;
mnode_t *node, *nodestack[1024];
if (!model->brush.num_leafs)
return true;
node = model->brush.data_nodes;
for (;;)
{
+#if 1
if (node->plane)
{
// node - recurse down the BSP tree
- side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
+ int side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
if (side < 2)
{
// box is on one side of plane, take that path
nodestack[nodestackindex++] = node->children[0];
node = node->children[1];
}
+ continue;
}
else
{
// leaf - check cluster bit
- clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
+ int clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
if (CHECKPVSBIT(pvs, clusterindex))
{
// it is visible, return immediately with the news
return true;
}
+ }
+#else
+ if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
+ {
+ if (node->plane)
+ {
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
+ node = node->children[1];
+ continue;
+ }
else
{
- // nothing to see here, try another path we didn't take earlier
- if (nodestackindex == 0)
- break;
- node = nodestack[--nodestackindex];
+ // leaf - check cluster bit
+ int clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
+ if (CHECKPVSBIT(pvs, clusterindex))
+ {
+ // it is visible, return immediately with the news
+ return true;
+ }
}
}
+#endif
+ // nothing to see here, try another path we didn't take earlier
+ if (nodestackindex == 0)
+ break;
+ node = nodestack[--nodestackindex];
}
// it is not visible
return false;
}
-static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const qbyte *visibleleafs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs)
{
- int side, nodestackindex = 0;
+ int nodestackindex = 0;
mnode_t *node, *nodestack[1024];
+ if (!model->brush.num_leafs)
+ return true;
node = model->brush.data_nodes;
for (;;)
{
+#if 1
if (node->plane)
{
// node - recurse down the BSP tree
- side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
+ int side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
if (side < 2)
{
// box is on one side of plane, take that path
nodestack[nodestackindex++] = node->children[0];
node = node->children[1];
}
+ continue;
}
else
{
// it is visible, return immediately with the news
return true;
}
+ }
+#else
+ if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
+ {
+ if (node->plane)
+ {
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
+ node = node->children[1];
+ continue;
+ }
else
{
- // nothing to see here, try another path we didn't take earlier
- if (nodestackindex == 0)
- break;
- node = nodestack[--nodestackindex];
+ // leaf - check if it is visible
+ if (visibleleafs[(mleaf_t *)node - model->brush.data_leafs])
+ {
+ // it is visible, return immediately with the news
+ return true;
+ }
}
}
+#endif
+ // nothing to see here, try another path we didn't take earlier
+ if (nodestackindex == 0)
+ break;
+ node = nodestack[--nodestackindex];
}
// it is not visible
return false;
return CONTENTS_EMPTY;
}
-typedef struct
+typedef struct RecursiveHullCheckTraceInfo_s
{
// the hull we're tracing through
const hull_t *hull;
if (ds >= 0 && ds < surface->lightmapinfo->extents[0] && dt >= 0 && dt < surface->lightmapinfo->extents[1])
{
- qbyte *lightmap;
+ unsigned char *lightmap;
int lmwidth, lmheight, maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
lmwidth = ((surface->lightmapinfo->extents[0]>>4)+1);
lmheight = ((surface->lightmapinfo->extents[1]>>4)+1);
for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++)
{
- scale = d_lightstylevalue[surface->lightmapinfo->styles[maps]];
+ scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]];
r00 += lightmap[ 0] * scale;g00 += lightmap[ 1] * scale;b00 += lightmap[ 2] * scale;
r01 += lightmap[ 3] * scale;g01 += lightmap[ 4] * scale;b01 += lightmap[ 5] * scale;
r10 += lightmap[line3+0] * scale;g10 += lightmap[line3+1] * scale;b10 += lightmap[line3+2] * scale;
Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2], p[2] - 65536);
}
-static void Mod_Q1BSP_DecompressVis(const qbyte *in, const qbyte *inend, qbyte *out, qbyte *outend)
+static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char *inend, unsigned char *out, unsigned char *outend)
{
int c;
- qbyte *outstart = out;
+ unsigned char *outstart = out;
while (out < outend)
{
if (in == inend)
A sky texture is 256*128, with the right side being a masked overlay
==============
*/
-void R_Q1BSP_LoadSplitSky (qbyte *src, int width, int height, int bytesperpixel)
+void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesperpixel)
{
int i, j;
unsigned solidpixels[128*128], alphapixels[128*128];
}
}
- loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (qbyte *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
- loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (qbyte *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
+ loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
+ loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
}
static void Mod_Q1BSP_LoadTextures(lump_t *l)
miptex_t *dmiptex;
texture_t *tx, *tx2, *anims[10], *altanims[10];
dmiptexlump_t *m;
- qbyte *data, *mtdata;
+ unsigned char *data, *mtdata;
char name[256];
loadmodel->data_textures = NULL;
loadmodel->num_textures = 2;
}
- loadmodel->data_textures = Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t));
+ loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t));
// fill out all slots with notexture
for (i = 0, tx = loadmodel->data_textures;i < loadmodel->num_textures;i++, tx++)
dofs[i] = LittleLong(dofs[i]);
if (dofs[i] == -1 || r_nosurftextures.integer)
continue;
- dmiptex = (miptex_t *)((qbyte *)m + dofs[i]);
+ dmiptex = (miptex_t *)((unsigned char *)m + dofs[i]);
// make sure name is no more than 15 characters
for (j = 0;dmiptex->name[j] && j < 15;j++)
Con_Printf("Texture \"%s\" in \"%s\"is corrupt or incomplete\n", dmiptex->name, loadmodel->name);
continue;
}
- mtdata = (qbyte *)dmiptex + j;
+ mtdata = (unsigned char *)dmiptex + j;
}
if ((mtwidth & 15) || (mtheight & 15))
if (loadmodel->brush.ishlbsp)
{
// internal texture overrides wad
- qbyte *pixels, *freepixels, *fogpixels;
+ unsigned char *pixels, *freepixels, *fogpixels;
pixels = freepixels = NULL;
if (mtdata)
pixels = W_ConvertWAD3Texture(dmiptex);
tx->skin.base = tx->skin.merged = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, NULL);
if (Image_CheckAlpha(pixels, image_width * image_height, true))
{
- fogpixels = Mem_Alloc(tempmempool, image_width * image_height * 4);
+ fogpixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
for (j = 0;j < image_width * image_height * 4;j += 4)
{
fogpixels[j + 0] = 255;
static void Mod_Q1BSP_LoadLighting(lump_t *l)
{
int i;
- qbyte *in, *out, *data, d;
+ unsigned char *in, *out, *data, d;
char litfilename[1024];
loadmodel->brushq1.lightdata = NULL;
if (loadmodel->brush.ishlbsp) // LordHavoc: load the colored lighting data straight
{
- loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, l->filelen);
+ loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
for (i=0; i<l->filelen; i++)
loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1;
}
else if (loadmodel->brush.ismcbsp)
{
- loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, l->filelen);
+ loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen);
}
else // LordHavoc: bsp version 29 (normal white lighting)
strlcpy (litfilename, loadmodel->name, sizeof (litfilename));
FS_StripExtension (litfilename, litfilename, sizeof (litfilename));
strlcat (litfilename, ".lit", sizeof (litfilename));
- data = (qbyte*) FS_LoadFile(litfilename, tempmempool, false);
+ data = (unsigned char*) FS_LoadFile(litfilename, tempmempool, false);
if (data)
{
if (fs_filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
if (i == 1)
{
Con_DPrintf("loaded %s\n", litfilename);
- loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, fs_filesize - 8);
+ loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, fs_filesize - 8);
memcpy(loadmodel->brushq1.lightdata, data + 8, fs_filesize - 8);
Mem_Free(data);
return;
// LordHavoc: oh well, expand the white lighting data
if (!l->filelen)
return;
- loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, l->filelen*3);
+ loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen*3);
in = loadmodel->brushq1.lightdata + l->filelen*2; // place the file at the end, so it will not be overwritten until the very last write
out = loadmodel->brushq1.lightdata;
memcpy(in, mod_base + l->fileofs, l->filelen);
s++;
numlights++;
}
- loadmodel->brushq1.lights = Mem_Alloc(loadmodel->mempool, numlights * sizeof(mlight_t));
+ loadmodel->brushq1.lights = (mlight_t *)Mem_Alloc(loadmodel->mempool, numlights * sizeof(mlight_t));
s = lightsstring;
n = 0;
while (*s && n < numlights)
if (!l->filelen)
return;
loadmodel->brushq1.num_compressedpvs = l->filelen;
- loadmodel->brushq1.data_compressedpvs = Mem_Alloc(loadmodel->mempool, l->filelen);
+ loadmodel->brushq1.data_compressedpvs = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
memcpy(loadmodel->brushq1.data_compressedpvs, mod_base + l->fileofs, l->filelen);
}
loadmodel->brush.entities = NULL;
if (!l->filelen)
return;
- loadmodel->brush.entities = Mem_Alloc(loadmodel->mempool, l->filelen);
+ loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
if (loadmodel->brush.ishlbsp)
Mod_Q1BSP_ParseWadsFromEntityLump(loadmodel->brush.entities);
mvertex_t *out;
int i, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (dvertex_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadVertexes: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+ out = (mvertex_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
loadmodel->brushq1.vertexes = out;
loadmodel->brushq1.numvertexes = count;
// The following two functions should be removed and MSG_* or SZ_* function sets adjusted so they
// can be used for this
// REMOVEME
-int SB_ReadInt (qbyte **buffer)
+int SB_ReadInt (unsigned char **buffer)
{
int i;
i = ((*buffer)[0]) + 256*((*buffer)[1]) + 65536*((*buffer)[2]) + 16777216*((*buffer)[3]);
}
// REMOVEME
-float SB_ReadFloat (qbyte **buffer)
+float SB_ReadFloat (unsigned char **buffer)
{
union
{
static void Mod_Q1BSP_LoadSubmodels(lump_t *l, hullinfo_t *hullinfo)
{
- qbyte *index;
+ unsigned char *index;
dmodel_t *out;
int i, j, count;
- index = (qbyte *)(mod_base + l->fileofs);
+ index = (unsigned char *)(mod_base + l->fileofs);
if (l->filelen % (48+4*hullinfo->filehulls))
Host_Error ("Mod_Q1BSP_LoadSubmodels: funny lump size in %s", loadmodel->name);
count = l->filelen / (48+4*hullinfo->filehulls);
- out = Mem_Alloc (loadmodel->mempool, count*sizeof(*out));
+ out = (dmodel_t *)Mem_Alloc (loadmodel->mempool, count*sizeof(*out));
loadmodel->brushq1.submodels = out;
loadmodel->brush.numsubmodels = count;
medge_t *out;
int i, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (dedge_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadEdges: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (medge_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq1.edges = out;
loadmodel->brushq1.numedges = count;
mtexinfo_t *out;
int i, j, k, count, miptex;
- in = (void *)(mod_base + l->fileofs);
+ in = (texinfo_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadTexinfo: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (mtexinfo_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq1.texinfo = out;
loadmodel->brushq1.numtexinfo = count;
int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris;
float texmins[2], texmaxs[2], val;
- in = (void *)(mod_base + l->fileofs);
+ in = (dface_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadFaces: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- loadmodel->data_surfaces = Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
- loadmodel->data_surfaces_lightmapinfo = Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_lightmapinfo_t));
+ loadmodel->data_surfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
+ loadmodel->data_surfaces_lightmapinfo = (msurface_lightmapinfo_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_lightmapinfo_t));
loadmodel->num_surfaces = count;
totalverts = 0;
totaltris = 0;
- for (surfacenum = 0, in = (void *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
+ for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
{
numedges = LittleShort(in->numedges);
totalverts += numedges;
// TODO: split up into multiple meshes as needed to avoid exceeding 65536
// vertex limit
loadmodel->nummeshes = 1;
- loadmodel->meshlist = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *));
+ loadmodel->meshlist = (surfmesh_t **)Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *));
loadmodel->meshlist[0] = Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, true, false, false);
totalverts = 0;
totaltris = 0;
- for (surfacenum = 0, in = (void *)(mod_base + l->fileofs), surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
+ for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs), surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
{
surface->lightmapinfo = loadmodel->data_surfaces_lightmapinfo + surfacenum;
// give non-lightmapped water a 1x white lightmap
if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
{
- surface->lightmapinfo->samples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+ surface->lightmapinfo->samples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
surface->lightmapinfo->styles[0] = 0;
memset(surface->lightmapinfo->samples, 128, ssize * tsize * 3);
}
if (ssize > 256 || tsize > 256)
Host_Error("Bad surface extents");
// stainmap for permanent marks on walls
- surface->lightmapinfo->stainsamples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+ surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
// clear to white
memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
dnode_t *in;
mnode_t *out;
- in = (void *)(mod_base + l->fileofs);
+ in = (dnode_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadNodes: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+ out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
loadmodel->brush.data_nodes = out;
loadmodel->brush.num_nodes = count;
mleaf_t *out;
int i, j, count, p;
- in = (void *)(mod_base + l->fileofs);
+ in = (dleaf_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+ out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
loadmodel->brush.data_leafs = out;
loadmodel->brush.num_leafs = count;
// get visleafs from the submodel data
loadmodel->brush.num_pvsclusters = loadmodel->brushq1.submodels[0].visleafs;
loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters+7)>>3;
- loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
+ loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
memset(loadmodel->brush.data_pvsclusters, 0xFF, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
for ( i=0 ; i<count ; i++, in++, out++)
int i, count;
hull_t *hull;
- in = (void *)(mod_base + l->fileofs);
+ in = (dclipnode_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadClipnodes: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
+ out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
loadmodel->brushq1.clipnodes = out;
loadmodel->brushq1.numclipnodes = count;
hull = &loadmodel->brushq1.hulls[0];
in = loadmodel->brush.data_nodes;
- out = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
+ out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
hull->clipnodes = out;
hull->firstclipnode = 0;
int i, j;
short *in;
- in = (void *)(mod_base + l->fileofs);
+ in = (short *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadLeaffaces: funny lump size in %s",loadmodel->name);
loadmodel->brush.num_leafsurfaces = l->filelen / sizeof(*in);
- loadmodel->brush.data_leafsurfaces = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int));
+ loadmodel->brush.data_leafsurfaces = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int));
for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++)
{
int i;
int *in;
- in = (void *)(mod_base + l->fileofs);
+ in = (int *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadSurfedges: funny lump size in %s",loadmodel->name);
loadmodel->brushq1.numsurfedges = l->filelen / sizeof(*in);
- loadmodel->brushq1.surfedges = Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numsurfedges * sizeof(int));
+ loadmodel->brushq1.surfedges = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numsurfedges * sizeof(int));
for (i = 0;i < loadmodel->brushq1.numsurfedges;i++)
loadmodel->brushq1.surfedges[i] = LittleLong(in[i]);
mplane_t *out;
dplane_t *in;
- in = (void *)(mod_base + l->fileofs);
+ in = (dplane_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadPlanes: funny lump size in %s", loadmodel->name);
loadmodel->brush.num_planes = l->filelen / sizeof(*in);
- loadmodel->brush.data_planes = out = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out));
+ loadmodel->brush.data_planes = out = (mplane_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out));
for (i = 0;i < loadmodel->brush.num_planes;i++, in++, out++)
{
char mapfilename[MAX_QPATH];
FS_StripExtension (loadmodel->name, mapfilename, sizeof (mapfilename));
strlcat (mapfilename, ".map", sizeof (mapfilename));
- maptext = (qbyte*) FS_LoadFile(mapfilename, tempmempool, false);
+ maptext = (unsigned char*) FS_LoadFile(mapfilename, tempmempool, false);
if (!maptext)
return;
text = maptext;
static portal_t *AllocPortal(void)
{
portal_t *p;
- p = Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
+ p = (portal_t *)Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
p->chain = portalchain;
portalchain = p;
return p;
mvertex_t *point;
mleaf_t *leaf, *endleaf;
- // recalculate bounding boxes for all leafs(because qbsp is very sloppy)
+ // tally up portal and point counts and recalculate bounding boxes for all
+ // leafs (because qbsp is very sloppy)
leaf = loadmodel->brush.data_leafs;
endleaf = leaf + loadmodel->brush.num_leafs;
for (;leaf < endleaf;leaf++)
VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000);
}
p = portalchain;
- while (p)
- {
- if (p->numpoints >= 3)
- {
- for (i = 0;i < 2;i++)
- {
- leaf = (mleaf_t *)p->nodes[i];
- for (j = 0;j < p->numpoints;j++)
- {
- if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0];
- if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1];
- if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2];
- if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0];
- if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1];
- if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2];
- }
- }
- }
- p = p->chain;
- }
-
- Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes);
-
- // tally up portal and point counts
- p = portalchain;
numportals = 0;
numpoints = 0;
while (p)
}
p = p->chain;
}
- loadmodel->brush.data_portals = Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
+ loadmodel->brush.data_portals = (mportal_t *)Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
loadmodel->brush.num_portals = numportals;
- loadmodel->brush.data_portalpoints = (void *)((qbyte *) loadmodel->brush.data_portals + numportals * sizeof(mportal_t));
+ loadmodel->brush.data_portalpoints = (mvertex_t *)((unsigned char *) loadmodel->brush.data_portals + numportals * sizeof(mportal_t));
loadmodel->brush.num_portalpoints = numpoints;
// clear all leaf portal chains
for (i = 0;i < loadmodel->brush.num_leafs;i++)
{
pnext = p->chain;
- // note: this check must match the one above or it will usually corrupt memory
- // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
- if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1] && ((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
+ if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1])
{
- // first make the back to front portal(forward portal)
- portal->points = point;
- portal->numpoints = p->numpoints;
- portal->plane.dist = p->plane.dist;
- VectorCopy(p->plane.normal, portal->plane.normal);
- portal->here = (mleaf_t *)p->nodes[1];
- portal->past = (mleaf_t *)p->nodes[0];
- // copy points
- for (j = 0;j < portal->numpoints;j++)
+ // note: this check must match the one above or it will usually corrupt memory
+ // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
+ if (((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
{
- VectorCopy(p->points + j*3, point->position);
- point++;
+ // first make the back to front portal(forward portal)
+ portal->points = point;
+ portal->numpoints = p->numpoints;
+ portal->plane.dist = p->plane.dist;
+ VectorCopy(p->plane.normal, portal->plane.normal);
+ portal->here = (mleaf_t *)p->nodes[1];
+ portal->past = (mleaf_t *)p->nodes[0];
+ // copy points
+ for (j = 0;j < portal->numpoints;j++)
+ {
+ VectorCopy(p->points + j*3, point->position);
+ point++;
+ }
+ BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
+ PlaneClassify(&portal->plane);
+
+ // link into leaf's portal chain
+ portal->next = portal->here->portals;
+ portal->here->portals = portal;
+
+ // advance to next portal
+ portal++;
+
+ // then make the front to back portal(backward portal)
+ portal->points = point;
+ portal->numpoints = p->numpoints;
+ portal->plane.dist = -p->plane.dist;
+ VectorNegate(p->plane.normal, portal->plane.normal);
+ portal->here = (mleaf_t *)p->nodes[0];
+ portal->past = (mleaf_t *)p->nodes[1];
+ // copy points
+ for (j = portal->numpoints - 1;j >= 0;j--)
+ {
+ VectorCopy(p->points + j*3, point->position);
+ point++;
+ }
+ BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
+ PlaneClassify(&portal->plane);
+
+ // link into leaf's portal chain
+ portal->next = portal->here->portals;
+ portal->here->portals = portal;
+
+ // advance to next portal
+ portal++;
}
- BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
- PlaneClassify(&portal->plane);
-
- // link into leaf's portal chain
- portal->next = portal->here->portals;
- portal->here->portals = portal;
-
- // advance to next portal
- portal++;
-
- // then make the front to back portal(backward portal)
- portal->points = point;
- portal->numpoints = p->numpoints;
- portal->plane.dist = -p->plane.dist;
- VectorNegate(p->plane.normal, portal->plane.normal);
- portal->here = (mleaf_t *)p->nodes[0];
- portal->past = (mleaf_t *)p->nodes[1];
- // copy points
- for (j = portal->numpoints - 1;j >= 0;j--)
+ // add the portal's polygon points to the leaf bounding boxes
+ for (i = 0;i < 2;i++)
{
- VectorCopy(p->points + j*3, point->position);
- point++;
+ leaf = (mleaf_t *)p->nodes[i];
+ for (j = 0;j < p->numpoints;j++)
+ {
+ if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0];
+ if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1];
+ if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2];
+ if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0];
+ if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1];
+ if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2];
+ }
}
- BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
- PlaneClassify(&portal->plane);
-
- // link into leaf's portal chain
- portal->next = portal->here->portals;
- portal->here->portals = portal;
-
- // advance to next portal
- portal++;
}
FreePortal(p);
p = pnext;
}
+ // now recalculate the node bounding boxes from the leafs
+ Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes);
}
/*
portalpointer = (void **) &node->portals;
while (1)
{
- t = *portalpointer;
+ t = (portal_t *)*portalpointer;
if (!t)
Host_Error("RemovePortalFromNodes: portal not in leaf");
}
if (!totalcount)
return;
- model->brushq1.light_style = Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(qbyte));
- model->brushq1.light_stylevalue = Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(int));
- model->brushq1.light_styleupdatechains = Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(msurface_t **));
- model->brushq1.light_styleupdatechainsbuffer = Mem_Alloc(mempool, totalcount * sizeof(msurface_t *));
+ model->brushq1.light_style = (unsigned char *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(unsigned char));
+ model->brushq1.light_stylevalue = (int *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(int));
+ model->brushq1.light_styleupdatechains = (msurface_t ***)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(msurface_t **));
+ model->brushq1.light_styleupdatechainsbuffer = (msurface_t **)Mem_Alloc(mempool, totalcount * sizeof(msurface_t *));
model->brushq1.light_styles = 0;
for (i = 0;i < 255;i++)
if (stylecounts[i])
//Returns PVS data for a given point
//(note: can return NULL)
-static qbyte *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
+static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
{
mnode_t *node;
- Mod_CheckLoaded(model);
node = model->brush.data_nodes;
while (node->plane)
node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
return NULL;
}
-static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbytes, mnode_t *node)
+static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node)
{
while (node->plane)
{
if (((mleaf_t *)node)->clusterindex >= 0)
{
int i;
- qbyte *pvs = model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
+ unsigned char *pvs = model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
for (i = 0;i < pvsbytes;i++)
pvsbuffer[i] |= pvs[i];
}
//Calculates a PVS that is the inclusive or of all leafs within radius pixels
//of the given point.
-static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbufferlength)
+static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength)
{
int bytes = model->brush.num_pvsclusterbytes;
bytes = min(bytes, pvsbufferlength);
if (!memcmp (buffer, "MCBSPpad", 8))
{
- qbyte *index;
+ unsigned char *index;
mod->brush.ismcbsp = true;
mod->brush.ishlbsp = false;
- mod_base = (qbyte*)buffer;
+ mod_base = (unsigned char*)buffer;
index = mod_base;
index += 8;
}
// read lumps
- mod_base = (qbyte*)buffer;
+ mod_base = (unsigned char*)buffer;
for (i = 0; i < HEADER_LUMPS; i++)
{
header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS;
mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
+ mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
mod->brush.LightPoint = Mod_Q1BSP_LightPoint;
mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
if (loadmodel->brush.numsubmodels)
- loadmodel->brush.submodels = Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
+ loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
if (loadmodel->isworldmodel)
{
mod->nummodelsurfaces = bm->numfaces;
// make the model surface list (used by shadowing/lighting)
- mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+ mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
for (j = 0;j < mod->nummodelsurfaces;j++)
mod->surfacelist[j] = mod->firstmodelsurface + j;
mod->brush.BoxTouchingPVS = NULL;
mod->brush.BoxTouchingLeafPVS = NULL;
mod->brush.BoxTouchingVisibleLeafs = NULL;
+ mod->brush.FindBoxClusters = NULL;
mod->brush.LightPoint = NULL;
mod->brush.AmbientSoundLevelsForPoint = NULL;
}
Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
}
- mod_base = (qbyte *)header;
+ mod_base = (unsigned char *)header;
// swap all the lumps
for (i = 0;i < (int) sizeof(*header) / 4;i++)
loadmodel->brushq3.num_lightgrid_cellsize[2] = 128;
if (!l->filelen)
return;
- loadmodel->brush.entities = Mem_Alloc(loadmodel->mempool, l->filelen);
+ loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
data = loadmodel->brush.entities;
// some Q3 maps override the lightgrid_cellsize with a worldspawn key
char firstpasstexturename[Q3PATHLENGTH];
char parameter[4][Q3PATHLENGTH];
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dtexture_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadTextures: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (texture_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->data_textures = out;
loadmodel->num_textures = count;
{
for (i = 0;i < search->numfilenames;i++)
{
- if ((f = FS_LoadFile(search->filenames[i], tempmempool, false)))
+ if ((f = (char *)FS_LoadFile(search->filenames[i], tempmempool, false)))
{
text = f;
while (COM_ParseToken(&text, false))
mplane_t *out;
int i, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dplane_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadPlanes: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (mplane_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brush.data_planes = out;
loadmodel->brush.num_planes = count;
q3mbrushside_t *out;
int i, n, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dbrushside_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadBrushSides: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brush.data_brushsides = out;
loadmodel->brush.num_brushsides = count;
int i, j, n, c, count, maxplanes;
mplane_t *planes;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dbrush_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadBrushes: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (q3mbrush_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brush.data_brushes = out;
loadmodel->brush.num_brushes = count;
maxplanes = out->numbrushsides;
if (planes)
Mem_Free(planes);
- planes = Mem_Alloc(tempmempool, sizeof(mplane_t) * maxplanes);
+ planes = (mplane_t *)Mem_Alloc(tempmempool, sizeof(mplane_t) * maxplanes);
}
for (j = 0;j < out->numbrushsides;j++)
{
q3deffect_t *out;
int i, n, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3deffect_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadEffects: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (q3deffect_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq3.data_effects = out;
loadmodel->brushq3.num_effects = count;
q3dvertex_t *in;
int i, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dvertex_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadVertices: funny lump size in %s",loadmodel->name);
loadmodel->brushq3.num_vertices = count = l->filelen / sizeof(*in);
- loadmodel->brushq3.data_vertex3f = Mem_Alloc(loadmodel->mempool, count * (sizeof(float) * (3 + 2 + 2 + 4)));
+ loadmodel->brushq3.data_vertex3f = (float *)Mem_Alloc(loadmodel->mempool, count * (sizeof(float) * (3 + 2 + 2 + 4)));
loadmodel->brushq3.data_texcoordtexture2f = loadmodel->brushq3.data_vertex3f + count * 3;
loadmodel->brushq3.data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordtexture2f + count * 2;
loadmodel->brushq3.data_color4f = loadmodel->brushq3.data_texcoordlightmap2f + count * 2;
int *out;
int i, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (int *)(mod_base + l->fileofs);
if (l->filelen % sizeof(int[3]))
Host_Error("Mod_Q3BSP_LoadTriangles: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq3.num_triangles = count / 3;
loadmodel->brushq3.data_element3i = out;
if (!l->filelen)
return;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dlightmap_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadLightmaps: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (rtexture_t **)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq3.data_lightmaps = out;
loadmodel->brushq3.num_lightmaps = count;
float *v;
surfmesh_t *mesh, *tempmeshlist[1024];
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dface_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadFaces: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (msurface_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->data_surfaces = out;
loadmodel->num_surfaces = count;
finalvertices = finalwidth * finalheight;
finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
- out->data_collisionvertex3f = Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
- out->data_collisionelement3i = Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
+ out->data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
+ out->data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
out->num_collisionvertices = finalvertices;
out->num_collisiontriangles = finaltriangles;
Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
loadmodel->nummeshes = meshnum;
if (loadmodel->nummeshes)
{
- loadmodel->meshlist = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *) * loadmodel->nummeshes);
+ loadmodel->meshlist = (surfmesh_t **)Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *) * loadmodel->nummeshes);
memcpy(loadmodel->meshlist, tempmeshlist, sizeof(surfmesh_t *) * loadmodel->nummeshes);
}
q3dmodel_t *out;
int i, j, n, c, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dmodel_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadModels: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (q3dmodel_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq3.data_models = out;
loadmodel->brushq3.num_models = count;
int *out;
int i, n, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (int *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadLeafBrushes: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brush.data_leafbrushes = out;
loadmodel->brush.num_leafbrushes = count;
int *out;
int i, n, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (int *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadLeafFaces: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brush.data_leafsurfaces = out;
loadmodel->brush.num_leafsurfaces = count;
mleaf_t *out;
int i, j, n, c, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dleaf_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brush.data_leafs = out;
loadmodel->brush.num_leafs = count;
mnode_t *out;
int i, j, n, count;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dnode_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadNodes: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brush.data_nodes = out;
loadmodel->brush.num_nodes = count;
q3dlightgrid_t *out;
int count;
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dlightgrid_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadLightGrid: funny lump size in %s",loadmodel->name);
loadmodel->brushq3.num_lightgrid_scale[0] = 1.0f / loadmodel->brushq3.num_lightgrid_cellsize[0];
Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)\n", l->filelen, count * sizeof(*in), loadmodel->brushq3.num_lightgrid_dimensions[0], loadmodel->brushq3.num_lightgrid_dimensions[1], loadmodel->brushq3.num_lightgrid_dimensions[2]);
if (l->filelen != count * (int)sizeof(*in))
Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i\n", count * sizeof(*in), l->filelen);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+ out = (q3dlightgrid_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq3.data_lightgrid = out;
loadmodel->brushq3.num_lightgrid = count;
// no swapping or validation necessary
// create clusters
loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters + 7) / 8;
totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
- loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, totalchains);
+ loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
memset(loadmodel->brush.data_pvsclusters, 0xFF, totalchains);
return;
}
- in = (void *)(mod_base + l->fileofs);
+ in = (q3dpvs_t *)(mod_base + l->fileofs);
if (l->filelen < 9)
Host_Error("Mod_Q3BSP_LoadPVS: funny lump size in %s",loadmodel->name);
if (l->filelen < totalchains + (int)sizeof(*in))
Host_Error("Mod_Q3BSP_LoadPVS: lump too small ((numclusters = %i) * (chainlength = %i) + sizeof(q3dpvs_t) == %i bytes, lump is %i bytes)\n", loadmodel->brush.num_pvsclusters, loadmodel->brush.num_pvsclusterbytes, totalchains + sizeof(*in), l->filelen);
- loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, totalchains);
- memcpy(loadmodel->brush.data_pvsclusters, (qbyte *)(in + 1), totalchains);
+ loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
+ memcpy(loadmodel->brush.data_pvsclusters, (unsigned char *)(in + 1), totalchains);
}
static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
{
int i;
- //int sides;
+ int sides;
float nodesegmentmins[3], nodesegmentmaxs[3];
mleaf_t *leaf;
colbrushf_t *brush;
}
*/
#if 1
+ for (;;)
+ {
+ mplane_t *plane = node->plane;
+ if (!plane)
+ break;
+ // axial planes are much more common than non-axial, so an optimized
+ // axial case pays off here
+ if (plane->type < 3)
+ {
+ // this is an axial plane, compare bounding box directly to it and
+ // recurse sides accordingly
+ // recurse down node sides
+ // use an inlined axial BoxOnPlaneSide to slightly reduce overhead
+ //sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, plane);
+ sides = ((segmentmaxs[plane->type] >= plane->dist) | ((segmentmins[plane->type] < plane->dist) << 1));
+ if (sides == 3)
+ {
+ // segment box crosses plane
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ sides = 2;
+ }
+ }
+ else
+ {
+ // this is a non-axial plane, entire trace bounding box
+ // comparisons against it are likely to be very sloppy, so in if
+ // the whole box is split by the plane we then test the start/end
+ // boxes against it to be sure
+ sides = BoxOnPlaneSide(segmentmins, segmentmaxs, plane);
+ if (sides == 3)
+ {
+ // segment box crosses plane
+ // now check start and end brush boxes to handle a lot of 'diagonal' cases more efficiently...
+ sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, plane);
+ if (sides == 3)
+ {
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ sides = 2;
+ }
+ }
+ }
+ // take whichever side the segment box is on
+ node = node->children[sides - 1];
+ }
+ nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
+ nodesegmentmins[1] = max(segmentmins[1], node->mins[1]);
+ nodesegmentmins[2] = max(segmentmins[2], node->mins[2]);
+ nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0]);
+ nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1]);
+ nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2]);
+#elif 1
for (;;)
{
nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS;
mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
+ mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
mod->brush.LightPoint = Mod_Q3BSP_LightPoint;
mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
mod->DrawLight = R_Q1BSP_DrawLight;
- mod_base = (qbyte *)header;
+ mod_base = (unsigned char *)header;
// swap all the lumps
header->ident = LittleLong(header->ident);
mod->brush.BoxTouchingPVS = NULL;
mod->brush.BoxTouchingLeafPVS = NULL;
mod->brush.BoxTouchingVisibleLeafs = NULL;
+ mod->brush.FindBoxClusters = NULL;
mod->brush.LightPoint = NULL;
mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
}
mod->nummodelsurfaces = mod->brushq3.data_models[i].numfaces;
mod->firstmodelbrush = mod->brushq3.data_models[i].firstbrush;
mod->nummodelbrushes = mod->brushq3.data_models[i].numbrushes;
- mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+ mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
for (j = 0;j < mod->nummodelsurfaces;j++)
mod->surfacelist[j] = mod->firstmodelsurface + j;
projects / xonotic / darkplaces.git / blobdiff