X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=model_brush.c;h=ad41ad38e3bd9246694ae95798ff693c1cff1999;hb=b18cecd7b0c37e696571dcb3abb22a79ad03dae7;hp=6fd45ee75de43255a498c09a61b574287a017fc3;hpb=fa20f76c173d9513a1e5543f840e008324ed71aa;p=xonotic%2Fdarkplaces.git diff --git a/model_brush.c b/model_brush.c index 6fd45ee7..ad41ad38 100644 --- a/model_brush.c +++ b/model_brush.c @@ -42,6 +42,7 @@ cvar_t r_trippy = {0, "r_trippy", "0", "easter egg"}; cvar_t r_fxaa = {CVAR_SAVE, "r_fxaa", "0", "fast approximate anti aliasing"}; cvar_t mod_noshader_default_offsetmapping = {CVAR_SAVE, "mod_noshader_default_offsetmapping", "1", "use offsetmapping by default on all surfaces that are not using q3 shader files"}; cvar_t mod_obj_orientation = {0, "mod_obj_orientation", "1", "fix orientation of OBJ models to the usual conventions (if zero, use coordinates as is)"}; +cvar_t mod_q2bsp_littransparentsurfaces = {0, "mod_q2bsp_littransparentsurfaces", "0", "allows lighting on rain in 3v3gloom3 and other cases of transparent surfaces that have lightmaps that were ignored by quake2"}; cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"}; cvar_t mod_q3bsp_curves_collisions_stride = {0, "mod_q3bsp_curves_collisions_stride", "16", "collisions against curves: optimize performance by doing a combined collision check for this triangle amount first (-1 avoids any box tests)"}; cvar_t mod_q3bsp_curves_stride = {0, "mod_q3bsp_curves_stride", "16", "particle effect collisions against curves: optimize performance by doing a combined collision check for this triangle amount first (-1 avoids any box tests)"}; @@ -89,6 +90,7 @@ void Mod_BrushInit(void) Cvar_RegisterVariable(&r_fxaa); Cvar_RegisterVariable(&mod_noshader_default_offsetmapping); Cvar_RegisterVariable(&mod_obj_orientation); + Cvar_RegisterVariable(&mod_q2bsp_littransparentsurfaces); Cvar_RegisterVariable(&mod_q3bsp_curves_collisions); Cvar_RegisterVariable(&mod_q3bsp_curves_collisions_stride); Cvar_RegisterVariable(&mod_q3bsp_curves_stride); @@ -885,7 +887,7 @@ static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, i } //#endif -static void Mod_Q1BSP_TracePoint(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +static void Mod_Q1BSP_TracePoint(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask) { RecursiveHullCheckTraceInfo_t rhc; @@ -900,22 +902,22 @@ static void Mod_Q1BSP_TracePoint(struct model_s *model, const frameblend_t *fram Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode); } -static void Mod_Q1BSP_TraceLineAgainstSurfaces(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask); +static void Mod_Q1BSP_TraceLineAgainstSurfaces(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask); -static void Mod_Q1BSP_TraceLine(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +static void Mod_Q1BSP_TraceLine(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask) { RecursiveHullCheckTraceInfo_t rhc; if (VectorCompare(start, end)) { - Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask); return; } // sometimes we want to traceline against polygons so we can report the texture that was hit rather than merely a contents, but using this method breaks one of negke's maps so it must be a cvar check... if (sv_gameplayfix_q1bsptracelinereportstexture.integer) { - Mod_Q1BSP_TraceLineAgainstSurfaces(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask); + Mod_Q1BSP_TraceLineAgainstSurfaces(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask); return; } @@ -923,6 +925,7 @@ static void Mod_Q1BSP_TraceLine(struct model_s *model, const frameblend_t *frame memset(trace, 0, sizeof(trace_t)); rhc.trace = trace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; rhc.trace->fraction = 1; rhc.trace->allsolid = true; rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 @@ -940,6 +943,7 @@ static void Mod_Q1BSP_TraceLine(struct model_s *model, const frameblend_t *frame memset(&testtrace, 0, sizeof(trace_t)); rhc.trace = &testtrace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; rhc.trace->fraction = 1; rhc.trace->allsolid = true; VectorCopy(test, rhc.start); @@ -959,7 +963,7 @@ static void Mod_Q1BSP_TraceLine(struct model_s *model, const frameblend_t *frame #endif } -static void Mod_Q1BSP_TraceBox(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask) +static void Mod_Q1BSP_TraceBox(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask) { // this function currently only supports same size start and end double boxsize[3]; @@ -968,9 +972,9 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, const frameblend_t *frameb if (VectorCompare(boxmins, boxmaxs)) { if (VectorCompare(start, end)) - Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask); else - Mod_Q1BSP_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask); + Mod_Q1BSP_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask); return; } @@ -978,6 +982,7 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, const frameblend_t *frameb memset(trace, 0, sizeof(trace_t)); rhc.trace = trace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; rhc.trace->fraction = 1; rhc.trace->allsolid = true; VectorSubtract(boxmaxs, boxmins, boxsize); @@ -1020,6 +1025,7 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, const frameblend_t *frameb memset(&testtrace, 0, sizeof(trace_t)); rhc.trace = &testtrace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; rhc.trace->fraction = 1; rhc.trace->allsolid = true; VectorCopy(test, rhc.start); @@ -1053,7 +1059,7 @@ static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const 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, const texture_t *boxtexture) +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 skipsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, const texture_t *boxtexture) { #if 1 colbrushf_t cbox; @@ -1088,6 +1094,7 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm cbox_planes[5].q3surfaceflags = boxq3surfaceflags;cbox_planes[5].texture = boxtexture; memset(trace, 0, sizeof(trace_t)); trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; trace->fraction = 1; Collision_TraceLineBrushFloat(trace, start, end, &cbox, &cbox); #else @@ -1145,6 +1152,7 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm rhc.hull = &box_hull; rhc.trace = trace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; rhc.trace->fraction = 1; rhc.trace->allsolid = true; VectorCopy(start, rhc.start); @@ -1157,14 +1165,16 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm #endif } -void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, const texture_t *boxtexture) +void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, const texture_t *boxtexture) { memset(trace, 0, sizeof(trace_t)); trace->fraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; if (BoxesOverlap(start, start, cmins, cmaxs)) { trace->startsupercontents |= boxsupercontents; - if (hitsupercontentsmask & boxsupercontents) + if ((hitsupercontentsmask & boxsupercontents) && !(skipsupercontentsmask & boxsupercontents)) { trace->startsolid = true; trace->allsolid = true; @@ -1175,7 +1185,7 @@ void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end) { trace_t trace; - Mod_Q1BSP_TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK); + Mod_Q1BSP_TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK, 0); return trace.fraction == 1; } @@ -1362,6 +1372,9 @@ static const texture_t *Mod_Q1BSP_TraceLineAgainstSurfacesFindTextureOnNode(Recu // skip faces with contents we don't care about if (!(t->trace->hitsupercontentsmask & surface->texture->supercontents)) continue; + // ignore surfaces matching the skipsupercontentsmask (this is rare) + if (t->trace->skipsupercontentsmask & surface->texture->supercontents) + continue; // get the surface normal - since it is flat we know any vertex normal will suffice VectorCopy(model->surfmesh.data_normal3f + 3 * surface->num_firstvertex, normal); // skip backfaces @@ -1492,7 +1505,7 @@ static int Mod_Q1BSP_TraceLineAgainstSurfacesRecursiveBSPNode(RecursiveHullCheck } } -static void Mod_Q1BSP_TraceLineAgainstSurfaces(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +static void Mod_Q1BSP_TraceLineAgainstSurfaces(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask) { RecursiveHullCheckTraceInfo_t rhc; @@ -1500,6 +1513,7 @@ static void Mod_Q1BSP_TraceLineAgainstSurfaces(struct model_s *model, const fram memset(trace, 0, sizeof(trace_t)); rhc.trace = trace; rhc.trace->hitsupercontentsmask = hitsupercontentsmask; + rhc.trace->skipsupercontentsmask = skipsupercontentsmask; rhc.trace->fraction = 1; rhc.trace->allsolid = true; rhc.hull = &model->brushq1.hulls[0]; // 0x0x0 @@ -1620,7 +1634,7 @@ static void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) { int i, j, k, num, max, altmax, mtwidth, mtheight, doffset, incomplete, nummiptex = 0; - skinframe_t *skinframe; + skinframe_t *skinframemissing; texture_t *tx, *tx2, *anims[10], *altanims[10]; texture_t backuptex; unsigned char *data, *mtdata; @@ -1651,9 +1665,9 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) // fill out all slots with notexture if (cls.state != ca_dedicated) - skinframe = R_SkinFrame_LoadMissing(); + skinframemissing = R_SkinFrame_LoadMissing(); else - skinframe = NULL; + skinframemissing = NULL; for (i = 0, tx = loadmodel->data_textures;i < loadmodel->num_textures;i++, tx++) { strlcpy(tx->name, "NO TEXTURE FOUND", sizeof(tx->name)); @@ -1662,10 +1676,8 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) tx->basealpha = 1.0f; if (cls.state != ca_dedicated) { - tx->numskinframes = 1; - tx->skinframerate = 1; - tx->skinframes[0] = skinframe; - tx->currentskinframe = tx->skinframes[0]; + tx->materialshaderpass = tx->shaderpasses[0] = Mod_CreateShaderPass(skinframemissing); + tx->currentskinframe = skinframemissing; } tx->basematerialflags = MATERIALFLAG_WALL; if (i == loadmodel->num_textures - 1) @@ -1825,7 +1837,7 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) } else { - skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va(vabuf, sizeof(vabuf), "textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, false); + skinframe_t *skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va(vabuf, sizeof(vabuf), "textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, false); if (!skinframe) skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va(vabuf, sizeof(vabuf), "textures/%s", tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS, false); if (skinframe) @@ -1854,15 +1866,15 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) else if (mtdata) // texture included skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP, false, r_fullbrights.integer, mtdata, tx->width, tx->height); } - // if skinframe is still NULL the "missing" texture will be used + // if skinframe is still NULL the "missing" texture has already been assigned to this if (skinframe) - tx->skinframes[0] = skinframe; + tx->materialshaderpass->skinframes[0] = skinframe; } // LordHavoc: some Tenebrae textures get replaced by black if (!strncmp(tx->name, "*glassmirror", 12)) // Tenebrae - tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA, zerotrans, 1, 1, false); + tx->materialshaderpass->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA, zerotrans, 1, 1, false); else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae - tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, 0, zeroopaque, 1, 1, false); + tx->materialshaderpass->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, 0, zeroopaque, 1, 1, false); } tx->basematerialflags = MATERIALFLAG_WALL; @@ -1877,9 +1889,13 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) 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]->hasalpha) + if (tx->materialshaderpass->skinframes[0]->hasalpha) tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; } + else if (tx->name[0] == '{') // fence textures + { + tx->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_NOSHADOW; + } else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae { // replace the texture with black @@ -1889,12 +1905,12 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) 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]->hasalpha) + else if (tx->materialshaderpass->skinframes[0]->hasalpha) tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // start out with no animation tx->currentframe = tx; - tx->currentskinframe = tx->skinframes[0]; + tx->currentskinframe = tx->materialshaderpass->skinframes[0]; tx->currentmaterialflags = tx->basematerialflags; } @@ -1904,6 +1920,12 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) tx = loadmodel->data_textures + i; if (!tx || tx->name[0] != '+' || tx->name[1] == 0 || tx->name[2] == 0) continue; + num = tx->name[1]; + if ((num < '0' || num > '9') && (num < 'a' || num > 'j')) + { + Con_Printf("Bad animating texture %s\n", tx->name); + continue; + } if (tx->anim_total[0] || tx->anim_total[1]) continue; // already sequenced @@ -1922,8 +1944,7 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) anims[num - '0'] = tx2; else if (num >= 'a' && num <= 'j') altanims[num - 'a'] = tx2; - else - Con_Printf("Bad animating texture %s\n", tx->name); + // No need to warn otherwise - we already did above. } max = altmax = 0; @@ -1956,6 +1977,12 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) if (incomplete) continue; + // If we have exactly one frame, something's wrong. + if (max + altmax <= 1) + { + Con_Printf("Texture %s is animated (leading +) but has only one frame\n", tx->name); + } + if (altmax < 1) { // if there is no alternate animation, duplicate the primary @@ -1965,6 +1992,18 @@ static void Mod_Q1BSP_LoadTextures(sizebuf_t *sb) altanims[k] = anims[k]; } + if (max < 1) + { + // Warn. + Con_Printf("Missing frame 0 of %s\n", tx->name); + + // however, we can handle this by duplicating the alternate animation into the primary + max = altmax; + for (k = 0;k < 10;k++) + anims[k] = altanims[k]; + } + + // link together the primary animation for (j = 0;j < max;j++) { @@ -2658,10 +2697,10 @@ static void Mod_Q1BSP_LoadFaces(sizebuf_t *sb) int stainmapsize = 0; mod_alloclightmap_state_t allocState; - Mod_AllocLightmap_Init(&allocState, lightmapsize, lightmapsize); + Mod_AllocLightmap_Init(&allocState, loadmodel->mempool, lightmapsize, lightmapsize); for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++) { - int i, iu, iv, lightmapx = 0, lightmapy = 0; + int iu, iv, lightmapx = 0, lightmapy = 0; float u, v, ubase, vbase, uscale, vscale; if (!loadmodel->brushq1.lightmapupdateflags[surfacenum]) @@ -3760,7 +3799,7 @@ static int Mod_Q1BSP_CreateShadowMesh(dp_model_t *mod) return numshadowmeshtriangles; } -void Mod_CollisionBIH_TraceLineAgainstSurfaces(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask); +void Mod_CollisionBIH_TraceLineAgainstSurfaces(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask); void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) { @@ -4276,7 +4315,7 @@ static void Mod_Q2BSP_LoadNodes(sizebuf_t *sb) static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) { mtexinfo_t *out; - int i, j, k, l, count; + int i, l, count; int structsize = 76; int maxtextures = 1024; // hardcoded limit of quake2 engine, so we may as well use it as an upper bound char filename[MAX_QPATH]; @@ -4292,6 +4331,7 @@ static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) for (i = 0;i < count;i++, out++) { + int j, k; for (k = 0;k < 2;k++) for (j = 0;j < 4;j++) out->vecs[k][j] = MSG_ReadLittleFloat(sb); @@ -4305,7 +4345,9 @@ static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) // find an existing match for the texture if possible dpsnprintf(filename, sizeof(filename), "textures/%s.wal", out->q2texture); for (j = 0;j < loadmodel->num_texturesperskin;j++) - if (!strcmp(filename, loadmodel->data_textures[j].name) && out->q2flags == loadmodel->data_textures[j].q2flags) + if (!strcmp(filename, loadmodel->data_textures[j].name) + && out->q2flags == loadmodel->data_textures[j].q2flags + && out->q2value == loadmodel->data_textures[j].q2value) break; // if we don't find the texture, store the new texture if (j == loadmodel->num_texturesperskin) @@ -4316,19 +4358,24 @@ static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) int q2flags = out->q2flags; unsigned char *walfile = NULL; fs_offset_t walfilesize = 0; - Mod_LoadTextureFromQ3Shader(tx, filename, true, true, TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS); + Mod_LoadTextureFromQ3Shader(tx, filename, true, true, TEXF_ALPHA | TEXF_MIPMAP | TEXF_ISWORLD | TEXF_PICMIP | TEXF_COMPRESS); // now read the .wal file to get metadata (even if a .tga was overriding it, we still need the wal data) walfile = FS_LoadFile(filename, tempmempool, true, &walfilesize); if (walfile) { int w, h; - char q2animname32c[32]; - LoadWAL_GetMetadata(walfile, (int)walfilesize, &w, &h, &q2flags, &tx->q2value, &tx->q2contents, q2animname32c); + LoadWAL_GetMetadata(walfile, (int)walfilesize, &w, &h, NULL, NULL, &tx->q2contents, NULL); tx->width = w; tx->height = h; - tx->q2flags = q2flags; Mem_Free(walfile); } + else + { + tx->width = 16; + tx->height = 16; + } + tx->q2flags = out->q2flags; + tx->q2value = out->q2value; // also modify the texture to have the correct contents and such based on flags // note that we create multiple texture_t structures if q2flags differs if (q2flags & Q2SURF_LIGHT) @@ -4361,7 +4408,7 @@ static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) if (q2flags & Q2SURF_TRANS33) { tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED; - tx->basealpha = 0.3333f; + tx->basealpha = 1.0f / 3.0f; tx->supercontents &= ~SUPERCONTENTS_OPAQUE; if (tx->q2contents & Q2CONTENTS_SOLID) tx->q2contents = (tx->q2contents & ~Q2CONTENTS_SOLID) | Q2CONTENTS_WINDOW; @@ -4369,16 +4416,29 @@ static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) if (q2flags & Q2SURF_TRANS66) { tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED; - tx->basealpha = 0.6667f; + tx->basealpha = 2.0f / 3.0f; tx->supercontents &= ~SUPERCONTENTS_OPAQUE; if (tx->q2contents & Q2CONTENTS_SOLID) tx->q2contents = (tx->q2contents & ~Q2CONTENTS_SOLID) | Q2CONTENTS_WINDOW; } if (q2flags & Q2SURF_FLOWING) { - tx->tcmods[0].tcmod = Q3TCMOD_SCROLL; - tx->tcmods[0].parms[0] = -1.6f; - tx->tcmods[0].parms[1] = 0.0f; + tx->materialshaderpass->tcmods[0].tcmod = Q3TCMOD_SCROLL; + if (q2flags & Q2SURF_WARP) + tx->materialshaderpass->tcmods[0].parms[0] = -0.5f; + else + tx->materialshaderpass->tcmods[0].parms[0] = -1.6f; + tx->materialshaderpass->tcmods[0].parms[1] = 0.0f; + } + if (q2flags & Q2SURF_ALPHATEST) + { + // KMQUAKE2 and other modded engines added this flag for lit alpha tested surfaces + tx->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_NOSHADOW; + } + else if (q2flags & (Q2SURF_TRANS33 | Q2SURF_TRANS66 | Q2SURF_WARP)) + { + if (!mod_q2bsp_littransparentsurfaces.integer) + tx->basematerialflags |= MATERIALFLAG_FULLBRIGHT; } if (q2flags & Q2SURF_NODRAW) { @@ -4393,7 +4453,7 @@ static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) tx->supercontents = Mod_Q2BSP_SuperContentsFromNativeContents(loadmodel, tx->q2contents); // set the current values to the base values tx->currentframe = tx; - tx->currentskinframe = tx->skinframes[0]; + tx->currentskinframe = tx->materialshaderpass->skinframes[0]; tx->currentmaterialflags = tx->basematerialflags; loadmodel->num_texturesperskin++; loadmodel->num_textures = loadmodel->num_texturesperskin; @@ -4415,8 +4475,9 @@ static void Mod_Q2BSP_LoadTexinfo(sizebuf_t *sb) // if we encounter the textures out of order, the later ones won't mark the earlier ones in a sequence, so the earlier for (i = 0, out = loadmodel->brushq1.texinfo;i < count;i++, out++) { - int j; + int j, k; texture_t *t = loadmodel->data_textures + out->textureindex; + t->currentframe = t; // fix the reallocated pointer // if this is not animated, skip it // if this is already processed, skip it (part of an existing sequence) @@ -4590,6 +4651,9 @@ static void Mod_Q2BSP_LoadBrushes(sizebuf_t *sb) int i, j, firstside, numsides, contents, count, maxplanes, q3surfaceflags, supercontents; colplanef_t *planes; int structsize = 12; + qboolean brushmissingtextures; + int numbrushesmissingtextures = 0; + int numcreatedtextures = 0; if (sb->cursize % structsize) Host_Error("Mod_Q2BSP_LoadBrushes: funny lump size in %s",loadmodel->name); @@ -4602,7 +4666,7 @@ static void Mod_Q2BSP_LoadBrushes(sizebuf_t *sb) maxplanes = 0; planes = NULL; - for (i = 0;i < count;i++, out++) + for (i = 0; i < count; i++, out++) { firstside = MSG_ReadLittleLong(sb); numsides = MSG_ReadLittleLong(sb); @@ -4612,11 +4676,49 @@ static void Mod_Q2BSP_LoadBrushes(sizebuf_t *sb) out->firstbrushside = loadmodel->brush.data_brushsides + firstside; out->numbrushsides = numsides; - // not really the same... we should store the q2 contents - out->texture = out->firstbrushside->texture; // convert the contents to our values supercontents = Mod_Q2BSP_SuperContentsFromNativeContents(loadmodel, contents); + // problem: q2bsp brushes have contents but not a texture + // problem: q2bsp brushsides *may* have a texture or may not + // problem: all brushsides and brushes must have a texture for trace_hittexture functionality to work, and the collision code is engineered around this assumption + // solution: nasty hacks + brushmissingtextures = false; + out->texture = NULL; + for (j = 0; j < out->numbrushsides; j++) + { + if (out->firstbrushside[j].texture == &mod_q1bsp_texture_solid) + brushmissingtextures = true; + else + { + // if we can find a matching texture on a brush side we can use it instead of creating one + if (out->firstbrushside[j].texture->supercontents == supercontents) + out->texture = out->firstbrushside[j].texture; + } + } + if (brushmissingtextures || out->texture == NULL) + { + numbrushesmissingtextures++; + // if we didn't find any appropriate texture (matching contents), we'll have to create one + // we could search earlier ones for a matching one but that can be slow + if (out->texture == NULL) + { + texture_t *validtexture; + validtexture = (texture_t *)Mem_Alloc(loadmodel->mempool, sizeof(texture_t)); + dpsnprintf(validtexture->name, sizeof(validtexture->name), "brushcollision%i", numcreatedtextures); + validtexture->surfaceflags = 0; + validtexture->supercontents = supercontents; + numcreatedtextures++; + out->texture = validtexture; + } + // out->texture now contains a texture with appropriate contents, copy onto any missing sides + for (j = 0; j < out->numbrushsides; j++) + if (out->firstbrushside[j].texture == &mod_q1bsp_texture_solid) + out->firstbrushside[j].texture = out->texture; + } + + // make a colbrush from the brush + q3surfaceflags = 0; // make a list of mplane_t structs to construct a colbrush from if (maxplanes < out->numbrushsides) { @@ -4625,7 +4727,6 @@ static void Mod_Q2BSP_LoadBrushes(sizebuf_t *sb) Mem_Free(planes); planes = (colplanef_t *)Mem_Alloc(tempmempool, sizeof(colplanef_t) * maxplanes); } - q3surfaceflags = 0; for (j = 0;j < out->numbrushsides;j++) { VectorCopy(out->firstbrushside[j].plane->normal, planes[j].normal); @@ -4633,10 +4734,7 @@ static void Mod_Q2BSP_LoadBrushes(sizebuf_t *sb) planes[j].q3surfaceflags = out->firstbrushside[j].texture->surfaceflags; planes[j].texture = out->firstbrushside[j].texture; q3surfaceflags |= planes[j].q3surfaceflags; - // LordHavoc: kind of a mean hack here, but we want the surfaces to have the brush contents - out->firstbrushside[j].texture->supercontents = supercontents; } - // make the colbrush from the planes out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents, q3surfaceflags, out->texture, true); // this whole loop can take a while (e.g. on redstarrepublic4) @@ -4644,6 +4742,8 @@ static void Mod_Q2BSP_LoadBrushes(sizebuf_t *sb) } if (planes) Mem_Free(planes); + if (numcreatedtextures) + Con_DPrintf("Mod_Q2BSP_LoadBrushes: %i brushes own sides that lack textures or have differing contents from the brush, %i textures have been created to describe these contents.\n", numbrushesmissingtextures, numcreatedtextures); } static void Mod_Q2BSP_LoadPOP(sizebuf_t *sb) @@ -6682,7 +6782,7 @@ static qboolean Mod_Q3BSP_TraceLineOfSight(struct model_s *model, const vec3_t s if (model->brush.submodel || mod_q3bsp_tracelineofsight_brushes.integer) { trace_t trace; - model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK); + model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK, SUPERCONTENTS_SKY); return trace.fraction == 1; } else @@ -6694,7 +6794,7 @@ static qboolean Mod_Q3BSP_TraceLineOfSight(struct model_s *model, const vec3_t s } } -void Mod_CollisionBIH_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +void Mod_CollisionBIH_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask) { const bih_t *bih; const bih_leaf_t *leaf; @@ -6708,6 +6808,7 @@ void Mod_CollisionBIH_TracePoint(dp_model_t *model, const frameblend_t *frameble memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; bih = &model->collision_bih; if(!bih->nodes) @@ -6758,7 +6859,7 @@ void Mod_CollisionBIH_TracePoint(dp_model_t *model, const frameblend_t *frameble } } -static void Mod_CollisionBIH_TraceLineShared(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, const bih_t *bih) +static void Mod_CollisionBIH_TraceLineShared(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask, const bih_t *bih) { const bih_leaf_t *leaf; const bih_node_t *node; @@ -6774,7 +6875,7 @@ static void Mod_CollisionBIH_TraceLineShared(dp_model_t *model, const frameblend if (VectorCompare(start, end)) { - Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask); return; } @@ -6783,6 +6884,7 @@ static void Mod_CollisionBIH_TraceLineShared(dp_model_t *model, const frameblend memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; // push first node nodestackline[nodestackpos][0] = start[0]; @@ -6881,17 +6983,17 @@ static void Mod_CollisionBIH_TraceLineShared(dp_model_t *model, const frameblend } } -void Mod_CollisionBIH_TraceLine(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +void Mod_CollisionBIH_TraceLine(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask) { if (VectorCompare(start, end)) { - Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask); return; } - Mod_CollisionBIH_TraceLineShared(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, &model->collision_bih); + Mod_CollisionBIH_TraceLineShared(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, &model->collision_bih); } -void Mod_CollisionBIH_TraceBrush(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, colbrushf_t *thisbrush_start, colbrushf_t *thisbrush_end, int hitsupercontentsmask) +void Mod_CollisionBIH_TraceBrush(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, colbrushf_t *thisbrush_start, colbrushf_t *thisbrush_end, int hitsupercontentsmask, int skipsupercontentsmask) { const bih_t *bih; const bih_leaf_t *leaf; @@ -6907,9 +7009,9 @@ void Mod_CollisionBIH_TraceBrush(dp_model_t *model, const frameblend_t *frameble if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(thisbrush_start->mins, thisbrush_start->maxs) && VectorCompare(thisbrush_end->mins, thisbrush_end->maxs)) { if (VectorCompare(thisbrush_start->mins, thisbrush_end->mins)) - Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, thisbrush_start->mins, hitsupercontentsmask); + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, thisbrush_start->mins, hitsupercontentsmask, skipsupercontentsmask); else - Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, thisbrush_start->mins, thisbrush_end->mins, hitsupercontentsmask); + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, thisbrush_start->mins, thisbrush_end->mins, hitsupercontentsmask, skipsupercontentsmask); return; } @@ -6922,6 +7024,7 @@ void Mod_CollisionBIH_TraceBrush(dp_model_t *model, const frameblend_t *frameble memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; // calculate tracebox-like parameters for efficient culling VectorMAM(0.5f, thisbrush_start->mins, 0.5f, thisbrush_start->maxs, start); @@ -7034,7 +7137,7 @@ void Mod_CollisionBIH_TraceBrush(dp_model_t *model, const frameblend_t *frameble } } -void Mod_CollisionBIH_TraceBox(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask) +void Mod_CollisionBIH_TraceBox(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask) { colboxbrushf_t thisbrush_start, thisbrush_end; vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; @@ -7046,25 +7149,25 @@ void Mod_CollisionBIH_TraceBox(dp_model_t *model, const frameblend_t *frameblend VectorAdd(end, boxmaxs, boxendmaxs); Collision_BrushForBox(&thisbrush_start, boxstartmins, boxstartmaxs, 0, 0, NULL); Collision_BrushForBox(&thisbrush_end, boxendmins, boxendmaxs, 0, 0, NULL); - Mod_CollisionBIH_TraceBrush(model, frameblend, skeleton, trace, &thisbrush_start.brush, &thisbrush_end.brush, hitsupercontentsmask); + Mod_CollisionBIH_TraceBrush(model, frameblend, skeleton, trace, &thisbrush_start.brush, &thisbrush_end.brush, hitsupercontentsmask, skipsupercontentsmask); } int Mod_CollisionBIH_PointSuperContents(struct model_s *model, int frame, const vec3_t point) { trace_t trace; - Mod_CollisionBIH_TracePoint(model, NULL, NULL, &trace, point, 0); + Mod_CollisionBIH_TracePoint(model, NULL, NULL, &trace, point, 0, 0); return trace.startsupercontents; } qboolean Mod_CollisionBIH_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end) { trace_t trace; - Mod_CollisionBIH_TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK); + Mod_CollisionBIH_TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK, 0); return trace.fraction == 1; } -void Mod_CollisionBIH_TracePoint_Mesh(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +void Mod_CollisionBIH_TracePoint_Mesh(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask) { #if 0 // broken - needs to be modified to count front faces and backfaces to figure out if it is in solid @@ -7075,12 +7178,14 @@ void Mod_CollisionBIH_TracePoint_Mesh(dp_model_t *model, const frameblend_t *fra memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; #if 0 - Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask); + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask); hitsupercontents = trace->hitsupercontents; memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; trace->startsupercontents = hitsupercontents; #endif } @@ -7094,8 +7199,9 @@ int Mod_CollisionBIH_PointSuperContents_Mesh(struct model_s *model, int frame, c VectorSet(end, start[0], start[1], model->normalmins[2]); memset(&trace, 0, sizeof(trace)); trace.fraction = 1; - trace.hitsupercontentsmask = 0; - Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask); + trace.hitsupercontentsmask = hitsupercontentsmask; + trace.skipsupercontentsmask = skipsupercontentsmask; + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask); return trace.hitsupercontents; #else return 0; @@ -7317,15 +7423,16 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo static int markframe = 0; -static void Mod_Q3BSP_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +static void Mod_Q3BSP_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask) { int i; q3mbrush_t *brush; memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; if (mod_collision_bih.integer) - Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask); else if (model->brush.submodel) { for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) @@ -7336,7 +7443,7 @@ static void Mod_Q3BSP_TracePoint(dp_model_t *model, const frameblend_t *frameble Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe); } -static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask) { int i; float segmentmins[3], segmentmaxs[3]; @@ -7345,13 +7452,14 @@ static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblen if (VectorCompare(start, end)) { - Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask, skipsupercontentsmask); return; } memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; segmentmins[0] = min(start[0], end[0]) - 1; segmentmins[1] = min(start[1], end[1]) - 1; segmentmins[2] = min(start[2], end[2]) - 1; @@ -7359,7 +7467,7 @@ static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblen segmentmaxs[1] = max(start[1], end[1]) + 1; segmentmaxs[2] = max(start[2], end[2]) + 1; if (mod_collision_bih.integer) - Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask); + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask); else if (model->brush.submodel) { for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) @@ -7374,7 +7482,7 @@ static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblen Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, 0, 1, start, end, ++markframe, segmentmins, segmentmaxs); } -static void Mod_Q3BSP_TraceBrush(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, colbrushf_t *start, colbrushf_t *end, int hitsupercontentsmask) +static void Mod_Q3BSP_TraceBrush(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, colbrushf_t *start, colbrushf_t *end, int hitsupercontentsmask, int skipsupercontentsmask) { float segmentmins[3], segmentmaxs[3]; int i; @@ -7384,9 +7492,9 @@ static void Mod_Q3BSP_TraceBrush(dp_model_t *model, const frameblend_t *frameble if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(start->mins, start->maxs) && VectorCompare(end->mins, end->maxs)) { if (VectorCompare(start->mins, end->mins)) - Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start->mins, hitsupercontentsmask); + Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start->mins, hitsupercontentsmask, skipsupercontentsmask); else - Mod_Q3BSP_TraceLine(model, frameblend, skeleton, trace, start->mins, end->mins, hitsupercontentsmask); + Mod_Q3BSP_TraceLine(model, frameblend, skeleton, trace, start->mins, end->mins, hitsupercontentsmask, skipsupercontentsmask); return; } @@ -7394,6 +7502,7 @@ static void Mod_Q3BSP_TraceBrush(dp_model_t *model, const frameblend_t *frameble memset(trace, 0, sizeof(*trace)); trace->fraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; + trace->skipsupercontentsmask = skipsupercontentsmask; segmentmins[0] = min(start->mins[0], end->mins[0]) - 1; segmentmins[1] = min(start->mins[1], end->mins[1]) - 1; segmentmins[2] = min(start->mins[2], end->mins[2]) - 1; @@ -7401,7 +7510,7 @@ static void Mod_Q3BSP_TraceBrush(dp_model_t *model, const frameblend_t *frameble segmentmaxs[1] = max(start->maxs[1], end->maxs[1]) + 1; segmentmaxs[2] = max(start->maxs[2], end->maxs[2]) + 1; if (mod_collision_bih.integer) - Mod_CollisionBIH_TraceBrush(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask); + Mod_CollisionBIH_TraceBrush(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask); else if (model->brush.submodel) { for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) @@ -7416,7 +7525,7 @@ static void Mod_Q3BSP_TraceBrush(dp_model_t *model, const frameblend_t *frameble Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, ++markframe, segmentmins, segmentmaxs); } -static void Mod_Q3BSP_TraceBox(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, 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, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask) { colboxbrushf_t thisbrush_start, thisbrush_end; vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; @@ -7428,7 +7537,7 @@ static void Mod_Q3BSP_TraceBox(dp_model_t *model, const frameblend_t *frameblend VectorAdd(end, boxmaxs, boxendmaxs); Collision_BrushForBox(&thisbrush_start, boxstartmins, boxstartmaxs, 0, 0, NULL); Collision_BrushForBox(&thisbrush_end, boxendmins, boxendmaxs, 0, 0, NULL); - Mod_Q3BSP_TraceBrush(model, frameblend, skeleton, trace, &thisbrush_start.brush, &thisbrush_end.brush, hitsupercontentsmask); + Mod_Q3BSP_TraceBrush(model, frameblend, skeleton, trace, &thisbrush_start.brush, &thisbrush_end.brush, hitsupercontentsmask, skipsupercontentsmask); } static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point) @@ -7467,9 +7576,9 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const return supercontents; } -void Mod_CollisionBIH_TraceLineAgainstSurfaces(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +void Mod_CollisionBIH_TraceLineAgainstSurfaces(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask) { - Mod_CollisionBIH_TraceLineShared(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, &model->render_bih); + Mod_CollisionBIH_TraceLineShared(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, &model->render_bih); } @@ -7999,9 +8108,9 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) int maxvn = 0, numvn = 1; char *texturenames = NULL; float dist, modelradius, modelyawradius, yawradius; - float *v = NULL; - float *vt = NULL; - float *vn = NULL; + float *obj_v = NULL; + float *obj_vt = NULL; + float *obj_vn = NULL; float mins[3]; float maxs[3]; float corner[3]; @@ -8015,7 +8124,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) skinfile_t *skinfiles = NULL; unsigned char *data = NULL; int *submodelfirstsurface; - msurface_t *surface; + msurface_t *tempsurface; msurface_t *tempsurfaces; memset(&vfirst, 0, sizeof(vfirst)); @@ -8121,19 +8230,19 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) if (maxv <= numv) { maxv = max(maxv * 2, 1024); - v = (float *)Mem_Realloc(tempmempool, v, maxv * sizeof(float[3])); + obj_v = (float *)Mem_Realloc(tempmempool, obj_v, maxv * sizeof(float[3])); } if(mod_obj_orientation.integer) { - v[numv*3+0] = atof(argv[1]); - v[numv*3+2] = atof(argv[2]); - v[numv*3+1] = atof(argv[3]); + obj_v[numv*3+0] = atof(argv[1]); + obj_v[numv*3+2] = atof(argv[2]); + obj_v[numv*3+1] = atof(argv[3]); } else { - v[numv*3+0] = atof(argv[1]); - v[numv*3+1] = atof(argv[2]); - v[numv*3+2] = atof(argv[3]); + obj_v[numv*3+0] = atof(argv[1]); + obj_v[numv*3+1] = atof(argv[2]); + obj_v[numv*3+2] = atof(argv[3]); } numv++; } @@ -8142,10 +8251,10 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) if (maxvt <= numvt) { maxvt = max(maxvt * 2, 1024); - vt = (float *)Mem_Realloc(tempmempool, vt, maxvt * sizeof(float[2])); + obj_vt = (float *)Mem_Realloc(tempmempool, obj_vt, maxvt * sizeof(float[2])); } - vt[numvt*2+0] = atof(argv[1]); - vt[numvt*2+1] = 1-atof(argv[2]); + obj_vt[numvt*2+0] = atof(argv[1]); + obj_vt[numvt*2+1] = 1-atof(argv[2]); numvt++; } else if (!strcmp(argv[0], "vn")) @@ -8153,19 +8262,19 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) if (maxvn <= numvn) { maxvn = max(maxvn * 2, 1024); - vn = (float *)Mem_Realloc(tempmempool, vn, maxvn * sizeof(float[3])); + obj_vn = (float *)Mem_Realloc(tempmempool, obj_vn, maxvn * sizeof(float[3])); } if(mod_obj_orientation.integer) { - vn[numvn*3+0] = atof(argv[1]); - vn[numvn*3+2] = atof(argv[2]); - vn[numvn*3+1] = atof(argv[3]); + obj_vn[numvn*3+0] = atof(argv[1]); + obj_vn[numvn*3+2] = atof(argv[2]); + obj_vn[numvn*3+1] = atof(argv[3]); } else { - vn[numvn*3+0] = atof(argv[1]); - vn[numvn*3+1] = atof(argv[2]); - vn[numvn*3+2] = atof(argv[3]); + obj_vn[numvn*3+0] = atof(argv[1]); + obj_vn[numvn*3+1] = atof(argv[2]); + obj_vn[numvn*3+2] = atof(argv[3]); } numvn++; } @@ -8206,12 +8315,12 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) vcurrent.nextindex = -1; vcurrent.textureindex = textureindex; vcurrent.submodelindex = submodelindex; - if (v && index1 >= 0 && index1 < numv) - VectorCopy(v + 3*index1, vcurrent.v); - if (vt && index2 >= 0 && index2 < numvt) - Vector2Copy(vt + 2*index2, vcurrent.vt); - if (vn && index3 >= 0 && index3 < numvn) - VectorCopy(vn + 3*index3, vcurrent.vn); + if (obj_v && index1 >= 0 && index1 < numv) + VectorCopy(obj_v + 3*index1, vcurrent.v); + if (obj_vt && index2 >= 0 && index2 < numvt) + Vector2Copy(obj_vt + 2*index2, vcurrent.vt); + if (obj_vn && index3 >= 0 && index3 < numvn) + VectorCopy(obj_vn + 3*index3, vcurrent.vn); if (numtriangles == 0) { VectorCopy(vcurrent.v, mins); @@ -8315,7 +8424,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) // allocate storage for the worst case number of surfaces, later we resize tempsurfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, numtextures * loadmodel->brush.numsubmodels * sizeof(msurface_t)); submodelfirstsurface = (int *)Mem_Alloc(loadmodel->mempool, (loadmodel->brush.numsubmodels+1) * sizeof(int)); - surface = tempsurfaces; + tempsurface = tempsurfaces; for (submodelindex = 0;submodelindex < loadmodel->brush.numsubmodels;submodelindex++) { submodelfirstsurface[submodelindex] = loadmodel->num_surfaces; @@ -8334,10 +8443,10 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) surfacevertices = 0; surfaceelements = 0; // we hack in a texture index in the surface to be fixed up later... - surface->texture = (texture_t *)((size_t)textureindex); + tempsurface->texture = (texture_t *)((size_t)textureindex); // calculate bounds as we go - VectorCopy(thisvertex->v, surface->mins); - VectorCopy(thisvertex->v, surface->maxs); + VectorCopy(thisvertex->v, tempsurface->mins); + VectorCopy(thisvertex->v, tempsurface->maxs); for (;vertexindex < numtriangles*3;vertexindex++) { thisvertex = vertices + vertexindex; @@ -8346,12 +8455,12 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) if (thisvertex->textureindex != textureindex) continue; // add vertex to surface bounds - surface->mins[0] = min(surface->mins[0], thisvertex->v[0]); - surface->mins[1] = min(surface->mins[1], thisvertex->v[1]); - surface->mins[2] = min(surface->mins[2], thisvertex->v[2]); - surface->maxs[0] = max(surface->maxs[0], thisvertex->v[0]); - surface->maxs[1] = max(surface->maxs[1], thisvertex->v[1]); - surface->maxs[2] = max(surface->maxs[2], thisvertex->v[2]); + tempsurface->mins[0] = min(tempsurface->mins[0], thisvertex->v[0]); + tempsurface->mins[1] = min(tempsurface->mins[1], thisvertex->v[1]); + tempsurface->mins[2] = min(tempsurface->mins[2], thisvertex->v[2]); + tempsurface->maxs[0] = max(tempsurface->maxs[0], thisvertex->v[0]); + tempsurface->maxs[1] = max(tempsurface->maxs[1], thisvertex->v[1]); + tempsurface->maxs[2] = max(tempsurface->maxs[2], thisvertex->v[2]); // add the vertex if it is not found in the merged set, and // get its index (triangle element) for the surface vertexhashindex = (unsigned int)(thisvertex->v[0] * 3571 + thisvertex->v[0] * 1777 + thisvertex->v[0] * 457) % (unsigned int)vertexhashsize; @@ -8374,13 +8483,13 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) surfaceelements++; } surfacetriangles = surfaceelements / 3; - surface->num_vertices = surfacevertices; - surface->num_triangles = surfacetriangles; - surface->num_firstvertex = firstvertex; - surface->num_firsttriangle = firsttriangle; - firstvertex += surface->num_vertices; - firsttriangle += surface->num_triangles; - surface++; + tempsurface->num_vertices = surfacevertices; + tempsurface->num_triangles = surfacetriangles; + tempsurface->num_firstvertex = firstvertex; + tempsurface->num_firsttriangle = firsttriangle; + firstvertex += tempsurface->num_vertices; + firsttriangle += tempsurface->num_triangles; + tempsurface++; loadmodel->num_surfaces++; } } @@ -8427,9 +8536,9 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) // free data Mem_Free(vertices); Mem_Free(texturenames); - Mem_Free(v); - Mem_Free(vt); - Mem_Free(vn); + Mem_Free(obj_v); + Mem_Free(obj_vt); + Mem_Free(obj_vn); Mem_Free(vertexhashtable); Mem_Free(vertexhashdata); @@ -8519,24 +8628,24 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) 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; + const float *v3f = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex; int k; if (!surface->num_vertices) continue; if (!l) { l = true; - VectorCopy(v, mod->normalmins); - VectorCopy(v, mod->normalmaxs); + VectorCopy(v3f, mod->normalmins); + VectorCopy(v3f, mod->normalmaxs); } - for (k = 0;k < surface->num_vertices;k++, v += 3) + for (k = 0;k < surface->num_vertices;k++, v3f += 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]); + mod->normalmins[0] = min(mod->normalmins[0], v3f[0]); + mod->normalmins[1] = min(mod->normalmins[1], v3f[1]); + mod->normalmins[2] = min(mod->normalmins[2], v3f[2]); + mod->normalmaxs[0] = max(mod->normalmaxs[0], v3f[0]); + mod->normalmaxs[1] = max(mod->normalmaxs[1], v3f[1]); + mod->normalmaxs[2] = max(mod->normalmaxs[2], v3f[2]); } } corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));