//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 mcbsp = {0, "mcbsp", "0", "indicates the current map is mcbsp 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)"};
cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1", "whether to use optimized traceline code for line traces (as opposed to tracebox code)"};
cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "selects different tracebrush bsp recursion algorithms (for debugging purposes only)"};
cvar_t mod_q3bsp_lightmapmergepower = {CVAR_SAVE, "mod_q3bsp_lightmapmergepower", "4", "merges the quake3 128x128 lightmap textures into larger lightmap group textures to speed up rendering, 1 = 256x256, 2 = 512x512, 3 = 1024x1024, 4 = 2048x2048, 5 = 4096x4096, ..."};
+cvar_t mod_q3bsp_nolightmaps = {CVAR_SAVE, "mod_q3bsp_nolightmaps", "0", "do not load lightmaps in Q3BSP maps (to save video RAM, but be warned: it looks ugly)"};
static texture_t mod_q1bsp_texture_solid;
static texture_t mod_q1bsp_texture_sky;
void Mod_BrushInit(void)
{
// Cvar_RegisterVariable(&r_subdivide_size);
- Cvar_RegisterVariable(&halflifebsp);
- Cvar_RegisterVariable(&mcbsp);
Cvar_RegisterVariable(&r_novis);
Cvar_RegisterVariable(&r_picmipworld);
Cvar_RegisterVariable(&r_nosurftextures);
Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline);
Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush);
Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower);
+ Cvar_RegisterVariable(&mod_q3bsp_nolightmaps);
memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid));
strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name));
mod_q1bsp_texture_water.supercontents = SUPERCONTENTS_WATER;
}
-static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p)
+static mleaf_t *Mod_Q1BSP_PointInLeaf(dp_model_t *model, const vec3_t p)
{
mnode_t *node;
return (mleaf_t *)node;
}
-static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, unsigned char *out, int outsize)
+static void Mod_Q1BSP_AmbientSoundLevelsForPoint(dp_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_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
+static int Mod_Q1BSP_FindBoxClusters(dp_model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
{
int numclusters = 0;
int nodestackindex = 0;
return numclusters;
}
-static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingPVS(dp_model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
{
int nodestackindex = 0;
mnode_t *node, *nodestack[1024];
return false;
}
-static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingLeafPVS(dp_model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
{
int nodestackindex = 0;
mnode_t *node, *nodestack[1024];
return false;
}
-static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingVisibleLeafs(dp_model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs)
{
int nodestackindex = 0;
mnode_t *node, *nodestack[1024];
vec_t radius;
vec3_t nudge;
vec_t bestdist;
- model_t *model;
+ dp_model_t *model;
}
findnonsolidlocationinfo_t;
}
}
-static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, float radius)
+static void Mod_Q1BSP_FindNonSolidLocation(dp_model_t *model, const vec3_t in, vec3_t out, float radius)
{
int i;
findnonsolidlocationinfo_t info;
VectorCopy(info.center, out);
}
-int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
+int Mod_Q1BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents)
{
switch(nativecontents)
{
return 0;
}
-int Mod_Q1BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
+int Mod_Q1BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents)
{
if (supercontents & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY))
return CONTENTS_SOLID;
//#if COLLISIONPARANOID < 2
static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, int num)
{
+ mplane_t *plane;
+ mclipnode_t *nodes = t->hull->clipnodes;
+ mplane_t *planes = t->hull->planes;
+ vec3_t point;
+ VectorCopy(t->start, point);
while (num >= 0)
- num = t->hull->clipnodes[num].children[(t->hull->planes[t->hull->clipnodes[num].planenum].type < 3 ? t->start[t->hull->planes[t->hull->clipnodes[num].planenum].type] : DotProduct(t->hull->planes[t->hull->clipnodes[num].planenum].normal, t->start)) < t->hull->planes[t->hull->clipnodes[num].planenum].dist];
+ {
+ plane = planes + nodes[num].planenum;
+ num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist];
+ }
num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
t->trace->startsupercontents |= num;
if (num & SUPERCONTENTS_LIQUIDSMASK)
VectorSubtract(boxmaxs, boxmins, boxsize);
if (boxsize[0] < 3)
rhc.hull = &model->brushq1.hulls[0]; // 0x0x0
- else if (model->brush.ismcbsp)
- {
- int i;
- float vdist, dist;
- int vdisti = 0;
-
- vdist = 0; // shut up compiler warning
-
- // find the closest hull size (this algorithm probably sucks, a qc field to override it might be in order...)
- for (i = 1; i < model->brushq1.numhulls; i++)
- {
- dist = fabs(model->brushq1.hulls[i].clip_size[0] - boxsize[0]) +
- fabs(model->brushq1.hulls[i].clip_size[1] - boxsize[1]) +
- fabs(model->brushq1.hulls[i].clip_size[2] - boxsize[2]) * 0.25;
-
- if (!vdisti || dist < vdist)
- {
- vdisti = i;
- vdist = dist;
- }
- }
- rhc.hull = &model->brushq1.hulls[vdisti];
- }
else if (model->brush.ishlbsp)
{
// LordHavoc: this has to have a minor tolerance (the .1) because of
#endif
}
+static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point)
+{
+ int num = model->brushq1.hulls[0].firstclipnode;
+ mplane_t *plane;
+ mclipnode_t *nodes = model->brushq1.hulls[0].clipnodes;
+ mplane_t *planes = model->brushq1.hulls[0].planes;
+ while (num >= 0)
+ {
+ plane = planes + nodes[num].planenum;
+ num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist];
+ }
+ return Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
+}
+
void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture)
{
#if 1
return Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend) != 2;
}
-static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(model_t *model, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz)
+static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(dp_model_t *model, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz)
{
int side;
float front, back;
// bilinear filter each lightmap style, and sum them
for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++)
{
- scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]];
+ scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[maps]];
w = w00 * scale;VectorMA(ambientcolor, w, lightmap , ambientcolor);
w = w01 * scale;VectorMA(ambientcolor, w, lightmap + 3 , ambientcolor);
w = w10 * scale;VectorMA(ambientcolor, w, lightmap + line3 , ambientcolor);
}
}
-void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
+void Mod_Q1BSP_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
{
// pretend lighting is coming down from above (due to lack of a lightgrid to know primary lighting direction)
VectorSet(diffusenormal, 0, 0, 1);
unsigned char *data, *mtdata;
const char *s;
char mapname[MAX_QPATH], name[MAX_QPATH];
+ unsigned char zero[4];
+
+ memset(zero, 0, sizeof(zero));
loadmodel->data_textures = NULL;
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)
{
- tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
+ tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
tx->supercontents = mod_q1bsp_texture_water.supercontents;
tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags;
}
else
{
- tx->basematerialflags |= MATERIALFLAG_WALL;
tx->supercontents = mod_q1bsp_texture_solid.supercontents;
tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags;
}
Vector4Set(tx->refractcolor4f, 1, 1, 1, 1);
tx->reflectfactor = 1;
Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1);
+ tx->r_water_wateralpha = 1;
}
if (!m)
// copy name, but only up to 16 characters
// (the output buffer can hold more than this, but the input buffer is
// only 16)
- for (j = 0;dmiptex->name[j] && j < 16;j++)
+ for (j = 0;j < 16 && dmiptex->name[j];j++)
name[j] = dmiptex->name[j];
name[j] = 0;
if (!name[0])
{
- sprintf(name, "unnamed%i", i);
+ dpsnprintf(name, sizeof(name), "unnamed%i", i);
Con_DPrintf("%s: warning: renaming unnamed texture to %s\n", loadmodel->name, name);
}
if (name[j] >= 'A' && name[j] <= 'Z')
name[j] += 'a' - 'A';
- if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, true, false, false))
+ if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, false, false, 0))
continue;
tx = loadmodel->data_textures + i;
// 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
{
- skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
+ skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
if (!skinframe)
- skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
+ skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false);
if (!skinframe)
{
// did not find external texture, load it from the bsp or wad3
{
tx->width = image_width;
tx->height = image_height;
- skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height);
+ skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height);
}
if (freepixels)
Mem_Free(freepixels);
}
else if (mtdata) // texture included
- skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height);
+ skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height);
}
// if skinframe is still NULL the "missing" texture will be used
if (skinframe)
tx->skinframes[0] = skinframe;
}
- tx->basematerialflags = 0;
+ tx->basematerialflags = MATERIALFLAG_WALL;
if (tx->name[0] == '*')
{
// LordHavoc: some turbulent textures should not be affected by wateralpha
- if (strncmp(tx->name,"*lava",5)
- && strncmp(tx->name,"*teleport",9)
- && strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
- tx->basematerialflags |= MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW | MATERIALFLAG_WATERSHADER;
- tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
+ if (!strncmp(tx->name, "*glassmirror", 12)) // Tenebrae
+ {
+ // replace the texture with transparent black
+ Vector4Set(zero, 128, 128, 128, 128);
+ tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_ALPHA, zero, 1, 1);
+ tx->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_REFLECTION;
+ }
+ else if (!strncmp(tx->name,"*lava",5)
+ || !strncmp(tx->name,"*teleport",9)
+ || !strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
+ tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
+ else
+ tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW | MATERIALFLAG_WATERALPHA | MATERIALFLAG_WATERSHADER;
+ if (tx->skinframes[0] && tx->skinframes[0]->fog)
+ tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
+ }
+ else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae
+ {
+ // replace the texture with black
+ tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_PRECACHE, zero, 1, 1);
+ tx->basematerialflags |= MATERIALFLAG_REFLECTION;
}
else if (!strncmp(tx->name, "sky", 3))
- tx->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
- else
- tx->basematerialflags |= MATERIALFLAG_WALL;
- if (tx->skinframes[0] && tx->skinframes[0]->fog)
+ tx->basematerialflags = MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
+ else if (!strcmp(tx->name, "caulk"))
+ tx->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
+ else if (tx->skinframes[0] && tx->skinframes[0]->fog)
tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
// start out with no animation
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 = (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)
{
// LordHavoc: hope is not lost yet, check for a .lit file to load
i = LittleLong(((int *)data)[1]);
if (i == 1)
{
- Con_DPrintf("loaded %s\n", litfilename);
+ if (developer_loading.integer)
+ Con_Printf("loaded %s\n", litfilename);
loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
memcpy(loadmodel->brushq1.lightdata, data + 8, filesize - 8);
Mem_Free(data);
i = LittleLong(((int *)data)[1]);
if (i == 1)
{
- Con_DPrintf("loaded %s\n", dlitfilename);
+ if (developer_loading.integer)
+ Con_Printf("loaded %s\n", dlitfilename);
loadmodel->brushq1.nmaplightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
memcpy(loadmodel->brushq1.nmaplightdata, data + 8, filesize - 8);
loadmodel->brushq3.deluxemapping_modelspace = false;
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;
loadmodel->brush.entities = NULL;
if (!l->filelen)
return;
- loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
+ loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen + 1);
memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
+ loadmodel->brush.entities[l->filelen] = 0;
if (loadmodel->brush.ishlbsp)
Mod_Q1BSP_ParseWadsFromEntityLump(loadmodel->brush.entities);
}
{
// if texture chosen is NULL or the shader needs a lightmap,
// force to notexture water shader
- if (out->texture == NULL || out->texture->basematerialflags & MATERIALFLAG_WALL)
+ if (out->texture == NULL)
out->texture = loadmodel->data_textures + (loadmodel->num_textures - 1);
}
else
}
#endif
-static qboolean Mod_Q1BSP_AllocLightmapBlock(int *lineused, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy)
+/* Maximum size of a single LM */
+#define MAX_SINGLE_LM_SIZE 256
+
+struct alloc_lm_row
+{
+ int rowY;
+ int currentX;
+};
+
+struct alloc_lm_state
+{
+ int currentY;
+ struct alloc_lm_row rows[MAX_SINGLE_LM_SIZE];
+};
+
+static void init_alloc_lm_state (struct alloc_lm_state* state)
+{
+ int r;
+
+ state->currentY = 0;
+ for (r = 0; r < MAX_SINGLE_LM_SIZE; r++)
+ {
+ state->rows[r].currentX = 0;
+ state->rows[r].rowY = -1;
+ }
+}
+
+static qboolean Mod_Q1BSP_AllocLightmapBlock(struct alloc_lm_state* state, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy)
{
- int y, x2, y2;
- int bestx = totalwidth, besty = 0;
- // find the left-most space we can find
- for (y = 0;y <= totalheight - blockheight;y++)
- {
- x2 = 0;
- for (y2 = 0;y2 < blockheight;y2++)
- x2 = max(x2, lineused[y+y2]);
- if (bestx > x2)
- {
- bestx = x2;
- besty = y;
- }
- }
- // if the best was not good enough, return failure
- if (bestx > totalwidth - blockwidth)
- return false;
- // we found a good spot
- if (outx)
- *outx = bestx;
- if (outy)
- *outy = besty;
- // now mark the space used
- for (y2 = 0;y2 < blockheight;y2++)
- lineused[besty+y2] = bestx + blockwidth;
- // return success
+ struct alloc_lm_row* row;
+ int r;
+
+ row = &(state->rows[blockheight]);
+ if ((row->rowY < 0) || (row->currentX + blockwidth > totalwidth))
+ {
+ if (state->currentY + blockheight <= totalheight)
+ {
+ row->rowY = state->currentY;
+ row->currentX = 0;
+ state->currentY += blockheight;
+ }
+ else
+ {
+ /* See if we can stuff the block into a higher row */
+ row = NULL;
+ for (r = blockheight; r < MAX_SINGLE_LM_SIZE; r++)
+ {
+ if ((state->rows[r].rowY >= 0)
+ && (state->rows[r].currentX + blockwidth <= totalwidth))
+ {
+ row = &(state->rows[r]);
+ break;
+ }
+ }
+ if (row == NULL) return false;
+ }
+ }
+ *outy = row->rowY;
+ *outx = row->currentX;
+ row->currentX += blockwidth;
+
return true;
}
msurface_t *surface;
int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber, lightmapsize, totallightmapsamples;
float texmins[2], texmaxs[2], val;
-#define LIGHTMAPSIZE 1024
rtexture_t *lightmaptexture, *deluxemaptexture;
- int lightmap_lineused[LIGHTMAPSIZE];
in = (dface_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
loadmodel->num_surfaces = count;
+ loadmodel->brushq1.lightmapupdateflags = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*sizeof(unsigned char));
+
totalverts = 0;
totaltris = 0;
for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
lightmaptexture = NULL;
deluxemaptexture = r_texture_blanknormalmap;
lightmapnumber = 1;
- lightmapsize = bound(256, gl_max_size.integer, LIGHTMAPSIZE);
+ lightmapsize = max(256, gl_max_size.integer);
totallightmapsamples = 0;
totalverts = 0;
{
surface->lightmapinfo->samples = NULL;
// give non-lightmapped water a 1x white lightmap
- if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
+ if (surface->texture->name[0] == '*' && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
{
surface->lightmapinfo->samples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
surface->lightmapinfo->styles[0] = 0;
// additionally this is used by the later code to see if a
// lightmap is needed on this surface (rather than duplicating the
// logic above)
- surface->cached_dlight = true;
+ loadmodel->brushq1.lightmapupdateflags[surfacenum] = true;
}
}
// store
// additionally, never choose a lightmapsize that is smaller than the
// largest surface encountered (as it would fail)
- // and finally, limit it to the size of our lineused array
i = lightmapsize;
- for (lightmapsize = 64;lightmapsize < LIGHTMAPSIZE && (lightmapsize < i || (lightmapsize < gl_max_size.integer && totallightmapsamples*2 > lightmapsize*lightmapsize));lightmapsize*=2)
+ for (lightmapsize = 64; (lightmapsize < i) && (lightmapsize < gl_max_size.integer) && (totallightmapsamples > lightmapsize*lightmapsize); lightmapsize*=2)
;
// now that we've decided the lightmap texture size, we can do the rest
if (cls.state != ca_dedicated)
{
+ struct alloc_lm_state allocState;
+
for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
{
- // check if we should apply a lightmap to this
- if (surface->cached_dlight)
- {
- int i, iu, iv, lightmapx, lightmapy;
- float u, v, ubase, vbase, uscale, vscale;
+ int i, iu, iv, lightmapx = 0, lightmapy = 0;
+ float u, v, ubase, vbase, uscale, vscale;
- smax = surface->lightmapinfo->extents[0] >> 4;
- tmax = surface->lightmapinfo->extents[1] >> 4;
- ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
- tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
+ smax = surface->lightmapinfo->extents[0] >> 4;
+ tmax = surface->lightmapinfo->extents[1] >> 4;
+ ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
+ tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
- // stainmap for permanent marks on walls
- surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
- // clear to white
- memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
+ if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy))
+ {
+ // allocate a texture pool if we need it
+ if (loadmodel->texturepool == NULL)
+ loadmodel->texturepool = R_AllocTexturePool();
+ // could not find room, make a new lightmap
+ lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+ if (loadmodel->brushq1.nmaplightdata)
+ deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+ lightmapnumber++;
+ init_alloc_lm_state (&allocState);
+ Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy);
+ }
+ surface->lightmaptexture = lightmaptexture;
+ surface->deluxemaptexture = deluxemaptexture;
+ surface->lightmapinfo->lightmaporigin[0] = lightmapx;
+ surface->lightmapinfo->lightmaporigin[1] = lightmapy;
- // find a place for this lightmap
- if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy))
- {
- // allocate a texture pool if we need it
- if (loadmodel->texturepool == NULL)
- loadmodel->texturepool = R_AllocTexturePool();
- // could not find room, make a new lightmap
- lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
- if (loadmodel->brushq1.nmaplightdata)
- deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
- lightmapnumber++;
- memset(lightmap_lineused, 0, sizeof(lightmap_lineused));
- Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy);
- }
+ uscale = 1.0f / (float)lightmapsize;
+ vscale = 1.0f / (float)lightmapsize;
+ ubase = lightmapx * uscale;
+ vbase = lightmapy * vscale;
- surface->lightmaptexture = lightmaptexture;
- surface->deluxemaptexture = deluxemaptexture;
- surface->lightmapinfo->lightmaporigin[0] = lightmapx;
- surface->lightmapinfo->lightmaporigin[1] = lightmapy;
+ for (i = 0;i < surface->num_vertices;i++)
+ {
+ u = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3]) + 8 - surface->lightmapinfo->texturemins[0]) * (1.0 / 16.0);
+ v = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3]) + 8 - surface->lightmapinfo->texturemins[1]) * (1.0 / 16.0);
+ (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase;
+ (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase;
+ // LordHavoc: calc lightmap data offset for vertex lighting to use
+ iu = (int) u;
+ iv = (int) v;
+ (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
+ }
- uscale = 1.0f / (float)lightmapsize;
- vscale = 1.0f / (float)lightmapsize;
- ubase = lightmapx * uscale;
- vbase = lightmapy * vscale;
+ }
- for (i = 0;i < surface->num_vertices;i++)
- {
- u = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3]) + 8 - surface->lightmapinfo->texturemins[0]) * (1.0 / 16.0);
- v = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3]) + 8 - surface->lightmapinfo->texturemins[1]) * (1.0 / 16.0);
- (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase;
- (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase;
- // LordHavoc: calc lightmap data offset for vertex lighting to use
- iu = (int) u;
- iv = (int) v;
- (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
- }
+ if (cl_stainmaps.integer)
+ {
+ // allocate stainmaps for permanent marks on walls
+ int stainmapsize = 0;
+ unsigned char *stainsamples = NULL;
+ for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
+ {
+ ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
+ tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
+ stainmapsize += ssize * tsize * 3;
+ }
+ // allocate and clear to white
+ stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, stainmapsize);
+ memset(stainsamples, 255, stainmapsize);
+ // assign pointers
+ for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
+ {
+ ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
+ tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
+ surface->lightmapinfo->stainsamples = stainsamples;
+ stainsamples += ssize * tsize * 3;
}
}
}
+
+ // generate ushort elements array if possible
+ if (loadmodel->surfmesh.data_element3s)
+ for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
+ loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
}
static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
int i, j;
mleaf_t *leaf;
const unsigned char *pvs;
+ // if there's no vis data, assume supported (because everything is visible all the time)
+ if (!loadmodel->brush.data_pvsclusters)
+ return true;
// check all liquid leafs to see if they can see into empty leafs, if any
// can we can assume this map supports r_wateralpha
for (i = 0, leaf = loadmodel->brush.data_leafs;i < loadmodel->brush.num_leafs;i++, leaf++)
{
- if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && (leaf->clusterindex >= 0 && loadmodel->brush.data_pvsclusters))
+ if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && leaf->clusterindex >= 0)
{
pvs = loadmodel->brush.data_pvsclusters + leaf->clusterindex * loadmodel->brush.num_pvsclusterbytes;
for (j = 0;j < loadmodel->brush.num_leafs;j++)
loadmodel->brushq1.clipnodes = out;
loadmodel->brushq1.numclipnodes = count;
- for (i = 1; i < hullinfo->numhulls; i++)
+ for (i = 1; i < MAX_MAP_HULLS; i++)
{
hull = &loadmodel->brushq1.hulls[i];
hull->clipnodes = out;
//Returns PVS data for a given point
//(note: can return NULL)
-static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
+static unsigned char *Mod_Q1BSP_GetPVS(dp_model_t *model, const vec3_t p)
{
mnode_t *node;
node = model->brush.data_nodes;
return NULL;
}
-static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node)
+static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(dp_model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node)
{
while (node->plane)
{
//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, unsigned char *pvsbuffer, int pvsbufferlength, qboolean merge)
+static int Mod_Q1BSP_FatPVS(dp_model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength, qboolean merge)
{
int bytes = model->brush.num_pvsclusterbytes;
bytes = min(bytes, pvsbufferlength);
return bytes;
}
-static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs)
+static void Mod_Q1BSP_RoundUpToHullSize(dp_model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs)
{
vec3_t size;
const hull_t *hull;
VectorSubtract(inmaxs, inmins, size);
- if (cmodel->brush.ismcbsp)
- {
- if (size[0] < 3)
- hull = &cmodel->brushq1.hulls[0]; // 0x0x0
- else if (size[2] < 48) // pick the nearest of 40 or 56
- hull = &cmodel->brushq1.hulls[2]; // 16x16x40
- else
- hull = &cmodel->brushq1.hulls[1]; // 16x16x56
- }
- else if (cmodel->brush.ishlbsp)
+ if (cmodel->brush.ishlbsp)
{
if (size[0] < 3)
hull = &cmodel->brushq1.hulls[0]; // 0x0x0
VectorAdd(inmins, hull->clip_size, outmaxs);
}
-void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
+void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
{
int i, j, k;
dheader_t *header;
dmodel_t *bm;
mempool_t *mainmempool;
- float dist, modelyawradius, modelradius, *vec;
+ float dist, modelyawradius, modelradius;
msurface_t *surface;
int numshadowmeshtriangles;
- dheader_t _header;
hullinfo_t hullinfo;
int totalstylesurfaces, totalstyles, stylecounts[256], remapstyles[256];
model_brush_lightstyleinfo_t styleinfo[256];
mod->type = mod_brushq1;
- if (!memcmp (buffer, "MCBSPpad", 8))
- {
- unsigned char *index;
+ header = (dheader_t *)buffer;
- mod->brush.ismcbsp = true;
- mod->brush.ishlbsp = false;
-
- mod_base = (unsigned char*)buffer;
-
- index = mod_base;
- index += 8;
- i = SB_ReadInt (&index);
- if (i != MCBSPVERSION)
- Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i)", mod->name, i, MCBSPVERSION);
-
- // read hull info
- hullinfo.numhulls = SB_ReadInt (&index);
- hullinfo.filehulls = hullinfo.numhulls;
- mod->brushq1.numhulls = hullinfo.numhulls;
-
- VectorClear (hullinfo.hullsizes[0][0]);
- VectorClear (hullinfo.hullsizes[0][1]);
- for (i = 1; i < hullinfo.numhulls; i++)
- {
- hullinfo.hullsizes[i][0][0] = SB_ReadFloat (&index);
- hullinfo.hullsizes[i][0][1] = SB_ReadFloat (&index);
- hullinfo.hullsizes[i][0][2] = SB_ReadFloat (&index);
- hullinfo.hullsizes[i][1][0] = SB_ReadFloat (&index);
- hullinfo.hullsizes[i][1][1] = SB_ReadFloat (&index);
- hullinfo.hullsizes[i][1][2] = SB_ReadFloat (&index);
- }
+ i = LittleLong(header->version);
+ if (i != BSPVERSION && i != 30)
+ Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION);
+ mod->brush.ishlbsp = i == 30;
- // read lumps
- _header.version = 0;
- for (i = 0; i < HEADER_LUMPS; i++)
- {
- _header.lumps[i].fileofs = SB_ReadInt (&index);
- _header.lumps[i].filelen = SB_ReadInt (&index);
- }
+// fill in hull info
+ VectorClear (hullinfo.hullsizes[0][0]);
+ VectorClear (hullinfo.hullsizes[0][1]);
+ if (mod->brush.ishlbsp)
+ {
+ mod->modeldatatypestring = "HLBSP";
- header = &_header;
+ hullinfo.filehulls = 4;
+ VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36);
+ VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36);
+ VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32);
+ VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32);
+ VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18);
+ VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18);
}
else
{
- header = (dheader_t *)buffer;
-
- i = LittleLong(header->version);
- if (i != BSPVERSION && i != 30)
- Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION);
- mod->brush.ishlbsp = i == 30;
- mod->brush.ismcbsp = false;
-
- // fill in hull info
- VectorClear (hullinfo.hullsizes[0][0]);
- VectorClear (hullinfo.hullsizes[0][1]);
- if (mod->brush.ishlbsp)
- {
- mod->modeldatatypestring = "HLBSP";
-
- hullinfo.numhulls = 4;
- hullinfo.filehulls = 4;
- mod->brushq1.numhulls = 4;
- VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36);
- VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36);
- VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32);
- VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32);
- VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18);
- VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18);
- }
- else
- {
- hullinfo.numhulls = 3;
- hullinfo.filehulls = 4;
- mod->brushq1.numhulls = 3;
- VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24);
- VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32);
- VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24);
- VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64);
- }
+ hullinfo.filehulls = 4;
+ VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24);
+ VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32);
+ VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24);
+ VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64);
+ }
- // read lumps
- mod_base = (unsigned char*)buffer;
- for (i = 0; i < HEADER_LUMPS; i++)
- {
- header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
- header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
- }
+// read lumps
+ mod_base = (unsigned char*)buffer;
+ for (i = 0; i < HEADER_LUMPS; i++)
+ {
+ header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
+ header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
}
mod->soundfromcenter = true;
mod->TraceBox = Mod_Q1BSP_TraceBox;
+ mod->PointSuperContents = Mod_Q1BSP_PointSuperContents;
mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents;
mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents;
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);
- Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
- }
+ 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
Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
if (loadmodel->brush.numsubmodels)
- loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
-
- if (loadmodel->isworldmodel)
- {
- // clear out any stale submodels or worldmodels lying around
- // if we did this clear before now, an error might abort loading and
- // leave things in a bad state
- Mod_RemoveStaleWorldModels(loadmodel);
- }
+ loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *));
// LordHavoc: to clear the fog around the original quake submodel code, I
// will explain:
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
- sprintf(name, "*%i", i);
- mod = Mod_FindName(name);
+ dpsnprintf(name, sizeof(name), "*%i", i);
+ 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);
+
+ // 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);
+ 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;
- 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;
- }
+
+ // 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)
{
- // LordHavoc: calculate bmodel bounding box rather than trusting what it says
- mod->normalmins[0] = mod->normalmins[1] = mod->normalmins[2] = 1000000000.0f;
- mod->normalmaxs[0] = mod->normalmaxs[1] = mod->normalmaxs[2] = -1000000000.0f;
- 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)
- {
- if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
- if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
- if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2];
- if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0];
- if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1];
- if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2];
- 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] = mod->yawmins[1] = - (mod->yawmaxs[0] = mod->yawmaxs[1] = modelyawradius);
- mod->yawmins[2] = mod->normalmins[2];
- 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;
+ break;
+ if (j < mod->nummodelsurfaces)
+ mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
// build lightstyle update chains
- // (used to rapidly mark surface->cached_dlight on many surfaces
+ // (used to rapidly mark lightmapupdateflags on many surfaces
// when d_lightstylevalue changes)
memset(stylecounts, 0, sizeof(stylecounts));
for (k = 0;k < mod->nummodelsurfaces;k++)
*/
}
-void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
+void static Mod_Q2BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
{
int i;
q2dheader_t *header;
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;
- mod->brush.ismcbsp = false;
- if (loadmodel->isworldmodel)
- {
- Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
- Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
- }
mod_base = (unsigned char *)header;
Mod_Q2BSP_LoadModels(&header->lumps[Q2LUMP_MODELS]);
}
-static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents);
-static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents);
+static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents);
+static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents);
static void Mod_Q3BSP_LoadEntities(lump_t *l)
{
loadmodel->brushq3.num_lightgrid_cellsize[2] = 128;
if (!l->filelen)
return;
- loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
+ loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen + 1);
memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
+ loadmodel->brush.entities[l->filelen] = 0;
data = loadmodel->brush.entities;
// some Q3 maps override the lightgrid_cellsize with a worldspawn key
if (data && COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{')
strlcpy(value, com_token, sizeof(value));
if (!strcmp("gridsize", key))
{
+#if _MSC_VER >= 1400
+#define sscanf sscanf_s
+#endif
if (sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3 && v[0] != 0 && v[1] != 0 && v[2] != 0)
VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize);
}
{
q3dtexture_t *in;
texture_t *out;
- int i, count, c;
+ int i, count;
in = (q3dtexture_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
if (cls.state == ca_dedicated)
return;
- c = 0;
for (i = 0;i < count;i++, in++, out++)
- if (!Mod_LoadTextureFromQ3Shader(out, out->name, false, true, false))
- c++;
- if (c)
- Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
+ Mod_LoadTextureFromQ3Shader(out, out->name, true, true, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS);
}
static void Mod_Q3BSP_LoadPlanes(lump_t *l)
}
}
+static void Mod_Q3BSP_LoadBrushSides_IG(lump_t *l)
+{
+ q3dbrushside_ig_t *in;
+ q3mbrushside_t *out;
+ int i, n, count;
+
+ in = (q3dbrushside_ig_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 = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
+
+ loadmodel->brush.data_brushsides = out;
+ loadmodel->brush.num_brushsides = count;
+
+ for (i = 0;i < count;i++, in++, out++)
+ {
+ n = LittleLong(in->planeindex);
+ if (n < 0 || n >= loadmodel->brush.num_planes)
+ Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes);
+ out->plane = loadmodel->brush.data_planes + n;
+ n = LittleLong(in->textureindex);
+ if (n < 0 || n >= loadmodel->num_textures)
+ Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)", n, loadmodel->num_textures);
+ out->texture = loadmodel->data_textures + n;
+ }
+}
+
static void Mod_Q3BSP_LoadBrushes(lump_t *l)
{
q3dbrush_t *in;
}
// 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);
static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
{
- q3dlightmap_t *in;
+ q3dlightmap_t *input_pointer;
int i, j, k, count, power, power2, mask, endlightmap, mergewidth, mergeheight;
unsigned char *c;
- unsigned char convertedpixels[128*128*4];
- if (!l->filelen)
- return;
+ unsigned char *convertedpixels;
+ char mapname[MAX_QPATH];
+ int size, bytesperpixel, rgbmap[3];
+ qboolean external;
+ unsigned char *inpixels[10000]; // max count q3map2 can output (it uses 4 digits)
+
+ // defaults for q3bsp
+ size = 128;
+ bytesperpixel = 3;
+ rgbmap[0] = 2;
+ rgbmap[1] = 1;
+ rgbmap[2] = 0;
+ external = false;
+ loadmodel->brushq3.lightmapsize = 128;
+
if (cls.state == ca_dedicated)
return;
- 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);
+
+ if(mod_q3bsp_nolightmaps.integer)
+ {
+ return;
+ }
+ else if(l->filelen)
+ {
+ // prefer internal LMs for compatibility (a BSP contains no info on whether external LMs exist)
+ if (developer_loading.integer)
+ Con_Printf("Using internal lightmaps\n");
+ input_pointer = (q3dlightmap_t *)(mod_base + l->fileofs);
+ if (l->filelen % sizeof(*input_pointer))
+ Host_Error("Mod_Q3BSP_LoadLightmaps: funny lump size in %s",loadmodel->name);
+ count = l->filelen / sizeof(*input_pointer);
+ for(i = 0; i < count; ++i)
+ inpixels[i] = input_pointer[i].rgb;
+ }
+ else
+ {
+ // no internal lightmaps
+ // try external lightmaps
+ if (developer_loading.integer)
+ Con_Printf("Using external lightmaps\n");
+ FS_StripExtension(loadmodel->name, mapname, sizeof(mapname));
+ inpixels[0] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, 0), false, false);
+ if(!inpixels[0])
+ return;
+
+ // using EXTERNAL lightmaps instead
+ if(image_width != (int) CeilPowerOf2(image_width) || image_width != image_height)
+ {
+ Mem_Free(inpixels[0]);
+ Host_Error("Mod_Q3BSP_LoadLightmaps: invalid external lightmap size in %s",loadmodel->name);
+ }
+
+ size = image_width;
+ bytesperpixel = 4;
+ rgbmap[0] = 0;
+ rgbmap[1] = 1;
+ rgbmap[2] = 2;
+ external = true;
+
+ for(count = 1; ; ++count)
+ {
+ inpixels[count] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, count), false, false);
+ if(!inpixels[count])
+ break; // we got all of them
+ if(image_width != size || image_height != size)
+ {
+ for(i = 0; i <= count; ++i)
+ Mem_Free(inpixels[i]);
+ Host_Error("Mod_Q3BSP_LoadLightmaps: invalid external lightmap size in %s",loadmodel->name);
+ }
+ }
+ }
+
+ convertedpixels = (unsigned char *) Mem_Alloc(tempmempool, size*size*4);
+ loadmodel->brushq3.lightmapsize = size;
loadmodel->brushq3.num_originallightmaps = count;
// now check the surfaces to see if any of them index an odd numbered
}
}
}
- if (endlightmap < 2)
- loadmodel->brushq3.deluxemapping = false;
// q3map2 sometimes (or always?) makes a second blank lightmap for no
// reason when only one lightmap is used, which can throw off the
// deluxemapping detection method, so check 2-lightmap bsp's specifically
// to see if the second lightmap is blank, if so it is not deluxemapped.
- if (endlightmap == 1 && count == 2)
+ //
+ // further research has shown q3map2 sometimes creates a deluxemap and two
+ // blank lightmaps, which must be handled properly as well
+ if (endlightmap == 1 && count > 1)
{
- c = in[1].rgb;
- for (i = 0;i < 128*128*3;i++)
- if (c[i])
+ c = inpixels[1];
+ for (i = 0;i < size*size;i++)
+ {
+ if (c[bytesperpixel*i + rgbmap[0]])
+ break;
+ if (c[bytesperpixel*i + rgbmap[1]])
break;
- if (i == 128*128*3)
+ if (c[bytesperpixel*i + rgbmap[2]])
+ break;
+ }
+ if (i == size*size)
{
// all pixels in the unused lightmap were black...
loadmodel->brushq3.deluxemapping = false;
loadmodel->brushq3.num_lightmapmergepower = 0;
for (power = 1;power <= mod_q3bsp_lightmapmergepower.integer && (128 << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> loadmodel->brushq3.deluxemapping);power++)
loadmodel->brushq3.num_lightmapmergepower = power;
+
+ // as the lightmap size may actually be another power of 2, adjust for this
+ // (and interpret it as the power for 128x128 lightmaps above)
+ for(i = 0; (128 << i) < size; ++i)
+ loadmodel->brushq3.num_lightmapmergepower -= 1;
+ if(loadmodel->brushq3.num_lightmapmergepower < 0)
+ loadmodel->brushq3.num_lightmapmergepower = 0;
+
loadmodel->brushq3.num_lightmapmerge = 1 << loadmodel->brushq3.num_lightmapmergepower;
loadmodel->brushq3.num_mergedlightmaps = ((count >> loadmodel->brushq3.deluxemapping) + (1 << (loadmodel->brushq3.num_lightmapmergepower * 2)) - 1) >> (loadmodel->brushq3.num_lightmapmergepower * 2);
{
// figure out which merged lightmap texture this fits into
int lightmapindex = i >> (loadmodel->brushq3.deluxemapping + power2);
- for (k = 0;k < 128*128;k++)
+ for (k = 0;k < size*size;k++)
{
- convertedpixels[k*4+2] = in[i].rgb[k*3+0];
- convertedpixels[k*4+1] = in[i].rgb[k*3+1];
- convertedpixels[k*4+0] = in[i].rgb[k*3+2];
+ convertedpixels[k*4+0] = inpixels[i][k*bytesperpixel+rgbmap[0]];
+ convertedpixels[k*4+1] = inpixels[i][k*bytesperpixel+rgbmap[1]];
+ convertedpixels[k*4+2] = inpixels[i][k*bytesperpixel+rgbmap[2]];
convertedpixels[k*4+3] = 255;
}
if (loadmodel->brushq3.num_lightmapmergepower > 0)
if (!loadmodel->brushq3.data_lightmaps[lightmapindex])
{
// create a lightmap only as large as necessary to hold the
- // remaining 128x128 blocks
+ // remaining size*size blocks
// if there are multiple merged lightmap textures then they will
// all be full size except the last one which may be smaller
// because it only needs to the remaining blocks, and it will often
;
for (mergeheight = 1;mergewidth*mergeheight < j && mergeheight < (1 << power);mergeheight *= 2)
;
- Con_DPrintf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*128, mergeheight*128, min(j, mergewidth*mergeheight), mergewidth*mergeheight);
- loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * 128, mergeheight * 128, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
+ if (developer_loading.integer)
+ Con_Printf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*size, mergeheight*size, min(j, mergewidth*mergeheight), mergewidth*mergeheight);
+ loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
if (loadmodel->brushq3.data_deluxemaps)
- loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * 128, mergeheight * 128, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
+ loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
}
- mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128;
- mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128;
+ mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size;
+ mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size;
j = (i >> loadmodel->brushq3.deluxemapping) & ((1 << power2) - 1);
if (loadmodel->brushq3.deluxemapping && (i & 1))
- R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], convertedpixels, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
+ R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size);
else
- R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
+ R_UpdateTexture(loadmodel->brushq3.data_lightmaps [lightmapindex], convertedpixels, (j % mergewidth) * size, (j / mergewidth) * size, size, size);
}
else
{
// figure out which merged lightmap texture this fits into
if (loadmodel->brushq3.deluxemapping && (i & 1))
- loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), 128, 128, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
+ loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL);
else
- loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), 128, 128, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
+ loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL);
}
}
+
+ Mem_Free(convertedpixels);
+ if(external)
+ {
+ for(i = 0; i < count; ++i)
+ Mem_Free(inpixels[i]);
+ }
}
+typedef struct patchtess_s
+{
+ patchinfo_t info;
+
+ // Auxiliary data used only by patch loading code in Mod_Q3BSP_LoadFaces
+ int surface_id;
+ float lodgroup[6];
+ 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;
+ 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 *originaltexcoordtexture2f;
float *originaltexcoordlightmap2f;
float *v;
+ patchtess_t *patchtess = NULL;
+ int patchtesscount = 0;
+ qboolean again;
in = (q3dface_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
loadmodel->data_surfaces = out;
loadmodel->num_surfaces = count;
+ if(count > 0)
+ patchtess = (patchtess_t*) Mem_Alloc(tempmempool, count * sizeof(*patchtess));
+
i = 0;
oldi = i;
oldin = in;
{
// check face type first
type = LittleLong(in->type);
- if (type != Q3FACETYPE_POLYGON
+ if (type != Q3FACETYPE_FLAT
&& type != Q3FACETYPE_PATCH
&& type != Q3FACETYPE_MESH
&& type != Q3FACETYPE_FLARE)
n = -1;
else if (n >= loadmodel->brushq3.num_originallightmaps)
{
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_originallightmaps);
+ if(loadmodel->brushq3.num_originallightmaps != 0)
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_originallightmaps);
n = -1;
}
else
}
switch(type)
{
- case Q3FACETYPE_POLYGON:
+ case Q3FACETYPE_FLAT:
case Q3FACETYPE_MESH:
// no processing necessary
break;
continue;
}
originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
+
// convert patch to Q3FACETYPE_MESH
xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
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);
- // bound to user limit on vertices
- while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
- {
- if (xtess > ytess)
- xtess--;
- else
- ytess--;
- }
- finalwidth = ((patchsize[0] - 1) * xtess) + 1;
- finalheight = ((patchsize[1] - 1) * ytess) + 1;
- numvertices = finalwidth * finalheight;
- numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
+ 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_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(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].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].originalvertex3f = originalvertex3f;
+ ++patchtesscount;
break;
case Q3FACETYPE_FLARE:
if (developer.integer >= 100)
meshtriangles += out->num_triangles;
}
+ // Fix patches tesselations so that they make no seams
+ do
+ {
+ again = false;
+ for(i = 0; i < patchtesscount; ++i)
+ {
+ for(j = i+1; j < patchtesscount; ++j)
+ {
+ if (!PATCHTESS_SAME_LODGROUP(patchtess[i], patchtess[j]))
+ continue;
+
+ if (Q3PatchAdjustTesselation(3, &patchtess[i].info, patchtess[i].originalvertex3f, &patchtess[j].info, patchtess[j].originalvertex3f) )
+ again = true;
+ }
+ }
+ }
+ while (again);
+
+ // 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;
+
+ 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;
in = oldin;
out = oldout;
out->num_firsttriangle = meshtriangles;
switch(type)
{
- case Q3FACETYPE_POLYGON:
+ case Q3FACETYPE_FLAT:
case Q3FACETYPE_MESH:
// no processing necessary, except for lightmap merging
for (j = 0;j < out->num_vertices;j++)
originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + firstvertex * 2;
originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4;
- // convert patch to Q3FACETYPE_MESH
- xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
- ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
- // bound to user settings
- 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);
- // bound to user limit on vertices
- while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
+
+ xtess = ytess = cxtess = cytess = -1;
+ for(j = 0; j < patchtesscount; ++j)
+ if(patchtess[j].surface_id == i)
+ {
+ 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 == -1)
{
- if (xtess > ytess)
- xtess--;
- else
- ytess--;
+ 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
- xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
- ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
- // bound to user settings
- xtess = bound(r_subdivisions_collision_mintess.integer, xtess, r_subdivisions_collision_maxtess.integer);
- ytess = bound(r_subdivisions_collision_mintess.integer, ytess, r_subdivisions_collision_maxtess.integer);
- // bound to sanity settings
- xtess = bound(1, xtess, 1024);
- ytess = bound(1, ytess, 1024);
- // bound to user limit on vertices
- while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_collision_maxvertices.integer, 262144))
- {
- if (xtess > ytess)
- xtess--;
- else
- ytess--;
- }
- finalwidth = ((patchsize[0] - 1) * xtess) + 1;
- finalheight = ((patchsize[1] - 1) * ytess) + 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->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);
+ Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess);
Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight, 0);
//Mod_SnapVertices(3, out->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), 0.25);
{
// figure out which part of the merged lightmap this fits into
int lightmapindex = LittleLong(in->lightmapindex) >> loadmodel->brushq3.deluxemapping;
- int mergewidth = R_TextureWidth(out->lightmaptexture) / 128;
- int mergeheight = R_TextureHeight(out->lightmaptexture) / 128;
+ int mergewidth = R_TextureWidth(out->lightmaptexture) / loadmodel->brushq3.lightmapsize;
+ int mergeheight = R_TextureHeight(out->lightmaptexture) / loadmodel->brushq3.lightmapsize;
lightmapindex &= mergewidth * mergeheight - 1;
lightmaptcscale[0] = 1.0f / mergewidth;
lightmaptcscale[1] = 1.0f / mergeheight;
//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);
+ // generate ushort elements array if possible
+ if (loadmodel->surfmesh.data_element3s)
+ for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
+ loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
+
// free the no longer needed vertex data
loadmodel->brushq3.num_vertices = 0;
if (loadmodel->brushq3.data_vertex3f)
if (loadmodel->brushq3.data_element3i)
Mem_Free(loadmodel->brushq3.data_element3i);
loadmodel->brushq3.data_element3i = NULL;
+
+ if(patchtess)
+ Mem_Free(patchtess);
}
static void Mod_Q3BSP_LoadModels(lump_t *l)
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_LightPoint(dp_model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
{
int i, j, k, index[3];
float transformed[3], blend1, blend2, blend, stylescale;
q3dlightgrid_t *a, *s;
// scale lighting by lightstyle[0] so that darkmode in dpmod works properly
- stylescale = r_refdef.rtlightstylevalue[0];
+ stylescale = r_refdef.scene.rtlightstylevalue[0];
if (!model->brushq3.num_lightgrid)
{
//Con_Printf("result: ambient %f %f %f diffuse %f %f %f diffusenormal %f %f %f\n", ambientcolor[0], ambientcolor[1], ambientcolor[2], diffusecolor[0], diffusecolor[1], diffusecolor[2], diffusenormal[0], diffusenormal[1], diffusenormal[2]);
}
-static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t point, int markframe)
+static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t point, int markframe)
{
int i;
mleaf_t *leaf;
colbrushf_t *brush;
// find which leaf the point is in
while (node->plane)
- node = node->children[DotProduct(point, node->plane->normal) < node->plane->dist];
+ node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist];
// point trace the brushes
leaf = (mleaf_t *)node;
for (i = 0;i < leaf->numleafbrushes;i++)
// can't do point traces on curves (they have no thickness)
}
-static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
+static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
{
int i, startside, endside;
float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
}
}
-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)
+static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_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;
}
}
-static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
+static void Mod_Q3BSP_TraceBox(dp_model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
{
int i;
float segmentmins[3], segmentmaxs[3];
}
}
-static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
+static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point)
+{
+ int i;
+ int supercontents = 0;
+ q3mbrush_t *brush;
+ // test if the point is inside each brush
+ if (model->brush.submodel)
+ {
+ // submodels are effectively one leaf
+ for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+ if (brush->colbrushf && Collision_PointInsideBrushFloat(point, brush->colbrushf))
+ supercontents |= brush->colbrushf->supercontents;
+ }
+ else
+ {
+ mnode_t *node = model->brush.data_nodes;
+ mleaf_t *leaf;
+ // find which leaf the point is in
+ while (node->plane)
+ node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist];
+ leaf = (mleaf_t *)node;
+ // now check the brushes in the leaf
+ for (i = 0;i < leaf->numleafbrushes;i++)
+ {
+ brush = model->brush.data_brushes + leaf->firstleafbrush[i];
+ if (brush->colbrushf && Collision_PointInsideBrushFloat(point, brush->colbrushf))
+ supercontents |= brush->colbrushf->supercontents;
+ }
+ }
+ return supercontents;
+}
+
+static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents)
{
int supercontents = 0;
if (nativecontents & CONTENTSQ3_SOLID)
return supercontents;
}
-static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
+static int Mod_Q3BSP_NativeContentsFromSuperContents(dp_model_t *model, int supercontents)
{
int nativecontents = 0;
if (supercontents & SUPERCONTENTS_SOLID)
loadmodel->brush.num_leafs = numleafs;
}
-void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
+void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
{
- int i, j, numshadowmeshtriangles;
+ int i, j, numshadowmeshtriangles, lumps;
q3dheader_t *header;
float corner[3], yawradius, modelradius;
msurface_t *surface;
mod->numskins = 1;
header = (q3dheader_t *)buffer;
+ if((char *) bufferend < (char *) buffer + sizeof(q3dheader_t))
+ Host_Error("Mod_Q3BSP_Load: %s is smaller than its header", mod->name);
i = LittleLong(header->version);
- if (i != Q3BSPVERSION)
+ 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;
- mod->brush.ismcbsp = false;
- if (loadmodel->isworldmodel)
- {
- Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
- Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
- }
mod->soundfromcenter = true;
mod->TraceBox = Mod_Q3BSP_TraceBox;
+ mod->PointSuperContents = Mod_Q3BSP_PointSuperContents;
mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents;
mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents;
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;
// swap all the lumps
header->ident = LittleLong(header->ident);
header->version = LittleLong(header->version);
- for (i = 0;i < Q3HEADER_LUMPS;i++)
+ lumps = (header->version == Q3BSPVERSION_LIVE) ? Q3HEADER_LUMPS_LIVE : Q3HEADER_LUMPS;
+ for (i = 0;i < lumps;i++)
{
- header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
- header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
+ j = (header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs));
+ if((char *) bufferend < (char *) buffer + j)
+ Host_Error("Mod_Q3BSP_Load: %s has a lump that starts outside the file!", mod->name);
+ j += (header->lumps[i].filelen = LittleLong(header->lumps[i].filelen));
+ if((char *) bufferend < (char *) buffer + j)
+ Host_Error("Mod_Q3BSP_Load: %s has a lump that ends outside the file!", mod->name);
+ }
+ /*
+ * NO, do NOT clear them!
+ * they contain actual data referenced by other stuff.
+ * Instead, before using the advertisements lump, check header->versio
+ * again!
+ * Sorry, but otherwise it breaks memory of the first lump.
+ for (i = lumps;i < Q3HEADER_LUMPS_MAX;i++)
+ {
+ header->lumps[i].fileofs = 0;
+ header->lumps[i].filelen = 0;
}
+ */
mod->brush.qw_md4sum = 0;
mod->brush.qw_md4sum2 = 0;
- for (i = 0;i < Q3HEADER_LUMPS;i++)
+ for (i = 0;i < lumps;i++)
{
if (i == Q3LUMP_ENTITIES)
continue;
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]);
Mod_Q3BSP_LoadTextures(&header->lumps[Q3LUMP_TEXTURES]);
Mod_Q3BSP_LoadPlanes(&header->lumps[Q3LUMP_PLANES]);
- Mod_Q3BSP_LoadBrushSides(&header->lumps[Q3LUMP_BRUSHSIDES]);
+ if (header->version == Q3BSPVERSION_IG)
+ Mod_Q3BSP_LoadBrushSides_IG(&header->lumps[Q3LUMP_BRUSHSIDES]);
+ else
+ Mod_Q3BSP_LoadBrushSides(&header->lumps[Q3LUMP_BRUSHSIDES]);
Mod_Q3BSP_LoadBrushes(&header->lumps[Q3LUMP_BRUSHES]);
Mod_Q3BSP_LoadEffects(&header->lumps[Q3LUMP_EFFECTS]);
Mod_Q3BSP_LoadVertices(&header->lumps[Q3LUMP_VERTICES]);
// make a single combined shadow mesh to allow optimized shadow volume creation
numshadowmeshtriangles = 0;
- for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
+ if (cls.state != ca_dedicated)
{
- surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
- numshadowmeshtriangles += surface->num_triangles;
+ for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
+ {
+ surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
+ numshadowmeshtriangles += surface->num_triangles;
+ }
+ loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
+ for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
+ if (surface->num_triangles > 0)
+ Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
+ loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false);
+ Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
}
- loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
- for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
- if (surface->num_triangles > 0)
- Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
- loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false);
- Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
loadmodel->brush.num_leafs = 0;
Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes);
- if (loadmodel->isworldmodel)
- {
- // clear out any stale submodels or worldmodels lying around
- // if we did this clear before now, an error might abort loading and
- // leave things in a bad state
- Mod_RemoveStaleWorldModels(loadmodel);
- }
-
mod = loadmodel;
for (i = 0;i < loadmodel->brush.numsubmodels;i++)
{
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
- sprintf(name, "*%i", i);
- mod = Mod_FindName(name);
+ dpsnprintf(name, sizeof(name), "*%i", i);
+ 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);
+ // enlarge the bounding box to enclose all geometry of this model,
+ // because q3map2 sometimes lies (mostly to affect the lightgrid),
+ // which can in turn mess up the farclip (as well as culling when
+ // outside the level - an unimportant concern)
+
+ //printf("Editing model %d... BEFORE re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]);
+ for (j = 0;j < mod->nummodelsurfaces;j++)
+ {
+ const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface;
+ const float *v = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex;
+ int k;
+ if (!surface->num_vertices)
+ continue;
+ for (k = 0;k < surface->num_vertices;k++, v += 3)
+ {
+ mod->normalmins[0] = min(mod->normalmins[0], v[0]);
+ mod->normalmins[1] = min(mod->normalmins[1], v[1]);
+ mod->normalmins[2] = min(mod->normalmins[2], v[2]);
+ mod->normalmaxs[0] = max(mod->normalmaxs[0], v[0]);
+ mod->normalmaxs[1] = max(mod->normalmaxs[1], v[1]);
+ mod->normalmaxs[2] = max(mod->normalmaxs[2], v[2]);
+ }
+ }
+ //printf("Editing model %d... AFTER re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]);
corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
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;
}
}
-void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend)
+void Mod_IBSP_Load(dp_model_t *mod, void *buffer, void *bufferend)
{
int i = LittleLong(((int *)buffer)[1]);
- if (i == Q3BSPVERSION)
+ if (i == Q3BSPVERSION || i == Q3BSPVERSION_IG || i == Q3BSPVERSION_LIVE)
Mod_Q3BSP_Load(mod,buffer, bufferend);
else if (i == Q2BSPVERSION)
Mod_Q2BSP_Load(mod,buffer, bufferend);
Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i);
}
-void Mod_MAP_Load(model_t *mod, void *buffer, void *bufferend)
+void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend)
{
Host_Error("Mod_MAP_Load: not yet implemented");
}
-qboolean Mod_CanSeeBox_Trace(int numsamples, float t, model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX)
+qboolean Mod_CanSeeBox_Trace(int numsamples, float t, dp_model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX)
{
// we already have done PVS culling at this point...
// so we don't need to do it again.