//cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "how large water polygons should be (smaller values produce more polygons which give better warping effects)"};
-cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"};
cvar_t r_picmipworld = {CVAR_SAVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too"};
cvar_t r_nosurftextures = {0, "r_nosurftextures", "0", "pretends there was no texture lump found in the q1bsp/hlbsp loading (useful for debugging this rare case)"};
cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4", "maximum error tolerance on curve subdivision for rendering purposes (in other words, the curves will be given as many polygons as necessary to represent curves at this quality)"};
-cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
+cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "0", "minimum number of subdivisions (values above 0 will smooth curves that don't need it)"};
cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536", "maximum vertices allowed per subdivided curve"};
cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15", "maximum error tolerance on curve subdivision for collision purposes (usually a larger error tolerance than for rendering)"};
-cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
+cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "0", "minimum number of subdivisions (values above 0 will smooth curves that don't need it)"};
cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"};
cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"};
void Mod_BrushInit(void)
{
// Cvar_RegisterVariable(&r_subdivide_size);
- Cvar_RegisterVariable(&halflifebsp);
Cvar_RegisterVariable(&r_novis);
Cvar_RegisterVariable(&r_picmipworld);
Cvar_RegisterVariable(&r_nosurftextures);
tx->skinframerate = 1;
tx->skinframes[0] = skinframe;
tx->currentskinframe = tx->skinframes[0];
- tx->basematerialflags = 0;
}
tx->basematerialflags = MATERIALFLAG_WALL;
if (i == loadmodel->num_textures - 1)
// LordHavoc: HL sky textures are entirely different than quake
if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == 256 && mtheight == 128)
{
- if (loadmodel->isworldmodel)
+ data = loadimagepixelsbgra(tx->name, false, false);
+ if (data && image_width == 256 && image_height == 128)
{
- data = loadimagepixelsbgra(tx->name, false, false);
- if (data && image_width == 256 && image_height == 128)
- {
- R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
- Mem_Free(data);
- }
- else if (mtdata != NULL)
- R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
+ R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
+ Mem_Free(data);
}
+ else if (mtdata != NULL)
+ R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
}
else
{
else if (!strncmp(tx->name, "sky", 3))
tx->basematerialflags = MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
else if (!strcmp(tx->name, "caulk"))
- tx->basematerialflags = MATERIALFLAG_NODRAW;
+ tx->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
else if (tx->skinframes[0] && tx->skinframes[0]->fog)
tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
{
char key[128], value[4096];
- char wadname[128];
int i, j, k;
if (!data)
return;
{
k = value[i];
value[i] = 0;
- strlcpy(wadname, "textures/", sizeof(wadname));
- strlcat(wadname, &value[j], sizeof(wadname));
- W_LoadTextureWadFile(wadname, false);
+ W_LoadTextureWadFile(&value[j], false);
j = i+1;
if (!k)
break;
dheader_t *header;
dmodel_t *bm;
mempool_t *mainmempool;
- float dist, modelyawradius, modelradius, *vec;
+ float dist, modelyawradius, modelradius;
msurface_t *surface;
int numshadowmeshtriangles;
hullinfo_t hullinfo;
mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
mod->brush.RoundUpToHullSize = Mod_Q1BSP_RoundUpToHullSize;
mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
-
- if (loadmodel->isworldmodel)
- Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
+ mod->Draw = R_Q1BSP_Draw;
+ mod->DrawDepth = R_Q1BSP_DrawDepth;
+ mod->DrawDebug = R_Q1BSP_DrawDebug;
+ mod->GetLightInfo = R_Q1BSP_GetLightInfo;
+ mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
+ mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+ mod->DrawLight = R_Q1BSP_DrawLight;
// load into heap
if (i > 0)
{
char name[10];
- // LordHavoc: only register submodels if it is the world
- // (prevents external bsp models from replacing world submodels with
- // their own)
- if (!loadmodel->isworldmodel)
- continue;
// duplicate the basic information
dpsnprintf(name, sizeof(name), "*%i", i);
- mod = Mod_FindName(name);
+ mod = Mod_FindName(name, loadmodel->name);
// copy the base model to this one
*mod = *loadmodel;
// rename the clone back to its proper name
strlcpy(mod->name, name, sizeof(mod->name));
+ mod->brush.parentmodel = loadmodel;
// textures and memory belong to the main model
mod->texturepool = NULL;
mod->mempool = NULL;
+ mod->brush.TraceLineOfSight = NULL;
+ mod->brush.GetPVS = NULL;
+ mod->brush.FatPVS = NULL;
+ mod->brush.BoxTouchingPVS = NULL;
+ mod->brush.BoxTouchingLeafPVS = NULL;
+ mod->brush.BoxTouchingVisibleLeafs = NULL;
+ mod->brush.FindBoxClusters = NULL;
+ mod->brush.LightPoint = NULL;
+ mod->brush.AmbientSoundLevelsForPoint = NULL;
}
mod->brush.submodel = i;
mod->nummodelsurfaces = bm->numfaces;
// make the model surface list (used by shadowing/lighting)
- mod->surfacelist = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int);
- for (j = 0;j < mod->nummodelsurfaces;j++)
- mod->surfacelist[j] = mod->firstmodelsurface + j;
+ mod->sortedmodelsurfaces = (int *)datapointer;datapointer += mod->nummodelsurfaces * sizeof(int);
+ Mod_MakeSortedSurfaces(mod);
- // this gets altered below if sky or water is used
- mod->DrawSky = NULL;
- mod->DrawAddWaterPlanes = NULL;
- mod->Draw = R_Q1BSP_Draw;
- mod->DrawDepth = R_Q1BSP_DrawDepth;
- mod->DrawDebug = R_Q1BSP_DrawDebug;
- mod->GetLightInfo = R_Q1BSP_GetLightInfo;
- mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
- mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
- mod->DrawLight = R_Q1BSP_DrawLight;
- if (i != 0)
- {
- mod->brush.TraceLineOfSight = NULL;
- mod->brush.GetPVS = NULL;
- mod->brush.FatPVS = NULL;
- mod->brush.BoxTouchingPVS = NULL;
- mod->brush.BoxTouchingLeafPVS = NULL;
- mod->brush.BoxTouchingVisibleLeafs = NULL;
- mod->brush.FindBoxClusters = NULL;
- mod->brush.LightPoint = NULL;
- mod->brush.AmbientSoundLevelsForPoint = NULL;
- }
// copy the submodel bounds, then enlarge the yaw and rotated bounds according to radius
+ // (previously this code measured the radius of the vertices of surfaces in the submodel, but that broke submodels that contain only CLIP brushes, which do not produce surfaces)
VectorCopy(bm->mins, mod->normalmins);
VectorCopy(bm->maxs, mod->normalmaxs);
- VectorCopy(bm->mins, mod->yawmins);
- VectorCopy(bm->maxs, mod->yawmaxs);
- VectorCopy(bm->mins, mod->rotatedmins);
- VectorCopy(bm->maxs, mod->rotatedmaxs);
+ dist = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
+ modelyawradius = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
+ modelyawradius = dist*dist+modelyawradius*modelyawradius;
+ modelradius = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
+ modelradius = modelyawradius + modelradius * modelradius;
+ modelyawradius = sqrt(modelyawradius);
+ modelradius = sqrt(modelradius);
+ mod->yawmins[0] = mod->yawmins[1] = -modelyawradius;
+ mod->yawmins[2] = mod->normalmins[2];
+ mod->yawmaxs[0] = mod->yawmaxs[1] = modelyawradius;
+ mod->yawmaxs[2] = mod->normalmaxs[2];
+ mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
+ mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius;
+ mod->radius = modelradius;
+ mod->radius2 = modelradius * modelradius;
+
+ // this gets altered below if sky or water is used
+ mod->DrawSky = NULL;
+ mod->DrawAddWaterPlanes = NULL;
+
+ // scan surfaces for sky and water and flag the submodel as possessing these features or not
+ // build lightstyle lists for quick marking of dirty lightmaps when lightstyles flicker
if (mod->nummodelsurfaces)
{
- modelyawradius = 0;
- modelradius = 0;
for (j = 0, surface = &mod->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->texture->basematerialflags & MATERIALFLAG_SKY)
- mod->DrawSky = R_Q1BSP_DrawSky;
+ break;
+ if (j < mod->nummodelsurfaces)
+ mod->DrawSky = R_Q1BSP_DrawSky;
+
+ for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++)
if (surface->texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
- mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
- // calculate bounding shapes
- for (k = 0, vec = (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex);k < surface->num_vertices;k++, vec += 3)
- {
- dist = vec[0]*vec[0]+vec[1]*vec[1];
- if (modelyawradius < dist)
- modelyawradius = dist;
- dist += vec[2]*vec[2];
- if (modelradius < dist)
- modelradius = dist;
- }
- }
- modelyawradius = sqrt(modelyawradius);
- modelradius = sqrt(modelradius);
- mod->yawmins[0] = min(mod->yawmins[0], -modelyawradius);
- mod->yawmaxs[0] = min(mod->yawmaxs[0], -modelyawradius);
- mod->yawmins[1] = min(mod->yawmins[1], modelyawradius);
- mod->yawmaxs[1] = min(mod->yawmaxs[1], modelyawradius);
- mod->rotatedmins[0] = min(mod->rotatedmins[0], -modelradius);
- mod->rotatedmaxs[0] = min(mod->rotatedmaxs[0], modelradius);
- mod->rotatedmins[1] = min(mod->rotatedmins[1], -modelradius);
- mod->rotatedmaxs[1] = min(mod->rotatedmaxs[1], modelradius);
- mod->rotatedmins[2] = min(mod->rotatedmins[2], -modelradius);
- mod->rotatedmaxs[2] = min(mod->rotatedmaxs[2], modelradius);
- mod->radius = modelradius;
- mod->radius2 = modelradius * modelradius;
+ break;
+ if (j < mod->nummodelsurfaces)
+ mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
// build lightstyle update chains
// (used to rapidly mark lightmapupdateflags on many surfaces
i = LittleLong(header->version);
if (i != Q2BSPVERSION)
Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION);
- mod->brush.ishlbsp = false;
- if (loadmodel->isworldmodel)
- Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
mod_base = (unsigned char *)header;
}
// make the colbrush from the planes
out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents);
+
+ // this whole loop can take a while (e.g. on redstarrepublic4)
+ CL_KeepaliveMessage(false);
}
if (planes)
Mem_Free(planes);
}
}
- convertedpixels = Mem_Alloc(tempmempool, size*size*4);
+ convertedpixels = (unsigned char *) Mem_Alloc(tempmempool, size*size*4);
loadmodel->brushq3.lightmapsize = size;
loadmodel->brushq3.num_originallightmaps = count;
typedef struct patchtess_s
{
- qboolean grouped;
+ patchinfo_t info;
+
+ // Auxiliary data used only by patch loading code in Mod_Q3BSP_LoadFaces
int surface_id;
- int xtess, ytess;
- int xsize, ysize;
- int cxtess, cytess;
- int cxsize, cysize;
float lodgroup[6];
-}
-patchtess_t;
+ float *originalvertex3f;
+} patchtess_t;
+
+#define PATCHTESS_SAME_LODGROUP(a,b) \
+ ( \
+ (a).lodgroup[0] == (b).lodgroup[0] && \
+ (a).lodgroup[1] == (b).lodgroup[1] && \
+ (a).lodgroup[2] == (b).lodgroup[2] && \
+ (a).lodgroup[3] == (b).lodgroup[3] && \
+ (a).lodgroup[4] == (b).lodgroup[4] && \
+ (a).lodgroup[5] == (b).lodgroup[5] \
+ )
static void Mod_Q3BSP_LoadFaces(lump_t *l)
{
q3dface_t *in, *oldin;
msurface_t *out, *oldout;
- int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles, groupsize, cxtess, cytess;
+ int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles, cxtess, cytess;
float lightmaptcbase[2], lightmaptcscale[2];
//int *originalelement3i;
//int *originalneighbor3i;
float *v;
patchtess_t *patchtess = NULL;
int patchtesscount = 0;
+ qboolean again;
in = (q3dface_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
loadmodel->num_surfaces = count;
if(count > 0)
- patchtess = Mem_Alloc(tempmempool, count * sizeof(*patchtess));
+ patchtess = (patchtess_t*) Mem_Alloc(tempmempool, count * sizeof(*patchtess));
i = 0;
oldi = i;
xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
// bound to sanity settings
- xtess = bound(1, xtess, 1024);
- ytess = bound(1, ytess, 1024);
+ xtess = bound(0, xtess, 1024);
+ ytess = bound(0, ytess, 1024);
// lower quality collision patches! Same procedure as before, but different cvars
// convert patch to Q3FACETYPE_MESH
cxtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
cytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
// bound to user settings
- cxtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_collision_maxtess.integer);
- cytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_collision_maxtess.integer);
+ cxtess = bound(r_subdivisions_collision_mintess.integer, cxtess, r_subdivisions_collision_maxtess.integer);
+ cytess = bound(r_subdivisions_collision_mintess.integer, cytess, r_subdivisions_collision_maxtess.integer);
// bound to sanity settings
- cxtess = bound(1, xtess, 1024);
- cytess = bound(1, ytess, 1024);
+ cxtess = bound(0, cxtess, 1024);
+ cytess = bound(0, cytess, 1024);
// store it for the LOD grouping step
+ patchtess[patchtesscount].info.xsize = patchsize[0];
+ patchtess[patchtesscount].info.ysize = patchsize[1];
+ patchtess[patchtesscount].info.lods[PATCH_LOD_VISUAL].xtess = xtess;
+ patchtess[patchtesscount].info.lods[PATCH_LOD_VISUAL].ytess = ytess;
+ patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].xtess = cxtess;
+ patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].ytess = cytess;
+
patchtess[patchtesscount].surface_id = i;
- patchtess[patchtesscount].grouped = false;
- patchtess[patchtesscount].xtess = xtess;
- patchtess[patchtesscount].ytess = ytess;
- patchtess[patchtesscount].xsize = patchsize[0];
- patchtess[patchtesscount].ysize = patchsize[1];
patchtess[patchtesscount].lodgroup[0] = in->specific.patch.mins[0];
patchtess[patchtesscount].lodgroup[1] = in->specific.patch.mins[1];
patchtess[patchtesscount].lodgroup[2] = in->specific.patch.mins[2];
patchtess[patchtesscount].lodgroup[3] = in->specific.patch.maxs[0];
patchtess[patchtesscount].lodgroup[4] = in->specific.patch.maxs[1];
patchtess[patchtesscount].lodgroup[5] = in->specific.patch.maxs[2];
-
- patchtess[patchtesscount].cxtess = xtess;
- patchtess[patchtesscount].cytess = ytess;
+ patchtess[patchtesscount].originalvertex3f = originalvertex3f;
++patchtesscount;
break;
case Q3FACETYPE_FLARE:
meshtriangles += out->num_triangles;
}
- for(i = 0; i < patchtesscount; ++i)
+ // Fix patches tesselations so that they make no seams
+ do
{
- if(patchtess[i].grouped) // already grouped
- continue;
-
- // get the highest required tess parameters for this group
- groupsize = 0;
- xtess = ytess = 0;
- cxtess = cytess = 0;
- for(j = 0; j < patchtesscount; ++j)
+ again = false;
+ for(i = 0; i < patchtesscount; ++i)
{
- if(patchtess[j].grouped) // already grouped
- continue;
- if(memcmp(patchtess[i].lodgroup, patchtess[j].lodgroup, sizeof(patchtess[i].lodgroup)))
- continue;
- if(patchtess[j].xtess > xtess)
- xtess = patchtess[j].xtess;
- if(patchtess[j].ytess > ytess)
- ytess = patchtess[j].ytess;
- if(patchtess[j].cxtess > cxtess)
- cxtess = patchtess[j].cxtess;
- if(patchtess[j].cytess > cytess)
- cytess = patchtess[j].cytess;
- ++groupsize;
- }
-
- if(groupsize == 0)
- {
- Con_Printf("ERROR: patch %d isn't in any LOD group (1)?!?\n", patchtess[i].surface_id);
- continue;
- }
-
- // bound to user limit on vertices
- for(;;)
- {
- numvertices = 0;
- numtriangles = 0;
-
- for(j = 0; j < patchtesscount; ++j)
+ for(j = i+1; j < patchtesscount; ++j)
{
- if(patchtess[j].grouped) // already grouped
+ if (!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j]))
continue;
- if(memcmp(patchtess[i].lodgroup, patchtess[j].lodgroup, sizeof(patchtess[i].lodgroup)))
- continue;
-
- finalwidth = (patchtess[j].xsize - 1) * xtess + 1;
- finalheight = (patchtess[j].ysize - 1) * ytess + 1;
- numvertices += finalwidth * finalheight;
- numtriangles += (finalwidth - 1) * (finalheight - 1) * 2;
- }
-
- if(xtess <= 1 && ytess <= 1)
- break;
- if(numvertices > min(r_subdivisions_maxvertices.integer, 262144) * groupsize)
- {
- if (xtess > ytess)
- xtess--;
- else
- ytess--;
- continue; // try again
+ if (Q3PatchAdjustTesselation(3, &patchtess[i].info, patchtess[i].originalvertex3f, &patchtess[j].info, patchtess[j].originalvertex3f) )
+ again = true;
}
-
- break;
}
+ }
+ while (again);
- // bound to user limit on vertices (collision)
- for(;;)
- {
- numvertices = 0;
- numtriangles = 0;
-
- for(j = 0; j < patchtesscount; ++j)
- {
- if(patchtess[j].grouped) // already grouped
- continue;
- if(memcmp(patchtess[i].lodgroup, patchtess[j].lodgroup, sizeof(patchtess[i].lodgroup)))
- continue;
-
- finalwidth = (patchtess[j].xsize - 1) * cxtess + 1;
- finalheight = (patchtess[j].ysize - 1) * cytess + 1;
- numvertices += finalwidth * finalheight;
- numtriangles += (finalwidth - 1) * (finalheight - 1) * 2;
- }
-
- if(cxtess <= 1 && cytess <= 1)
- break;
-
- if(numvertices > min(r_subdivisions_collision_maxvertices.integer, 262144) * groupsize)
- {
- if (cxtess > cytess)
- cxtess--;
- else
- cytess--;
- continue; // try again
- }
-
- break;
- }
-
- for(j = 0; j < patchtesscount; ++j)
- {
- if(patchtess[j].grouped) // already grouped
- continue;
- if(memcmp(patchtess[i].lodgroup, patchtess[j].lodgroup, sizeof(patchtess[i].lodgroup)))
- continue;
-
- finalwidth = (patchtess[j].xsize - 1) * xtess + 1;
- finalheight = (patchtess[j].ysize - 1) * ytess + 1;
- numvertices = finalwidth * finalheight;
- numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
-
- oldout[patchtess[j].surface_id].num_vertices = numvertices;
- oldout[patchtess[j].surface_id].num_triangles = numtriangles;
- meshvertices += oldout[patchtess[j].surface_id].num_vertices;
- meshtriangles += oldout[patchtess[j].surface_id].num_triangles;
+ // Calculate resulting number of triangles
+ for(i = 0; i < patchtesscount; ++i)
+ {
+ finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_VISUAL].xtess);
+ finalheight = Q3PatchDimForTess(patchtess[i].info.ysize,patchtess[i].info.lods[PATCH_LOD_VISUAL].ytess);
+ numvertices = finalwidth * finalheight;
+ numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
- patchtess[j].grouped = true;
- patchtess[j].xtess = xtess;
- patchtess[j].ytess = ytess;
- patchtess[j].cxtess = cxtess;
- patchtess[j].cytess = cytess;
- }
+ oldout[patchtess[i].surface_id].num_vertices = numvertices;
+ oldout[patchtess[i].surface_id].num_triangles = numtriangles;
+ meshvertices += oldout[patchtess[i].surface_id].num_vertices;
+ meshtriangles += oldout[patchtess[i].surface_id].num_triangles;
}
i = oldi;
originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4;
- xtess = ytess = cxtess = cytess = 0;
+ xtess = ytess = cxtess = cytess = -1;
for(j = 0; j < patchtesscount; ++j)
- if(patchtess[j].grouped && patchtess[j].surface_id == i)
+ if(patchtess[j].surface_id == i)
{
- xtess = patchtess[j].xtess;
- ytess = patchtess[j].ytess;
- cxtess = patchtess[j].cxtess;
- cytess = patchtess[j].cytess;
+ xtess = patchtess[j].info.lods[PATCH_LOD_VISUAL].xtess;
+ ytess = patchtess[j].info.lods[PATCH_LOD_VISUAL].ytess;
+ cxtess = patchtess[j].info.lods[PATCH_LOD_COLLISION].xtess;
+ cytess = patchtess[j].info.lods[PATCH_LOD_COLLISION].ytess;
break;
}
- if(xtess == 0)
+ if(xtess == -1)
{
- Con_Printf("ERROR: patch %d isn't in any LOD group (2)?!?\n", i);
- xtess = ytess = cxtess = cytess = 1;
+ Con_Printf("ERROR: patch %d isn't preprocessed?!?\n", i);
+ xtess = ytess = cxtess = cytess = 0;
}
- finalwidth = ((patchsize[0] - 1) * xtess) + 1;
- finalheight = ((patchsize[1] - 1) * ytess) + 1;
+ finalwidth = Q3PatchDimForTess(patchsize[0],xtess); //((patchsize[0] - 1) * xtess) + 1;
+ finalheight = Q3PatchDimForTess(patchsize[1],ytess); //((patchsize[1] - 1) * ytess) + 1;
finalvertices = finalwidth * finalheight;
finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
type = Q3FACETYPE_MESH;
Q3PatchTesselateFloat(2, sizeof(float[2]), (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordlightmap2f, xtess, ytess);
Q3PatchTesselateFloat(4, sizeof(float[4]), (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[4]), originalcolor4f, xtess, ytess);
Q3PatchTriangleElements((loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), finalwidth, finalheight, out->num_firstvertex);
+
out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), loadmodel->surfmesh.data_vertex3f);
+
if (developer.integer >= 100)
{
if (out->num_triangles < finaltriangles)
}
// q3map does not put in collision brushes for curves... ugh
// build the lower quality collision geometry
- finalwidth = ((patchsize[0] - 1) * cxtess) + 1;
- finalheight = ((patchsize[1] - 1) * cytess) + 1;
+ finalwidth = Q3PatchDimForTess(patchsize[0],cxtess); //((patchsize[0] - 1) * cxtess) + 1;
+ finalheight = Q3PatchDimForTess(patchsize[1],cytess); //((patchsize[1] - 1) * cytess) + 1;
finalvertices = finalwidth * finalheight;
finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
//out->lightmapinfo->styles[3] = 255;
}
+ i = oldi;
+ out = oldout;
+ for (;i < count;i++, out++)
+ {
+ if(out->num_vertices && out->num_triangles)
+ continue;
+ if(out->num_vertices == 0)
+ Con_Printf("Mod_Q3BSP_LoadFaces: surface %d has no vertices, ignoring\n", i);
+ if(out->num_triangles == 0)
+ Con_Printf("Mod_Q3BSP_LoadFaces: surface %d has no triangles, ignoring\n", i);
+ }
+
// for per pixel lighting
Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
i = LittleLong(header->version);
if (i != Q3BSPVERSION && i != Q3BSPVERSION_IG && i != Q3BSPVERSION_LIVE)
Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION);
- mod->brush.ishlbsp = false;
- if (loadmodel->isworldmodel)
- Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
mod->soundfromcenter = true;
mod->TraceBox = Mod_Q3BSP_TraceBox;
mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
mod->brush.LightPoint = Mod_Q3BSP_LightPoint;
mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
+ mod->brush.AmbientSoundLevelsForPoint = NULL;
+ mod->brush.RoundUpToHullSize = NULL;
mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
mod->Draw = R_Q1BSP_Draw;
mod->DrawDepth = R_Q1BSP_DrawDepth;
mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
mod->DrawLight = R_Q1BSP_DrawLight;
- mod->DrawAddWaterPlanes = NULL;
mod_base = (unsigned char *)header;
if (i == Q3LUMP_PVS || i == Q3LUMP_LEAFS || i == Q3LUMP_NODES)
continue;
mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
+
+ // all this checksumming can take a while, so let's send keepalives here too
+ CL_KeepaliveMessage(false);
}
Mod_Q3BSP_LoadEntities(&header->lumps[Q3LUMP_ENTITIES]);
if (i > 0)
{
char name[10];
- // LordHavoc: only register submodels if it is the world
- // (prevents external bsp models from replacing world submodels with
- // their own)
- if (!loadmodel->isworldmodel)
- continue;
// duplicate the basic information
dpsnprintf(name, sizeof(name), "*%i", i);
- mod = Mod_FindName(name);
+ mod = Mod_FindName(name, loadmodel->name);
+ // copy the base model to this one
*mod = *loadmodel;
+ // rename the clone back to its proper name
strlcpy(mod->name, name, sizeof(mod->name));
+ mod->brush.parentmodel = loadmodel;
// textures and memory belong to the main model
mod->texturepool = NULL;
mod->mempool = NULL;
mod->brush.BoxTouchingVisibleLeafs = NULL;
mod->brush.FindBoxClusters = NULL;
mod->brush.LightPoint = NULL;
- mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
+ mod->brush.AmbientSoundLevelsForPoint = NULL;
}
mod->brush.submodel = i;
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 = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
- for (j = 0;j < mod->nummodelsurfaces;j++)
- mod->surfacelist[j] = mod->firstmodelsurface + j;
+ mod->sortedmodelsurfaces = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->sortedmodelsurfaces));
+ Mod_MakeSortedSurfaces(mod);
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;
+ // this gets altered below if sky or water is used
+ mod->DrawSky = NULL;
+ mod->DrawAddWaterPlanes = NULL;
+
for (j = 0;j < mod->nummodelsurfaces;j++)
if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & MATERIALFLAG_SKY)
break;
if (j < mod->nummodelsurfaces)
mod->DrawSky = R_Q1BSP_DrawSky;
- else
- mod->DrawSky = NULL;
for (j = 0;j < mod->nummodelsurfaces;j++)
if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
break;
if (j < mod->nummodelsurfaces)
mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
- else
- mod->DrawAddWaterPlanes = NULL;
}
}