#include "wad.h"
-// note: model_shared.c sets up r_notexture, and r_surf_notexture
-
qbyte mod_q1bsp_novis[(MAX_MAP_LEAFS + 7)/ 8];
//cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128"};
{
int clusterindex, side, nodestackindex = 0;
mnode_t *node, *nodestack[1024];
- node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode;
+ if (!model->brush.num_pvsclusters)
+ return true;
+ node = model->brush.data_nodes;
for (;;)
{
if (node->plane)
return false;
}
+static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const qbyte *visibleleafs, const vec3_t mins, const vec3_t maxs)
+{
+ int side, nodestackindex = 0;
+ mnode_t *node, *nodestack[1024];
+ node = model->brush.data_nodes;
+ for (;;)
+ {
+ if (node->plane)
+ {
+ // node - recurse down the BSP tree
+ 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];
+ }
+ }
+ else
+ {
+ // 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;
+ }
+ else
+ {
+ // 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;
+}
+
typedef struct findnonsolidlocationinfo_s
{
vec3_t center;
}
findnonsolidlocationinfo_t;
-#if 0
-extern cvar_t samelevel;
-#endif
static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *info, mleaf_t *leaf)
{
int i, surfacenum, k, *tri, *mark;
float dist, f, vert[3][3], edge[3][3], facenormal[3], edgenormal[3][3], point[3];
-#if 0
- float surfnormal[3];
-#endif
msurface_t *surface;
for (surfacenum = 0, mark = leaf->firstleafsurface;surfacenum < leaf->numleafsurfaces;surfacenum++, mark++)
{
- surface = info->model->brushq1.surfaces + *mark;
- if (surface->flags & SURF_SOLIDCLIP)
+ surface = info->model->brush.data_surfaces + *mark;
+ if (surface->texture->supercontents & SUPERCONTENTS_SOLID)
{
-#if 0
- VectorCopy(surface->plane->normal, surfnormal);
- if (surface->flags & SURF_PLANEBACK)
- VectorNegate(surfnormal, surfnormal);
-#endif
for (k = 0;k < surface->mesh.num_triangles;k++)
{
tri = surface->mesh.data_element3i + k * 3;
if (facenormal[0] || facenormal[1] || facenormal[2])
{
VectorNormalize(facenormal);
-#if 0
- if (VectorDistance(facenormal, surfnormal) > 0.01f)
- Con_Printf("a2! %f %f %f != %f %f %f\n", facenormal[0], facenormal[1], facenormal[2], surfnormal[0], surfnormal[1], surfnormal[2]);
-#endif
f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
if (f <= info->bestdist && f >= -info->bestdist)
{
CrossProduct(facenormal, edge[0], edgenormal[0]);
CrossProduct(facenormal, edge[1], edgenormal[1]);
CrossProduct(facenormal, edge[2], edgenormal[2]);
-#if 0
- if (samelevel.integer & 1)
- VectorNegate(edgenormal[0], edgenormal[0]);
- if (samelevel.integer & 2)
- VectorNegate(edgenormal[1], edgenormal[1]);
- if (samelevel.integer & 4)
- VectorNegate(edgenormal[2], edgenormal[2]);
- for (i = 0;i < 3;i++)
- if (DotProduct(vert[0], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
- || DotProduct(vert[1], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
- || DotProduct(vert[2], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f)
- Con_Printf("a! %i : %f %f %f (%f %f %f)\n", i, edgenormal[i][0], edgenormal[i][1], edgenormal[i][2], facenormal[0], facenormal[1], facenormal[2]);
-#endif
// face distance
if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0])
&& DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1])
int i, ds, dt;
msurface_t *surface;
- surface = r_refdef.worldmodel->brushq1.surfaces + node->firstsurface;
+ surface = r_refdef.worldmodel->brush.data_surfaces + node->firstsurface;
for (i = 0;i < node->numsurfaces;i++, surface++)
{
- if (!(surface->flags & SURF_LIGHTMAP) || !surface->samples)
+ if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->samples)
continue; // no lightmaps
ds = (int) (x * surface->texinfo->vecs[0][0] + y * surface->texinfo->vecs[0][1] + mid * surface->texinfo->vecs[0][2] + surface->texinfo->vecs[0][3]) - surface->texturemins[0];
strcpy(tx->name, "NO TEXTURE FOUND");
tx->width = 16;
tx->height = 16;
- tx->skin.base = r_notexture;
+ tx->skin.base = r_texture_notexture;
if (i == loadmodel->brush.num_textures - 1)
- tx->flags = SURF_DRAWTURB | SURF_LIGHTBOTHSIDES;
+ {
+ tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES;
+ tx->supercontents = SUPERCONTENTS_WATER;
+ }
else
- tx->flags = SURF_LIGHTMAP | SURF_SOLIDCLIP;
+ {
+ tx->basematerialflags |= MATERIALFLAG_WALL;
+ tx->supercontents = SUPERCONTENTS_SOLID;
+ }
+ tx->basematerialflags = 0;
tx->currentframe = tx;
}
}
else
{
- if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true, true))
+ if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, tx->name[0] != '*', true))
{
// did not find external texture, load it from the bsp or wad3
if (loadmodel->brush.ishlbsp)
Mem_Free(freepixels);
}
else if (mtdata) // texture included
- Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_PICMIP, false, true, tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
+ Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_PICMIP, false, tx->name[0] != '*', tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
}
}
if (tx->skin.base == NULL)
// no texture found
tx->width = 16;
tx->height = 16;
- tx->skin.base = r_notexture;
+ tx->skin.base = r_texture_notexture;
}
+ tx->basematerialflags = 0;
if (tx->name[0] == '*')
{
// turb does not block movement
- tx->flags = SURF_DRAWTURB | SURF_LIGHTBOTHSIDES;
+ tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES;
// LordHavoc: some turbulent textures should be fullbright and solid
if (!strncmp(tx->name,"*lava",5)
|| !strncmp(tx->name,"*teleport",9)
|| !strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
- tx->flags |= SURF_DRAWFULLBRIGHT | SURF_DRAWNOALPHA;
+ tx->basematerialflags |= MATERIALFLAG_FULLBRIGHT;
else
- tx->flags |= SURF_WATERALPHA;
+ tx->basematerialflags |= MATERIALFLAG_WATERALPHA;
+ if (!strncmp(tx->name, "*lava", 5))
+ tx->supercontents = SUPERCONTENTS_LAVA;
+ else if (!strncmp(tx->name, "*slime", 6))
+ tx->supercontents = SUPERCONTENTS_SLIME;
+ else
+ tx->supercontents = SUPERCONTENTS_WATER;
}
else if (tx->name[0] == 's' && tx->name[1] == 'k' && tx->name[2] == 'y')
- tx->flags = SURF_DRAWSKY | SURF_SOLIDCLIP;
+ {
+ tx->supercontents = SUPERCONTENTS_SKY;
+ tx->basematerialflags |= MATERIALFLAG_SKY;
+ }
else
- tx->flags = SURF_LIGHTMAP | SURF_SOLIDCLIP;
+ {
+ tx->supercontents = SUPERCONTENTS_SOLID;
+ tx->basematerialflags |= MATERIALFLAG_WALL;
+ }
+ if (tx->skin.fog)
+ tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_TRANSPARENT;
// start out with no animation
tx->currentframe = tx;
{
// if texture chosen is NULL or the shader needs a lightmap,
// force to notexture water shader
- if (out->texture == NULL || out->texture->flags & SURF_LIGHTMAP)
+ if (out->texture == NULL || out->texture->basematerialflags & MATERIALFLAG_WALL)
out->texture = loadmodel->brush.data_textures + (loadmodel->brush.num_textures - 1);
}
else
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadFaces: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- loadmodel->brushq1.surfaces = Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
+ loadmodel->brush.data_surfaces = Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
- loadmodel->brushq1.numsurfaces = count;
+ loadmodel->brush.num_surfaces = count;
totalverts = 0;
totaltris = 0;
totalverts = 0;
totaltris = 0;
- for (surfacenum = 0, in = (void *)(mod_base + l->fileofs), surface = loadmodel->brushq1.surfaces;surfacenum < count;surfacenum++, in++, surface++)
+ for (surfacenum = 0, in = (void *)(mod_base + l->fileofs), surface = loadmodel->brush.data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
{
- surface->number = surfacenum;
// FIXME: validate edges, texinfo, etc?
firstedge = LittleLong(in->firstedge);
numedges = LittleShort(in->numedges);
if ((unsigned int) i >= (unsigned int) loadmodel->brushq1.numtexinfo)
Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)\n", i, loadmodel->brushq1.numtexinfo);
surface->texinfo = loadmodel->brushq1.texinfo + i;
- surface->flags = surface->texinfo->texture->flags;
+ surface->texture = surface->texinfo->texture;
planenum = LittleShort(in->planenum);
if ((unsigned int) planenum >= (unsigned int) loadmodel->brush.num_planes)
Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)\n", planenum, loadmodel->brush.num_planes);
- if (LittleShort(in->side))
- surface->flags |= SURF_PLANEBACK;
-
- surface->plane = loadmodel->brush.data_planes + planenum;
+ //surface->flags = surface->texture->flags;
+ //if (LittleShort(in->side))
+ // surface->flags |= SURF_PLANEBACK;
+ //surface->plane = loadmodel->brush.data_planes + planenum;
surface->mesh.num_vertices = numedges;
surface->mesh.num_triangles = numedges - 2;
VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[-lindex].v[1]].position, surface->mesh.data_vertex3f + i * 3);
s = DotProduct((surface->mesh.data_vertex3f + i * 3), surface->texinfo->vecs[0]) + surface->texinfo->vecs[0][3];
t = DotProduct((surface->mesh.data_vertex3f + i * 3), surface->texinfo->vecs[1]) + surface->texinfo->vecs[1][3];
- surface->mesh.data_texcoordtexture2f[i * 2 + 0] = s / surface->texinfo->texture->width;
- surface->mesh.data_texcoordtexture2f[i * 2 + 1] = t / surface->texinfo->texture->height;
+ surface->mesh.data_texcoordtexture2f[i * 2 + 0] = s / surface->texture->width;
+ surface->mesh.data_texcoordtexture2f[i * 2 + 1] = t / surface->texture->height;
surface->mesh.data_texcoorddetail2f[i * 2 + 0] = s * (1.0f / 16.0f);
surface->mesh.data_texcoorddetail2f[i * 2 + 1] = t * (1.0f / 16.0f);
surface->mesh.data_texcoordlightmap2f[i * 2 + 0] = 0;
surface->lightmaptexture = NULL;
i = LittleLong(in->lightofs);
if (i == -1)
+ {
surface->samples = NULL;
+ // give non-lightmapped water a 1x white lightmap
+ if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
+ {
+ surface->samples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+ surface->styles[0] = 0;
+ memset(surface->samples, 128, ssize * tsize * 3);
+ }
+ }
else if (loadmodel->brush.ishlbsp) // LordHavoc: HalfLife map (bsp version 30)
surface->samples = loadmodel->brushq1.lightdata + i;
else // LordHavoc: white lighting (bsp version 29)
surface->samples = loadmodel->brushq1.lightdata + (i * 3);
- if (surface->texinfo->texture->flags & SURF_LIGHTMAP)
+ if (!(surface->texinfo->flags & TEX_SPECIAL) || surface->samples)
{
+ int i, iu, iv;
+ float u, v, ubase, vbase, uscale, vscale;
+
if (ssize > 256 || tsize > 256)
Host_Error("Bad surface extents");
// stainmap for permanent marks on walls
surface->stainsamples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
// clear to white
memset(surface->stainsamples, 255, ssize * tsize * 3);
- }
-
- if (surface->texinfo->texture->flags & SURF_LIGHTMAP)
- {
- int i, iu, iv;
- float u, v, ubase, vbase, uscale, vscale;
if (r_miplightmaps.integer)
{
}
}
-static void Mod_Q1BSP_SetParent(mnode_t *node, mnode_t *parent)
+static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
{
+ //if (node->parent)
+ // Host_Error("Mod_Q1BSP_LoadNodes_RecursiveSetParent: runaway recursion\n");
node->parent = parent;
if (node->plane)
{
- Mod_Q1BSP_SetParent(node->children[0], node);
- Mod_Q1BSP_SetParent(node->children[1], node);
+ Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[0], node);
+ Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[1], node);
}
}
}
}
- Mod_Q1BSP_SetParent(loadmodel->brush.data_nodes, NULL); // sets nodes and leafs
+ Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL); // sets nodes and leafs
}
static void Mod_Q1BSP_LoadLeafs(lump_t *l)
for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++)
{
j = (unsigned) LittleShort(in[i]);
- if (j >= loadmodel->brushq1.numsurfaces)
+ if (j >= loadmodel->brush.num_surfaces)
Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number");
loadmodel->brush.data_leafsurfaces[i] = j;
}
memset(stylecounts, 0, sizeof(stylecounts));
for (i = 0;i < model->nummodelsurfaces;i++)
{
- surface = model->brushq1.surfaces + model->firstmodelsurface + i;
+ surface = model->brush.data_surfaces + model->firstmodelsurface + i;
for (j = 0;j < MAXLIGHTMAPS;j++)
stylecounts[surface->styles[j]]++;
}
}
for (i = 0;i < model->nummodelsurfaces;i++)
{
- surface = model->brushq1.surfaces + model->firstmodelsurface + i;
+ surface = model->brush.data_surfaces + model->firstmodelsurface + i;
for (j = 0;j < MAXLIGHTMAPS;j++)
if (surface->styles[j] != 255)
*model->brushq1.light_styleupdatechains[remapstyles[surface->styles[j]]]++ = surface;
//of the given point.
static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbufferlength)
{
- int bytes = ((model->brush.num_leafs - 1) + 7) >> 3;
+ int bytes = model->brush.num_pvsclusterbytes;
bytes = min(bytes, pvsbufferlength);
- if (r_novis.integer || !Mod_Q1BSP_GetPVS(model, org))
+ if (r_novis.integer || !model->brush.num_pvsclusters || !Mod_Q1BSP_GetPVS(model, org))
{
memset(pvsbuffer, 0xFF, bytes);
return bytes;
VectorAdd(inmins, hull->clip_size, outmaxs);
}
-/*
-void Mod_Q1BSP_RecursiveGetVisible(mnode_t *node, model_t *model, const vec3_t point, const vec3_t mins, const vec3_t maxs, int maxleafs, mleaf_t *leaflist, int *numleafs, int maxsurfaces, msurface_t *surfacelist, int *numsurfaces, const qbyte *pvs)
-{
- mleaf_t *leaf;
- for (;;)
- {
- if (!BoxesOverlap(node->mins, node->maxs, mins, maxs))
- return;
- if (!node->plane)
- break;
- Mod_Q1BSP_RecursiveGetVisible(node->children[0], model, point, mins, maxs, maxleafs, leaflist, numleafs, maxsurfaces, surfacelist, numsurfaces, pvs);
- node = node->children[1];
- }
- leaf = (mleaf_t *)node;
- if ((pvs == NULL || CHECKPVSBIT(pvs, leaf->clusterindex)))
- {
- int leafsurfacenum;
- msurface_t *surface;
- if (maxleafs && *numleafs < maxleafs)
- leaflist[(*numleafs)++] = leaf;
- if (maxsurfaces)
- {
- for (leafsurfacenum = 0;leafsurfacenum < leaf->numleafsurfaces;leafsurfacenum++)
- {
- surface = model->brushq1.surfaces + leaf->firstleafsurface[leafsurfacenum];
- if (surface->shadowmark != shadowmarkcount)
- {
- surface->shadowmark = shadowmarkcount;
- if (BoxesOverlap(mins, maxs, surface->mins, surface->maxs) && ((surface->flags & SURF_PLANEBACK) ? PlaneDiff(point, surface->plane) < 0 : PlaneDiff(point, surface->plane) > 0) && *numsurfaces < maxsurfaces)
- surfacelist[(*numsurfaces)++] = surface;
- }
- }
- }
- }
-}
-
-void Mod_Q1BSP_GetVisible(model_t *model, const vec3_t point, const vec3_t mins, const vec3_t maxs, int maxleafs, mleaf_t *leaflist, int *numleafs, int maxsurfaces, msurface_t *surfacelist, int *numsurfaces)
-{
- // FIXME: support portals
- if (maxsurfaces)
- *numsurfaces = 0;
- if (maxleafs)
- *numleafs = 0;
- pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin);
- Mod_Q1BSP_RecursiveGetVisible(ent->model->brush.data_nodes + ent->model->brushq1.firstclipnode, model, point, mins, maxs, maxleafs, leaflist, numleafs, maxsurfaces, surfacelist, numsurfaces);
-}
-*/
-
extern void R_Q1BSP_DrawSky(entity_render_t *ent);
extern void R_Q1BSP_Draw(entity_render_t *ent);
extern void R_Q1BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer);
-extern void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist);
+extern void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist, const vec3_t lightmins, const vec3_t lightmaxs);
extern void R_Q1BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int numsurfaces, const int *surfacelist);
void Mod_Q1BSP_Load(model_t *mod, void *buffer)
{
mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
mod->brush.FatPVS = Mod_Q1BSP_FatPVS;
mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
+ mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
mod->brush.LightPoint = Mod_Q1BSP_LightPoint;
mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
// make a single combined shadow mesh to allow optimized shadow volume creation
numshadowmeshtriangles = 0;
- for (j = 0, surface = loadmodel->brushq1.surfaces;j < loadmodel->brushq1.numsurfaces;j++, surface++)
+ for (j = 0, surface = loadmodel->brush.data_surfaces;j < loadmodel->brush.num_surfaces;j++, surface++)
{
surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
numshadowmeshtriangles += surface->mesh.num_triangles;
}
loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
- for (j = 0, surface = loadmodel->brushq1.surfaces;j < loadmodel->brushq1.numsurfaces;j++, surface++)
+ for (j = 0, surface = loadmodel->brush.data_surfaces;j < loadmodel->brush.num_surfaces;j++, surface++)
Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, surface->mesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->mesh.num_triangles, surface->mesh.data_element3i);
loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true);
Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
mod->brush.GetPVS = NULL;
mod->brush.FatPVS = NULL;
mod->brush.BoxTouchingPVS = NULL;
+ mod->brush.BoxTouchingVisibleLeafs = NULL;
mod->brush.LightPoint = NULL;
mod->brush.AmbientSoundLevelsForPoint = NULL;
}
mod->normalmaxs[0] = mod->normalmaxs[1] = mod->normalmaxs[2] = -1000000000.0f;
modelyawradius = 0;
modelradius = 0;
- for (j = 0, surface = &mod->brushq1.surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++)
+ for (j = 0, surface = &mod->brush.data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++)
{
// we only need to have a drawsky function if it is used(usually only on world model)
- if (surface->texinfo->texture->flags & SURF_DRAWSKY)
+ if (surface->texture->basematerialflags & MATERIALFLAG_SKY)
mod->DrawSky = R_Q1BSP_DrawSky;
- // LordHavoc: submodels always clip, even if water
- if (mod->brush.numsubmodels - 1)
- surface->flags |= SURF_SOLIDCLIP;
// calculate bounding shapes
for (k = 0, vec = surface->mesh.data_vertex3f;k < surface->mesh.num_vertices;k++, vec += 3)
{
//Mod_Q1BSP_ProcessLightList();
if (developer.integer)
- Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->brushq1.numsurfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brushq1.submodels[i].visleafs, loadmodel->brush.num_portals);
+ Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->brush.num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brushq1.submodels[i].visleafs, loadmodel->brush.num_portals);
}
static void Mod_Q2BSP_LoadEntities(lump_t *l)
{
out->surfaceparms = flags;
out->textureflags = flags2;
+ out->basematerialflags = 0;
+ if (out->surfaceparms & Q3SURFACEPARM_NODRAW)
+ out->basematerialflags |= MATERIALFLAG_NODRAW;
+ else if (out->surfaceparms & Q3SURFACEPARM_SKY)
+ out->basematerialflags |= MATERIALFLAG_SKY;
+ else if (out->surfaceparms & (Q3SURFACEPARM_WATER | Q3SURFACEPARM_SLIME | Q3SURFACEPARM_LAVA))
+ out->basematerialflags |= MATERIALFLAG_WATER;
+ else
+ out->basematerialflags |= MATERIALFLAG_WALL;
+ if (out->surfaceparms & (Q3SURFACEPARM_SLIME | Q3SURFACEPARM_WATER))
+ out->basematerialflags |= MATERIALFLAG_WATERALPHA;
strlcpy(out->firstpasstexturename, firstpasstexturename, sizeof(out->firstpasstexturename));
if ((flags & Q3SURFACEPARM_SKY) && sky[0])
{
c++;
Con_DPrintf("%s: No shader found for texture \"%s\"\n", loadmodel->name, out->name);
out->surfaceparms = 0;
+ if (out->surfaceflags & Q3SURFACEFLAG_NODRAW)
+ out->basematerialflags |= MATERIALFLAG_NODRAW;
+ else if (out->surfaceflags & Q3SURFACEFLAG_SKY)
+ out->basematerialflags |= MATERIALFLAG_SKY;
+ else
+ out->basematerialflags |= MATERIALFLAG_WALL;
// these are defaults
//if (!strncmp(out->name, "textures/skies/", 15))
// out->surfaceparms |= Q3SURFACEPARM_SKY;
//if (R_TextureHasAlpha(out->skin.base))
// out->surfaceparms |= Q3SURFACEPARM_TRANS;
}
- if (!Mod_LoadSkinFrame(&out->skin, out->name, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, true, true))
- if (!Mod_LoadSkinFrame(&out->skin, out->firstpasstexturename, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, true, true))
+ if (!Mod_LoadSkinFrame(&out->skin, out->name, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, false, true))
+ if (!Mod_LoadSkinFrame(&out->skin, out->firstpasstexturename, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, false, true))
Con_Printf("%s: texture loading for shader \"%s\" failed (first layer \"%s\" not found either)\n", loadmodel->name, out->name, out->firstpasstexturename);
+ if (out->skin.fog)
+ out->basematerialflags |= (MATERIALFLAG_ALPHA | MATERIALFLAG_TRANSPARENT);
+ // no animation
+ out->currentframe = out;
}
if (c)
Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_brushsides = out;
- loadmodel->brushq3.num_brushsides = count;
+ loadmodel->brush.data_brushsides = out;
+ loadmodel->brush.num_brushsides = count;
for (i = 0;i < count;i++, in++, out++)
{
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_brushes = out;
- loadmodel->brushq3.num_brushes = count;
+ loadmodel->brush.data_brushes = out;
+ loadmodel->brush.num_brushes = count;
maxplanes = 0;
planes = NULL;
{
n = LittleLong(in->firstbrushside);
c = LittleLong(in->numbrushsides);
- if (n < 0 || n + c > loadmodel->brushq3.num_brushsides)
- Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)\n", n, n + c, loadmodel->brushq3.num_brushsides);
- out->firstbrushside = loadmodel->brushq3.data_brushsides + n;
+ if (n < 0 || n + c > loadmodel->brush.num_brushsides)
+ Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)\n", n, n + c, loadmodel->brush.num_brushsides);
+ out->firstbrushside = loadmodel->brush.data_brushsides + n;
out->numbrushsides = c;
n = LittleLong(in->textureindex);
if (n < 0 || n >= loadmodel->brush.num_textures)
static void Mod_Q3BSP_LoadEffects(lump_t *l)
{
q3deffect_t *in;
- q3meffect_t *out;
+ q3deffect_t *out;
int i, n, count;
in = (void *)(mod_base + l->fileofs);
{
strlcpy (out->shadername, in->shadername, sizeof (out->shadername));
n = LittleLong(in->brushindex);
- if (n < 0 || n >= loadmodel->brushq3.num_brushes)
- Host_Error("Mod_Q3BSP_LoadEffects: invalid brushindex %i (%i brushes)\n", n, loadmodel->brushq3.num_brushes);
- out->brush = loadmodel->brushq3.data_brushes + n;
+ if (n < 0 || n >= loadmodel->brush.num_brushes)
+ Host_Error("Mod_Q3BSP_LoadEffects: invalid brushindex %i (%i brushes)\n", n, loadmodel->brush.num_brushes);
+ out->brushindex = n;
out->unknown = LittleLong(in->unknown);
}
}
static void Mod_Q3BSP_LoadFaces(lump_t *l)
{
q3dface_t *in, *oldin;
- q3msurface_t *out, *oldout;
+ msurface_t *out, *oldout;
int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshnum, meshvertices, meshtriangles, numvertices, numtriangles;
//int *originalelement3i;
//int *originalneighbor3i;
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_faces = out;
- loadmodel->brushq3.num_faces = count;
+ loadmodel->brush.data_surfaces = out;
+ loadmodel->brush.num_surfaces = count;
i = 0;
for (meshnum = 0;i < count;meshnum++)
out->maxs[1] += 1.0f;
out->maxs[2] += 1.0f;
}
+ // set lightmap styles for consistency with q1bsp
+ out->styles[0] = 0;
+ out->styles[1] = 255;
+ out->styles[2] = 255;
+ out->styles[3] = 255;
}
}
static void Mod_Q3BSP_LoadModels(lump_t *l)
{
q3dmodel_t *in;
- q3mmodel_t *out;
+ q3dmodel_t *out;
int i, j, n, c, count;
in = (void *)(mod_base + l->fileofs);
}
n = LittleLong(in->firstface);
c = LittleLong(in->numfaces);
- if (n < 0 || n + c > loadmodel->brushq3.num_faces)
- Host_Error("Mod_Q3BSP_LoadModels: invalid face range %i : %i (%i faces)\n", n, n + c, loadmodel->brushq3.num_faces);
- out->firstsurface = loadmodel->brushq3.data_faces + n;
- out->numsurfaces = c;
+ if (n < 0 || n + c > loadmodel->brush.num_surfaces)
+ Host_Error("Mod_Q3BSP_LoadModels: invalid face range %i : %i (%i faces)\n", n, n + c, loadmodel->brush.num_surfaces);
+ out->firstface = n;
+ out->numfaces = c;
n = LittleLong(in->firstbrush);
c = LittleLong(in->numbrushes);
- if (n < 0 || n + c > loadmodel->brushq3.num_brushes)
- Host_Error("Mod_Q3BSP_LoadModels: invalid brush range %i : %i (%i brushes)\n", n, n + c, loadmodel->brushq3.num_brushes);
- out->firstbrush = loadmodel->brushq3.data_brushes + n;
+ if (n < 0 || n + c > loadmodel->brush.num_brushes)
+ Host_Error("Mod_Q3BSP_LoadModels: invalid brush range %i : %i (%i brushes)\n", n, n + c, loadmodel->brush.num_brushes);
+ out->firstbrush = n;
out->numbrushes = c;
}
}
for (i = 0;i < count;i++, in++, out++)
{
n = LittleLong(*in);
- if (n < 0 || n >= loadmodel->brushq3.num_brushes)
- Host_Error("Mod_Q3BSP_LoadLeafBrushes: invalid brush index %i (%i brushes)\n", n, loadmodel->brushq3.num_brushes);
+ if (n < 0 || n >= loadmodel->brush.num_brushes)
+ Host_Error("Mod_Q3BSP_LoadLeafBrushes: invalid brush index %i (%i brushes)\n", n, loadmodel->brush.num_brushes);
*out = n;
}
}
for (i = 0;i < count;i++, in++, out++)
{
n = LittleLong(*in);
- if (n < 0 || n >= loadmodel->brushq3.num_faces)
- Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)\n", n, loadmodel->brushq3.num_faces);
+ if (n < 0 || n >= loadmodel->brush.num_surfaces)
+ Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)\n", n, loadmodel->brush.num_surfaces);
*out = n;
}
}
}
}
-static void Mod_Q3BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
-{
- if (node->parent)
- Host_Error("Mod_Q3BSP_LoadNodes_RecursiveSetParent: runaway recursion\n");
- node->parent = parent;
- if (node->plane)
- {
- Mod_Q3BSP_LoadNodes_RecursiveSetParent(node->children[0], node);
- Mod_Q3BSP_LoadNodes_RecursiveSetParent(node->children[1], node);
- }
-}
-
static void Mod_Q3BSP_LoadNodes(lump_t *l)
{
q3dnode_t *in;
}
// set the parent pointers
- Mod_Q3BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL);
+ Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL);
}
static void Mod_Q3BSP_LoadLightGrid(lump_t *l)
memcpy(loadmodel->brush.data_pvsclusters, (qbyte *)(in + 1), totalchains);
}
-static void Mod_Q3BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, vec_t radius)
-{
- // FIXME: finish this code
- VectorCopy(in, out);
-}
-
static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
{
int i, j, k, index[3];
leaf = (mleaf_t *)node;
for (i = 0;i < leaf->numleafbrushes;i++)
{
- brush = model->brushq3.data_brushes[leaf->firstleafbrush[i]].colbrushf;
+ brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
if (brush && brush->markframe != markframe && BoxesOverlap(point, point, brush->mins, brush->maxs))
{
brush->markframe = markframe;
int i, startside, endside;
float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
mleaf_t *leaf;
- q3msurface_t *surface;
+ msurface_t *surface;
colbrushf_t *brush;
if (startfrac > trace->realfraction)
return;
leaf = (mleaf_t *)node;
for (i = 0;i < leaf->numleafbrushes;i++)
{
- brush = model->brushq3.data_brushes[leaf->firstleafbrush[i]].colbrushf;
+ brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
{
brush->markframe = markframe;
// line trace the curves
for (i = 0;i < leaf->numleafsurfaces;i++)
{
- surface = model->brushq3.data_faces + leaf->firstleafsurface[i];
+ surface = model->brush.data_surfaces + leaf->firstleafsurface[i];
if (surface->mesh.num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
{
surface->collisionmarkframe = markframe;
float nodesegmentmins[3], nodesegmentmaxs[3];
mleaf_t *leaf;
colbrushf_t *brush;
- q3msurface_t *surface;
+ msurface_t *surface;
/*
// find which nodes the line is in and recurse for them
while (node->plane)
leaf = (mleaf_t *)node;
for (i = 0;i < leaf->numleafbrushes;i++)
{
- brush = model->brushq3.data_brushes[leaf->firstleafbrush[i]].colbrushf;
+ brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
{
brush->markframe = markframe;
{
for (i = 0;i < leaf->numleafsurfaces;i++)
{
- surface = model->brushq3.data_faces + leaf->firstleafsurface[i];
+ surface = model->brush.data_surfaces + leaf->firstleafsurface[i];
if (surface->mesh.num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
{
surface->collisionmarkframe = markframe;
colbrushf_t *thisbrush_start, *thisbrush_end;
matrix4x4_t startmatrix, endmatrix;
static int markframe = 0;
- q3msurface_t *surface;
+ msurface_t *surface;
+ q3mbrush_t *brush;
memset(trace, 0, sizeof(*trace));
trace->fraction = 1;
trace->realfraction = 1;
// point trace
if (model->brush.submodel)
{
- for (i = 0;i < model->brushq3.data_models[model->brush.submodel].numbrushes;i++)
- if (model->brushq3.data_models[model->brush.submodel].firstbrush[i].colbrushf)
- Collision_TracePointBrushFloat(trace, boxstartmins, model->brushq3.data_models[model->brush.submodel].firstbrush[i].colbrushf);
+ for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+ if (brush->colbrushf)
+ Collision_TracePointBrushFloat(trace, boxstartmins, brush->colbrushf);
}
else
Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, boxstartmins, ++markframe);
// line trace
if (model->brush.submodel)
{
- for (i = 0;i < model->brushq3.data_models[model->brush.submodel].numbrushes;i++)
- if (model->brushq3.data_models[model->brush.submodel].firstbrush[i].colbrushf)
- Collision_TraceLineBrushFloat(trace, boxstartmins, boxendmins, model->brushq3.data_models[model->brush.submodel].firstbrush[i].colbrushf, model->brushq3.data_models[model->brush.submodel].firstbrush[i].colbrushf);
+ for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+ if (brush->colbrushf)
+ Collision_TraceLineBrushFloat(trace, boxstartmins, boxendmins, brush->colbrushf, brush->colbrushf);
if (mod_q3bsp_curves_collisions.integer)
- {
- for (i = 0;i < model->brushq3.data_models[model->brush.submodel].numsurfaces;i++)
- {
- surface = model->brushq3.data_models[model->brush.submodel].firstsurface + i;
+ for (i = 0, surface = model->brush.data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
if (surface->mesh.num_collisiontriangles)
Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, surface->mesh.num_collisiontriangles, surface->mesh.data_collisionelement3i, surface->mesh.data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
- }
- }
}
else
Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, boxstartmins, boxendmins, 0, 1, boxstartmins, boxendmins, ++markframe, segmentmins, segmentmaxs);
thisbrush_end = Collision_BrushForBox(&endmatrix, boxendmins, boxendmaxs);
if (model->brush.submodel)
{
- for (i = 0;i < model->brushq3.data_models[model->brush.submodel].numbrushes;i++)
- if (model->brushq3.data_models[model->brush.submodel].firstbrush[i].colbrushf)
- Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, model->brushq3.data_models[model->brush.submodel].firstbrush[i].colbrushf, model->brushq3.data_models[model->brush.submodel].firstbrush[i].colbrushf);
+ for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+ if (brush->colbrushf)
+ Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush->colbrushf, brush->colbrushf);
if (mod_q3bsp_curves_collisions.integer)
- {
- for (i = 0;i < model->brushq3.data_models[model->brush.submodel].numsurfaces;i++)
- {
- surface = model->brushq3.data_models[model->brush.submodel].firstsurface + i;
+ for (i = 0, surface = model->brush.data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
if (surface->mesh.num_collisiontriangles)
Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->mesh.num_collisiontriangles, surface->mesh.data_collisionelement3i, surface->mesh.data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
- }
- }
}
else
Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs);
}
}
-static int Mod_Q3BSP_BoxTouchingPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
-{
- int clusterindex, side, nodestackindex = 0;
- mnode_t *node, *nodestack[1024];
- node = model->brush.data_nodes;
- if (!model->brush.num_pvsclusters)
- return true;
- for (;;)
- {
- if (node->plane)
- {
- // node - recurse down the BSP tree
- 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];
- }
- }
- else
- {
- // leaf - check cluster bit
- clusterindex = ((mleaf_t *)node)->clusterindex;
-#if 0
- if (clusterindex >= model->brush.num_pvsclusters)
- {
- Con_Printf("%i >= %i\n", clusterindex, model->brush.num_pvsclusters);
- return true;
- }
-#endif
- if (CHECKPVSBIT(pvs, clusterindex))
- {
- // it is visible, return immediately with the news
- return true;
- }
- else
- {
- // 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;
-}
-
-//Returns PVS data for a given point
-//(note: can return NULL)
-static qbyte *Mod_Q3BSP_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];
- if (((mleaf_t *)node)->clusterindex >= 0)
- return model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
- else
- return NULL;
-}
-
-static void Mod_Q3BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbytes, mnode_t *node)
-{
- while (node->plane)
- {
- float d = PlaneDiff(org, node->plane);
- if (d > radius)
- node = node->children[0];
- else if (d < -radius)
- node = node->children[1];
- else
- {
- // go down both sides
- Mod_Q3BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, pvsbytes, node->children[0]);
- node = node->children[1];
- }
- }
- // if this leaf is in a cluster, accumulate the pvs bits
- if (((mleaf_t *)node)->clusterindex >= 0)
- {
- int i;
- qbyte *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_Q3BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbufferlength)
-{
- int bytes = model->brush.num_pvsclusterbytes;
- bytes = min(bytes, pvsbufferlength);
- if (r_novis.integer || !model->brush.num_pvsclusters || !Mod_Q3BSP_GetPVS(model, org))
- {
- memset(pvsbuffer, 0xFF, bytes);
- return bytes;
- }
- memset(pvsbuffer, 0, bytes);
- Mod_Q3BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brush.data_nodes);
- return bytes;
-}
-
-
static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
{
int supercontents = 0;
loadmodel->brush.num_leafs = numleafs;
}
-extern void R_Q3BSP_DrawSky(struct entity_render_s *ent);
-extern void R_Q3BSP_Draw(struct entity_render_s *ent);
-extern void R_Q3BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer);
-extern void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist);
-extern void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int numsurfaces, const int *surfacelist);
void Mod_Q3BSP_Load(model_t *mod, void *buffer)
{
int i, j, numshadowmeshtriangles;
q3dheader_t *header;
float corner[3], yawradius, modelradius;
- q3msurface_t *surface;
+ msurface_t *surface;
mod->type = mod_brushq3;
mod->numframes = 2; // although alternate textures are not supported it is annoying to complain about no such frame 1
mod->TraceBox = Mod_Q3BSP_TraceBox;
mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents;
mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents;
- mod->brush.GetPVS = Mod_Q3BSP_GetPVS;
- mod->brush.FatPVS = Mod_Q3BSP_FatPVS;
- mod->brush.BoxTouchingPVS = Mod_Q3BSP_BoxTouchingPVS;
+ mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
+ mod->brush.FatPVS = Mod_Q1BSP_FatPVS;
+ mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
+ mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
mod->brush.LightPoint = Mod_Q3BSP_LightPoint;
- mod->brush.FindNonSolidLocation = Mod_Q3BSP_FindNonSolidLocation;
- //mod->DrawSky = R_Q3BSP_DrawSky;
- mod->Draw = R_Q3BSP_Draw;
- mod->GetLightInfo = R_Q3BSP_GetLightInfo;
- mod->DrawShadowVolume = R_Q3BSP_DrawShadowVolume;
- mod->DrawLight = R_Q3BSP_DrawLight;
+ mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
+ mod->Draw = R_Q1BSP_Draw;
+ mod->GetLightInfo = R_Q1BSP_GetLightInfo;
+ mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+ mod->DrawLight = R_Q1BSP_DrawLight;
mod_base = (qbyte *)header;
// make a single combined shadow mesh to allow optimized shadow volume creation
numshadowmeshtriangles = 0;
- for (j = 0, surface = loadmodel->brushq3.data_faces;j < loadmodel->brushq3.num_faces;j++, surface++)
+ for (j = 0, surface = loadmodel->brush.data_surfaces;j < loadmodel->brush.num_surfaces;j++, surface++)
{
surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
numshadowmeshtriangles += surface->mesh.num_triangles;
}
loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
- for (j = 0, surface = loadmodel->brushq3.data_faces;j < loadmodel->brushq3.num_faces;j++, surface++)
+ for (j = 0, surface = loadmodel->brush.data_surfaces;j < loadmodel->brush.num_surfaces;j++, surface++)
Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, surface->mesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->mesh.num_triangles, surface->mesh.data_element3i);
loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true);
Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes);
mod = loadmodel;
- for (i = 0;i < loadmodel->brushq3.num_models;i++)
+ for (i = 0;i < loadmodel->brush.numsubmodels;i++)
{
if (i > 0)
{
mod->brush.GetPVS = NULL;
mod->brush.FatPVS = NULL;
mod->brush.BoxTouchingPVS = NULL;
+ mod->brush.BoxTouchingVisibleLeafs = NULL;
mod->brush.LightPoint = NULL;
- mod->brush.FindNonSolidLocation = Mod_Q3BSP_FindNonSolidLocation;
+ mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
}
mod->brush.submodel = i;
// make the model surface list (used by shadowing/lighting)
- mod->nummodelsurfaces = mod->brushq3.data_models[i].numsurfaces;
+ mod->firstmodelsurface = mod->brushq3.data_models[i].firstface;
+ 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));
for (j = 0;j < mod->nummodelsurfaces;j++)
- mod->surfacelist[j] = (mod->brushq3.data_models[i].firstsurface - mod->brushq3.data_faces) + j;
+ mod->surfacelist[j] = mod->firstmodelsurface + j;
VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins);
VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs);
mod->radius = modelradius;
mod->radius2 = modelradius * modelradius;
- for (j = 0;j < mod->brushq3.data_models[i].numsurfaces;j++)
- if (mod->brushq3.data_models[i].firstsurface[j].texture->surfaceflags & Q3SURFACEFLAG_SKY)
+ for (j = 0;j < mod->nummodelsurfaces;j++)
+ if (mod->brush.data_surfaces[j + mod->firstmodelsurface].texture->surfaceflags & Q3SURFACEFLAG_SKY)
break;
- if (j < mod->brushq3.data_models[i].numsurfaces)
- mod->DrawSky = R_Q3BSP_DrawSky;
+ if (j < mod->nummodelsurfaces)
+ mod->DrawSky = R_Q1BSP_DrawSky;
}
}
projects / xonotic / darkplaces.git / blobdiff