X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=model_brush.c;h=6cc700f199ebffd1fe2b9ee64e3100fe919392dc;hb=b290a6cace16fb813438af50629fb7876862294e;hp=47765028630ca56e2897dcc5073e0a2d4e2b2bbb;hpb=4f779cc71b416cfcac6290f6b616e58d65ef1730;p=xonotic%2Fdarkplaces.git diff --git a/model_brush.c b/model_brush.c index 47765028..6cc700f1 100644 --- a/model_brush.c +++ b/model_brush.c @@ -43,6 +43,7 @@ cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxv 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, ..."}; static texture_t mod_q1bsp_texture_solid; static texture_t mod_q1bsp_texture_sky; @@ -69,6 +70,7 @@ void Mod_BrushInit(void) Cvar_RegisterVariable(&mod_q3bsp_curves_collisions); Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline); Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush); + Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower); memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid)); strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name)); @@ -614,6 +616,7 @@ RecursiveHullCheckTraceInfo_t; #define HULLCHECKSTATE_SOLID 1 #define HULLCHECKSTATE_DONE 2 +extern cvar_t collision_prefernudgedfraction; static int Mod_Q1BSP_RecursiveHullCheck(RecursiveHullCheckTraceInfo_t *t, int num, double p1f, double p2f, double p1[3], double p2[3]) { // status variables, these don't need to be saved on the stack when @@ -768,6 +771,9 @@ loc0: midf = (t1 - DIST_EPSILON) / (t1 - t2); t->trace->fraction = bound(0, midf, 1); + if (collision_prefernudgedfraction.integer) + t->trace->realfraction = t->trace->fraction; + #if COLLISIONPARANOID >= 3 Con_Print("D"); #endif @@ -982,6 +988,76 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm #endif } +static int Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(mnode_t *node, double p1[3], double p2[3]) +{ + double t1, t2; + double midf, mid[3]; + int ret, side; + + // check for empty + while (node->plane) + { + // find the point distances + mplane_t *plane = node->plane; + if (plane->type < 3) + { + t1 = p1[plane->type] - plane->dist; + t2 = p2[plane->type] - plane->dist; + } + else + { + t1 = DotProduct (plane->normal, p1) - plane->dist; + t2 = DotProduct (plane->normal, p2) - plane->dist; + } + + if (t1 < 0) + { + if (t2 < 0) + { + node = node->children[1]; + continue; + } + side = 1; + } + else + { + if (t2 >= 0) + { + node = node->children[0]; + continue; + } + side = 0; + } + + midf = t1 / (t1 - t2); + VectorLerp(p1, midf, p2, mid); + + // recurse both sides, front side first + // return 2 if empty is followed by solid (hit something) + // do not return 2 if both are solid or both empty, + // or if start is solid and end is empty + // as these degenerate cases usually indicate the eye is in solid and + // should see the target point anyway + ret = Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ], p1, mid); + if (ret != 0) + return ret; + ret = Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ^ 1], mid, p2); + if (ret != 1) + return ret; + return 2; + } + return ((mleaf_t *)node)->clusterindex < 0; +} + +static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end) +{ + // this function currently only supports same size start and end + double tracestart[3], traceend[3]; + VectorCopy(start, tracestart); + VectorCopy(end, traceend); + 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) { int side; @@ -1117,9 +1193,17 @@ middle sample (the one which was requested) void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal) { - Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2] + 0.125, p[2] - 65536); // pretend lighting is coming down from above (due to lack of a lightgrid to know primary lighting direction) VectorSet(diffusenormal, 0, 0, 1); + + if (!model->brushq1.lightdata) + { + VectorSet(ambientcolor, 1, 1, 1); + VectorSet(diffusecolor, 0, 0, 0); + return; + } + + Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2] + 0.125, p[2] - 65536); } static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char *inend, unsigned char *out, unsigned char *outend) @@ -1130,7 +1214,7 @@ static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char { if (in == inend) { - Con_Printf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart); + Con_Printf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); return; } c = *in++; @@ -1140,14 +1224,14 @@ static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char { if (in == inend) { - Con_Printf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart); + Con_Printf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); return; } for (c = *in++;c > 0;c--) { if (out == outend) { - Con_Printf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart); + Con_Printf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart)); return; } *out++ = 0; @@ -1264,10 +1348,11 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) tx->skinframerate = 1; tx->currentskinframe = tx->skinframes; tx->skinframes[0].base = r_texture_notexture; + tx->backgroundcurrentskinframe = tx->backgroundskinframes; tx->basematerialflags = 0; if (i == loadmodel->num_textures - 1) { - tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES; + tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW; tx->supercontents = mod_q1bsp_texture_water.supercontents; tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags; } @@ -1398,7 +1483,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) if (strncmp(tx->name,"*lava",5) && strncmp(tx->name,"*teleport",9) && strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture - tx->basematerialflags |= MATERIALFLAG_WATERALPHA; + tx->basematerialflags |= MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW; if (!strncmp(tx->name, "*lava", 5)) { tx->supercontents = mod_q1bsp_texture_lava.supercontents; @@ -1414,13 +1499,13 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) tx->supercontents = mod_q1bsp_texture_water.supercontents; tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags; } - tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES; + tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW; } else if (tx->name[0] == 's' && tx->name[1] == 'k' && tx->name[2] == 'y') { tx->supercontents = mod_q1bsp_texture_sky.supercontents; tx->surfaceflags = mod_q1bsp_texture_sky.surfaceflags; - tx->basematerialflags |= MATERIALFLAG_SKY; + tx->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; } else { @@ -1429,7 +1514,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) tx->basematerialflags |= MATERIALFLAG_WALL; } if (tx->skinframes[0].fog) - tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT; + tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; // start out with no animation tx->currentframe = tx; @@ -1601,7 +1686,7 @@ static void Mod_Q1BSP_LoadLighting(lump_t *l) else if (filesize == 8) Con_Print("Empty .lit file, ignoring\n"); else - Con_Printf("Corrupt .lit file (file size %i bytes, should be %i bytes), ignoring\n", filesize, 8 + l->filelen * 3); + Con_Printf("Corrupt .lit file (file size %i bytes, should be %i bytes), ignoring\n", (int) filesize, (int) (8 + l->filelen * 3)); if (data) { Mem_Free(data); @@ -2255,8 +2340,33 @@ static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *paren node->parent = parent; if (node->plane) { + // this is a node, recurse to children Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[0], node); Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[1], node); + // combine supercontents of children + node->combinedsupercontents = node->children[0]->combinedsupercontents | node->children[1]->combinedsupercontents; + } + else + { + int j; + mleaf_t *leaf = (mleaf_t *)node; + // if this is a leaf, calculate supercontents mask from all collidable + // primitives in the leaf (brushes and collision surfaces) + // also flag if the leaf contains any collision surfaces + leaf->combinedsupercontents = 0; + // combine the supercontents values of all brushes in this leaf + for (j = 0;j < leaf->numleafbrushes;j++) + leaf->combinedsupercontents |= loadmodel->brush.data_brushes[leaf->firstleafbrush[j]].texture->supercontents; + // check if this leaf contains any collision surfaces (q3 patches) + for (j = 0;j < leaf->numleafsurfaces;j++) + { + msurface_t *surface = loadmodel->data_surfaces + leaf->firstleafsurface[j]; + if (surface->num_collisiontriangles) + { + leaf->containscollisionsurfaces = true; + leaf->combinedsupercontents |= surface->texture->supercontents; + } + } } } @@ -2338,7 +2448,7 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l) out->numleafsurfaces = LittleShort(in->nummarksurfaces); if (out->firstleafsurface < 0 || LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces) { - Con_Printf("Mod_Q1BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", out->firstleafsurface, out->firstleafsurface + out->numleafsurfaces, 0, loadmodel->brush.num_leafsurfaces); + Con_Printf("Mod_Q1BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", (int)(out->firstleafsurface - loadmodel->brush.data_leafsurfaces), (int)(out->firstleafsurface + out->numleafsurfaces - loadmodel->brush.data_leafsurfaces), 0, loadmodel->brush.num_leafsurfaces); out->firstleafsurface = NULL; out->numleafsurfaces = 0; } @@ -2364,6 +2474,26 @@ static void Mod_Q1BSP_LoadLeafs(lump_t *l) } } +qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void) +{ + int i, j; + mleaf_t *leaf; + const unsigned char *pvs; + // 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)) + { + pvs = loadmodel->brush.data_pvsclusters + leaf->clusterindex * loadmodel->brush.num_pvsclusterbytes; + for (j = 0;j < loadmodel->brush.num_leafs;j++) + if (CHECKPVSBIT(pvs, loadmodel->brush.data_leafs[j].clusterindex) && loadmodel->brush.data_leafs[j].contents == CONTENTS_EMPTY) + return true; + } + } + return false; +} + static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo) { dclipnode_t *in, *out; @@ -3226,6 +3356,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->soundfromcenter = true; mod->TraceBox = Mod_Q1BSP_TraceBox; + mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight; mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents; mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents; mod->brush.GetPVS = Mod_Q1BSP_GetPVS; @@ -3280,8 +3411,8 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) Mod_Q1BSP_LoadNodes(&header->lumps[LUMP_NODES]); Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES], &hullinfo); - if (!mod->brushq1.lightdata) - mod->brush.LightPoint = NULL; + // check if the map supports transparent water rendering + loadmodel->brush.supportwateralpha = Mod_Q1BSP_CheckWaterAlphaSupport(); if (mod->brushq1.data_compressedpvs) Mem_Free(mod->brushq1.data_compressedpvs); @@ -3390,6 +3521,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->DrawLight = R_Q1BSP_DrawLight; if (i != 0) { + mod->brush.TraceLineOfSight = NULL; mod->brush.GetPVS = NULL; mod->brush.FatPVS = NULL; mod->brush.BoxTouchingPVS = NULL; @@ -4118,7 +4250,7 @@ static void Mod_Q3BSP_LoadShaders(void) { int i; layer->numframes = min(numparameters - 2, TEXTURE_MAXFRAMES); - layer->framerate = atoi(parameter[1]); + layer->framerate = atof(parameter[1]); for (i = 0;i < layer->numframes;i++) strlcpy(layer->texturename[i], parameter[i + 2], sizeof(layer->texturename)); } @@ -4233,8 +4365,10 @@ static void Mod_Q3BSP_LoadShaders(void) shader->surfaceparms |= Q3SURFACEPARM_WATER; else if (!strcasecmp(parameter[1], "pointlight")) shader->surfaceparms |= Q3SURFACEPARM_POINTLIGHT; + else if (!strcasecmp(parameter[1], "antiportal")) + shader->surfaceparms |= Q3SURFACEPARM_ANTIPORTAL; else - Con_Printf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[fileindex], parameter[1]); + Con_DPrintf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[fileindex], parameter[1]); } else if (!strcasecmp(parameter[0], "sky") && numparameters >= 2) { @@ -4269,8 +4403,11 @@ static void Mod_Q3BSP_LoadShaders(void) // identify if this is a blended terrain shader or similar if (shader->numlayers) { + shader->backgroundlayer = NULL; shader->primarylayer = shader->layers + 0; - if ((shader->layers[1].blendfunc[0] == GL_SRC_ALPHA && shader->layers[1].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA) || shader->layers[1].alphatest) + if ((shader->layers[0].blendfunc[0] == GL_ONE && shader->layers[0].blendfunc[1] == GL_ZERO && !shader->layers[0].alphatest) + && ((shader->layers[1].blendfunc[0] == GL_SRC_ALPHA && shader->layers[1].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA && !shader->layers[0].alphatest) + || (shader->layers[1].blendfunc[0] == GL_ONE && shader->layers[1].blendfunc[1] == GL_ZERO && shader->layers[1].alphatest))) { // terrain blending or other effects shader->backgroundlayer = shader->layers + 0; @@ -4278,7 +4415,10 @@ static void Mod_Q3BSP_LoadShaders(void) } // now see if the lightmap came first, and if so choose the second texture instead if (!strcasecmp(shader->primarylayer->texturename[0], "$lightmap")) + { + shader->backgroundlayer = NULL; shader->primarylayer = shader->layers + 1; + } } } Mem_Free(f); @@ -4327,7 +4467,7 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l) out->basematerialflags = 0; if (shader->surfaceparms & Q3SURFACEPARM_SKY) { - out->basematerialflags |= MATERIALFLAG_SKY; + out->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; if (shader->skyboxname[0]) { // quake3 seems to append a _ to the skybox name, so this must do so as well @@ -4335,17 +4475,21 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l) } } else if ((out->surfaceflags & Q3SURFACEFLAG_NODRAW) || shader->numlayers == 0) - out->basematerialflags |= MATERIALFLAG_NODRAW; + out->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW; else if (shader->surfaceparms & Q3SURFACEPARM_LAVA) - out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_FULLBRIGHT; + out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOSHADOW; else if (shader->surfaceparms & Q3SURFACEPARM_SLIME) - out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_WATERALPHA; + out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW; else if (shader->surfaceparms & Q3SURFACEPARM_WATER) - out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_WATERALPHA; + out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW; else out->basematerialflags |= MATERIALFLAG_WALL; if (shader->layers[0].alphatest) - out->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_TRANSPARENT; + out->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; + if (shader->textureflags & Q3TEXTUREFLAG_TWOSIDED) + out->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE; + if (shader->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) + out->basematerialflags |= MATERIALFLAG_NOSHADOW; out->customblendfunc[0] = GL_ONE; out->customblendfunc[1] = GL_ZERO; if (shader->numlayers > 0) @@ -4376,13 +4520,13 @@ Q3 shader blendfuncs actually used in the game (* = supported by DP) if (shader->layers[0].blendfunc[0] != GL_ONE || shader->layers[0].blendfunc[1] != GL_ZERO) { if (shader->layers[0].blendfunc[0] == GL_ONE && shader->layers[0].blendfunc[1] == GL_ONE) - out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT; + out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; else if (shader->layers[0].blendfunc[0] == GL_SRC_ALPHA && shader->layers[0].blendfunc[1] == GL_ONE) - out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT; + out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; else if (shader->layers[0].blendfunc[0] == GL_SRC_ALPHA && shader->layers[0].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA) - out->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT; + out->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; else - out->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT; + out->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW; } } if (!shader->lighting) @@ -4394,18 +4538,29 @@ Q3 shader blendfuncs actually used in the game (* = supported by DP) out->skinframerate = shader->primarylayer->framerate; for (j = 0;j < shader->primarylayer->numframes;j++) if (!Mod_LoadSkinFrame(&out->skinframes[j], shader->primarylayer->texturename[j], ((shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (shader->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP) | (shader->primarylayer->clampmap ? TEXF_CLAMP : 0), false, true)) - Con_Printf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->primarylayer->texturename[j], j, out->name); + Con_DPrintf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->primarylayer->texturename[j], j, out->name); + } + if (shader->backgroundlayer && cls.state != ca_dedicated) + { + int j; + out->backgroundnumskinframes = shader->backgroundlayer->numframes; + out->backgroundskinframerate = shader->backgroundlayer->framerate; + for (j = 0;j < shader->backgroundlayer->numframes;j++) + if (!Mod_LoadSkinFrame(&out->backgroundskinframes[j], shader->backgroundlayer->texturename[j], ((shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (shader->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP) | (shader->backgroundlayer->clampmap ? TEXF_CLAMP : 0), false, true)) + Con_DPrintf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->backgroundlayer->texturename[j], j, out->name); } } + else if (!strcmp(out->name, "noshader")) + out->surfaceparms = 0; else { c++; Con_DPrintf("%s: No shader found for texture \"%s\"\n", loadmodel->name, out->name); out->surfaceparms = 0; if (out->surfaceflags & Q3SURFACEFLAG_NODRAW) - out->basematerialflags |= MATERIALFLAG_NODRAW; + out->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW; else if (out->surfaceflags & Q3SURFACEFLAG_SKY) - out->basematerialflags |= MATERIALFLAG_SKY; + out->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW; else out->basematerialflags |= MATERIALFLAG_WALL; // these are defaults @@ -4418,11 +4573,12 @@ Q3 shader blendfuncs actually used in the game (* = supported by DP) // out->surfaceparms |= Q3SURFACEPARM_TRANS; if (cls.state != ca_dedicated) if (!Mod_LoadSkinFrame(&out->skinframes[0], out->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true)) - Con_Printf("%s: could not load texture for missing shader \"%s\"\n", loadmodel->name, out->name); + Con_DPrintf("%s: could not load texture for missing shader \"%s\"\n", loadmodel->name, out->name); } // init the animation variables out->currentframe = out; out->currentskinframe = &out->skinframes[0]; + out->backgroundcurrentskinframe = &out->backgroundskinframes[0]; } if (c) Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c); @@ -4625,42 +4781,62 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) } } -static void Mod_Q3BSP_LoadLightmaps(lump_t *l) +static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) { q3dlightmap_t *in; - rtexture_t **out; - int i, count; + int i, j, count, power, power2, mask, endlightmap; unsigned char *c; if (!l->filelen) return; + 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); - out = (rtexture_t **)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); - - loadmodel->brushq3.data_lightmaps = out; - loadmodel->brushq3.num_lightmaps = count; - - // deluxemapped q3bsp files have an even number of lightmaps, and surfaces - // always index even numbered ones (0, 2, 4, ...), the odd numbered - // lightmaps are the deluxemaps (light direction textures), so if we - // encounter any odd numbered lightmaps it is not a deluxemapped bsp, it - // is also not a deluxemapped bsp if it has an odd number of lightmaps or - // less than 2 - loadmodel->brushq3.deluxemapping = true; + loadmodel->brushq3.num_originallightmaps = count; + + // now check the surfaces to see if any of them index an odd numbered + // lightmap, if so this is not a deluxemapped bsp file + // + // also check what lightmaps are actually used, because q3map2 sometimes + // (always?) makes an unused one at the end, which + // 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. + loadmodel->brushq3.deluxemapping = !(count & 1); loadmodel->brushq3.deluxemapping_modelspace = true; - if (count < 2 || (count & 1)) + endlightmap = 0; + if (loadmodel->brushq3.deluxemapping) + { + int facecount = faceslump->filelen / sizeof(q3dface_t); + q3dface_t *faces = (q3dface_t *)(mod_base + faceslump->fileofs); + for (i = 0;i < facecount;i++) + { + j = LittleLong(faces[i].lightmapindex); + if (j >= 0) + { + endlightmap = max(endlightmap, j + 1); + if ((j & 1) || j + 1 >= count) + { + loadmodel->brushq3.deluxemapping = false; + break; + } + } + } + } + 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 (count == 2) + if (endlightmap == 1 && count == 2) { - c = in[count - 1].rgb; + c = in[1].rgb; for (i = 0;i < 128*128*3;i++) if (c[i]) break; @@ -4671,10 +4847,39 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l) } } - // further deluxemapping detection is done in Mod_Q3BSP_LoadFaces + Con_DPrintf("%s is %sdeluxemapped\n", loadmodel->name, loadmodel->brushq3.deluxemapping ? "" : "not "); - for (i = 0;i < count;i++, in++, out++) - *out = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", i), 128, 128, in->rgb, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + // figure out what the most reasonable merge power is within limits + loadmodel->brushq3.num_lightmapmergepower = 0; + for (power = 1;power <= mod_q3bsp_lightmapmergepower.integer && (1 << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> loadmodel->brushq3.deluxemapping);power++) + loadmodel->brushq3.num_lightmapmergepower = power; + 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); + loadmodel->brushq3.data_lightmaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_mergedlightmaps * sizeof(rtexture_t *)); + if (loadmodel->brushq3.deluxemapping) + loadmodel->brushq3.data_deluxemaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_mergedlightmaps * sizeof(rtexture_t *)); + + j = 128 << loadmodel->brushq3.num_lightmapmergepower; + if (loadmodel->brushq3.data_lightmaps) + for (i = 0;i < loadmodel->brushq3.num_mergedlightmaps;i++) + loadmodel->brushq3.data_lightmaps[i] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", i), j, j, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + + if (loadmodel->brushq3.data_deluxemaps) + for (i = 0;i < loadmodel->brushq3.num_mergedlightmaps;i++) + loadmodel->brushq3.data_deluxemaps[i] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", i), j, j, NULL, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + + power = loadmodel->brushq3.num_lightmapmergepower; + power2 = power * 2; + mask = (1 << power) - 1; + for (i = 0;i < count;i++) + { + j = i >> loadmodel->brushq3.deluxemapping; + if (loadmodel->brushq3.deluxemapping && (i & 1)) + R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[j >> power2], in[i].rgb, (j & mask) * 128, ((j >> power) & mask) * 128, 128, 128); + else + R_UpdateTexture(loadmodel->brushq3.data_lightmaps [j >> power2], in[i].rgb, (j & mask) * 128, ((j >> power) & mask) * 128, 128, 128); + } } static void Mod_Q3BSP_LoadFaces(lump_t *l) @@ -4682,6 +4887,7 @@ 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; + float lightmaptcbase[2], lightmaptcscale; //int *originalelement3i; //int *originalneighbor3i; float *originalvertex3f; @@ -4702,21 +4908,6 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) loadmodel->data_surfaces = out; loadmodel->num_surfaces = count; - // now that we have surfaces to look at, see if any of them index an odd numbered lightmap, if so this is not a deluxemapped bsp file - if (loadmodel->brushq3.deluxemapping) - { - for (i = 0;i < count;i++) - { - n = LittleLong(in[i].lightmapindex); - if (n >= 0 && ((n & 1) || n + 1 >= loadmodel->brushq3.num_lightmaps)) - { - loadmodel->brushq3.deluxemapping = false; - break; - } - } - } - Con_DPrintf("%s is %sdeluxemapped\n", loadmodel->name, loadmodel->brushq3.deluxemapping ? "" : "not "); - i = 0; oldi = i; oldin = in; @@ -4754,26 +4945,25 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) out->effect = NULL; else out->effect = loadmodel->brushq3.data_effects + n; - n = LittleLong(in->lightmapindex); - if (n >= loadmodel->brushq3.num_lightmaps) - { - Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_lightmaps); - n = -1; - } - else if (n < 0) - n = -1; - if (n == -1) + + if (cls.state != ca_dedicated) { out->lightmaptexture = NULL; out->deluxemaptexture = r_texture_blanknormalmap; - } - else - { - out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n]; - if (loadmodel->brushq3.deluxemapping) - out->deluxemaptexture = loadmodel->brushq3.data_lightmaps[n+1]; + n = LittleLong(in->lightmapindex); + if (n < 0) + 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); + n = -1; + } else - out->deluxemaptexture = r_texture_blanknormalmap; + { + out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)]; + if (loadmodel->brushq3.deluxemapping) + out->deluxemaptexture = loadmodel->brushq3.data_deluxemaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)]; + } } firstvertex = LittleLong(in->firstvertex); @@ -4864,7 +5054,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) { case Q3FACETYPE_POLYGON: case Q3FACETYPE_MESH: - // no processing necessary + // no processing necessary, except for lightmap merging for (j = 0;j < out->num_vertices;j++) { (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[j * 3 + 0] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 0]; @@ -4994,6 +5184,20 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) VectorClear(out->maxs); if (out->num_vertices) { + int lightmapindex = LittleLong(in->lightmapindex); + if (lightmapindex >= 0 && cls.state != ca_dedicated) + { + lightmapindex >>= loadmodel->brushq3.deluxemapping; + lightmaptcscale = 1.0f / loadmodel->brushq3.num_lightmapmerge; + lightmaptcbase[0] = ((lightmapindex ) & (loadmodel->brushq3.num_lightmapmerge - 1)) * lightmaptcscale; + lightmaptcbase[1] = ((lightmapindex >> loadmodel->brushq3.num_lightmapmergepower) & (loadmodel->brushq3.num_lightmapmerge - 1)) * lightmaptcscale; + // modify the lightmap texcoords to match this region of the merged lightmap + for (j = 0, v = loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex;j < out->num_vertices;j++, v += 2) + { + v[0] = v[0] * lightmaptcscale + lightmaptcbase[0]; + v[1] = v[1] * lightmaptcscale + lightmaptcbase[1]; + } + } VectorCopy((loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), out->mins); VectorCopy((loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), out->maxs); for (j = 1, v = (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex) + 3;j < out->num_vertices;j++, v += 3) @@ -5245,9 +5449,9 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l) if (l->filelen) { if (l->filelen < count * (int)sizeof(*in)) - Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)", l->filelen, count * sizeof(*in), loadmodel->brushq3.num_lightgrid_dimensions[0], loadmodel->brushq3.num_lightgrid_dimensions[1], loadmodel->brushq3.num_lightgrid_dimensions[2]); + Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)", l->filelen, (int)(count * sizeof(*in)), loadmodel->brushq3.num_lightgrid_dimensions[0], loadmodel->brushq3.num_lightgrid_dimensions[1], loadmodel->brushq3.num_lightgrid_dimensions[2]); if (l->filelen != count * (int)sizeof(*in)) - Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i", count * sizeof(*in), l->filelen); + Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i\n", (int)(count * sizeof(*in)), l->filelen); out = (q3dlightgrid_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); loadmodel->brushq3.data_lightgrid = out; loadmodel->brushq3.num_lightgrid = count; @@ -5288,7 +5492,7 @@ static void Mod_Q3BSP_LoadPVS(lump_t *l) Host_Error("Mod_Q3BSP_LoadPVS: (chainlength = %i) < ((numclusters = %i) + 7) / 8", loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.num_pvsclusters); totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters; if (l->filelen < totalchains + (int)sizeof(*in)) - Host_Error("Mod_Q3BSP_LoadPVS: lump too small ((numclusters = %i) * (chainlength = %i) + sizeof(q3dpvs_t) == %i bytes, lump is %i bytes)", loadmodel->brush.num_pvsclusters, loadmodel->brush.num_pvsclusterbytes, totalchains + sizeof(*in), l->filelen); + Host_Error("Mod_Q3BSP_LoadPVS: lump too small ((numclusters = %i) * (chainlength = %i) + sizeof(q3dpvs_t) == %i bytes, lump is %i bytes)", loadmodel->brush.num_pvsclusters, loadmodel->brush.num_pvsclusterbytes, (int)(totalchains + sizeof(*in)), l->filelen); loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains); memcpy(loadmodel->brush.data_pvsclusters, (unsigned char *)(in + 1), totalchains); @@ -5392,6 +5596,9 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, // walk the tree until we hit a leaf, recursing for any split cases while (node->plane) { + // abort if this part of the bsp tree can not be hit by this trace +// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) +// return; plane = node->plane; // axial planes are much more common than non-axial, so an optimized // axial case pays off here @@ -5428,6 +5635,9 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, return; } } + // abort if this part of the bsp tree can not be hit by this trace +// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) +// return; // hit a leaf nodesegmentmins[0] = min(start[0], end[0]) - 1; nodesegmentmins[1] = min(start[1], end[1]) - 1; @@ -5447,7 +5657,7 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, } } // can't do point traces on curves (they have no thickness) - if (mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end)) + if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end)) { // line trace the curves for (i = 0;i < leaf->numleafsurfaces;i++) @@ -5474,6 +5684,9 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model // walk the tree until we hit a leaf, recursing for any split cases while (node->plane) { + // abort if this part of the bsp tree can not be hit by this trace +// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) +// return; plane = node->plane; // axial planes are much more common than non-axial, so an optimized // axial case pays off here @@ -5506,6 +5719,9 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model // take whichever side the segment box is on node = node->children[sides - 1]; } + // abort if this part of the bsp tree can not be hit by this trace +// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) +// return; nodesegmentmins[0] = max(segmentmins[0], node->mins[0] - 1); nodesegmentmins[1] = max(segmentmins[1], node->mins[1] - 1); nodesegmentmins[2] = max(segmentmins[2], node->mins[2] - 1); @@ -5523,7 +5739,7 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush, brush); } } - if (mod_q3bsp_curves_collisions.integer) + if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer) { for (i = 0;i < leaf->numleafsurfaces;i++) { @@ -5708,6 +5924,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) mod->soundfromcenter = true; mod->TraceBox = Mod_Q3BSP_TraceBox; + mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight; mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents; mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents; mod->brush.GetPVS = Mod_Q1BSP_GetPVS; @@ -5756,7 +5973,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) Mod_Q3BSP_LoadEffects(&header->lumps[Q3LUMP_EFFECTS]); Mod_Q3BSP_LoadVertices(&header->lumps[Q3LUMP_VERTICES]); Mod_Q3BSP_LoadTriangles(&header->lumps[Q3LUMP_TRIANGLES]); - Mod_Q3BSP_LoadLightmaps(&header->lumps[Q3LUMP_LIGHTMAPS]); + Mod_Q3BSP_LoadLightmaps(&header->lumps[Q3LUMP_LIGHTMAPS], &header->lumps[Q3LUMP_FACES]); Mod_Q3BSP_LoadFaces(&header->lumps[Q3LUMP_FACES]); Mod_Q3BSP_LoadModels(&header->lumps[Q3LUMP_MODELS]); Mod_Q3BSP_LoadLeafBrushes(&header->lumps[Q3LUMP_LEAFBRUSHES]); @@ -5770,6 +5987,9 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) // the MakePortals code works fine on the q3bsp data as well Mod_Q1BSP_MakePortals(); + // FIXME: shader alpha should replace r_wateralpha support in q3bsp + loadmodel->brush.supportwateralpha = true; + // 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++) @@ -5814,6 +6034,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) // 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; @@ -5855,6 +6076,8 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend) break; if (j < mod->nummodelsurfaces) mod->DrawSky = R_Q1BSP_DrawSky; + else + mod->DrawSky = NULL; } } @@ -5874,3 +6097,39 @@ void Mod_MAP_Load(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) +{ + // we already have done PVS culling at this point... + // so we don't need to do it again. + + int i; + vec3_t testorigin, mins, maxs; + + testorigin[0] = (minsX[0] + maxsX[0]) * 0.5; + testorigin[1] = (minsX[1] + maxsX[1]) * 0.5; + testorigin[2] = (minsX[2] + maxsX[2]) * 0.5; + + if(model->brush.TraceLineOfSight(model, eye, testorigin)) + return 1; + + // expand the box a little + mins[0] = (t+1) * minsX[0] - t * maxsX[0]; + maxs[0] = (t+1) * maxsX[0] - t * minsX[0]; + mins[1] = (t+1) * minsX[1] - t * maxsX[1]; + maxs[1] = (t+1) * maxsX[1] - t * minsX[1]; + mins[2] = (t+1) * minsX[2] - t * maxsX[2]; + maxs[2] = (t+1) * maxsX[2] - t * minsX[2]; + + for(i = 0; i != numsamples; ++i) + { + testorigin[0] = lhrandom(mins[0], maxs[0]); + testorigin[1] = lhrandom(mins[1], maxs[1]); + testorigin[2] = lhrandom(mins[2], maxs[2]); + + if(model->brush.TraceLineOfSight(model, eye, testorigin)) + return 1; + } + + return 0; +} +