X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=collision.c;h=e6621710f0668729be2821f425f13064d447a04d;hb=46964b3848eb7471d2f0e2284ae389b4b53337c1;hp=547ad23635501a66778bab3a4d6f20631f9e59e5;hpb=28f64beb60928fdcf2a8932a4971ce547fd98062;p=xonotic%2Fdarkplaces.git diff --git a/collision.c b/collision.c index 547ad236..e6621710 100644 --- a/collision.c +++ b/collision.c @@ -1,6 +1,7 @@ #include "quakedef.h" #include "polygon.h" +#include "collision.h" #define COLLISION_EDGEDIR_DOT_EPSILON (0.999f) #define COLLISION_EDGECROSS_MINLENGTH2 (1.0f / 4194304.0f) @@ -18,6 +19,7 @@ cvar_t collision_cache = {0, "collision_cache", "1", "store results of collision //cvar_t collision_triangle_neighborsides = {0, "collision_triangle_neighborsides", "1", "override automatic side generation if triangle has neighbors with face planes that form a convex edge (perfect solution, but can not work for all edges)"}; cvar_t collision_triangle_bevelsides = {0, "collision_triangle_bevelsides", "0", "generate sloped edge planes on triangles - if 0, see axialedgeplanes"}; cvar_t collision_triangle_axialsides = {0, "collision_triangle_axialsides", "1", "generate axially-aligned edge planes on triangles - otherwise use perpendicular edge planes"}; +cvar_t collision_bih_fullrecursion = { 0, "collision_bih_fullrecursion", "0", "debugging option to disable the bih recursion optimizations by iterating the entire tree" }; mempool_t *collision_mempool; @@ -32,6 +34,7 @@ void Collision_Init (void) // Cvar_RegisterVariable(&collision_triangle_neighborsides); Cvar_RegisterVariable(&collision_triangle_bevelsides); Cvar_RegisterVariable(&collision_triangle_axialsides); + Cvar_RegisterVariable(&collision_bih_fullrecursion); collision_mempool = Mem_AllocPool("collision cache", 0, NULL); Collision_Cache_Init(collision_mempool); } @@ -554,25 +557,6 @@ void Collision_CalcPlanesForTriangleBrushFloat(colbrushf_t *brush) } } -colbrushf_t *Collision_AllocBrushFromPermanentPolygonFloat(mempool_t *mempool, int numpoints, float *points, int supercontents, int q3surfaceflags, const texture_t *texture) -{ - colbrushf_t *brush; - brush = (colbrushf_t *)Mem_Alloc(mempool, sizeof(colbrushf_t) + sizeof(colplanef_t) * (numpoints + 2) + sizeof(colpointf_t) * numpoints); - brush->isaabb = false; - brush->hasaabbplanes = false; - brush->supercontents = supercontents; - brush->numpoints = numpoints; - brush->numedgedirs = numpoints; - brush->numplanes = numpoints + 2; - brush->planes = (colplanef_t *)(brush + 1); - brush->points = (colpointf_t *)points; - brush->edgedirs = (colpointf_t *)(brush->planes + brush->numplanes); - brush->q3surfaceflags = q3surfaceflags; - brush->texture = texture; - Sys_Error("Collision_AllocBrushFromPermanentPolygonFloat: FIXME: this code needs to be updated to generate a mesh..."); - return brush; -} - // NOTE: start and end of each brush pair must have same numplanes/numpoints void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *trace_start, const colbrushf_t *trace_end, const colbrushf_t *other_start, const colbrushf_t *other_end) { @@ -591,6 +575,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *trace_sta const texture_t *hittexture = NULL; vec_t startdepth = 1; vec3_t startdepthnormal; + const texture_t *starttexture = NULL; VectorClear(startdepthnormal); Vector4Clear(newimpactplane); @@ -646,7 +631,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *trace_sta VectorNormalize(endplane); } startplane[3] = furthestplanedist_float(startplane, other_start->points, othernumpoints); - endplane[3] = furthestplanedist_float(startplane, other_end->points, othernumpoints); + endplane[3] = furthestplanedist_float(endplane, other_end->points, othernumpoints); startdist = nearestplanedist_float(startplane, trace_start->points, tracenumpoints) - startplane[3]; enddist = nearestplanedist_float(endplane, trace_end->points, tracenumpoints) - endplane[3]; //Con_Printf("%c%i: startdist = %f, enddist = %f, startdist / (startdist - enddist) = %f\n", nplane2 != nplane ? 'b' : 'a', nplane2, startdist, enddist, startdist / (startdist - enddist)); @@ -656,6 +641,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *trace_sta { startdepth = startdist; VectorCopy(startplane, startdepthnormal); + starttexture = other_start->planes[nplane2].texture; } if (startdist > enddist) @@ -741,7 +727,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *trace_sta { // started outside, and overlaps, therefore there is a collision here // store out the impact information - if (trace->hitsupercontentsmask & other_start->supercontents) + if ((trace->hitsupercontentsmask & other_start->supercontents) && !(trace->skipsupercontentsmask & other_start->supercontents) && !(trace->skipmaterialflagsmask & (hittexture ? hittexture->currentmaterialflags : 0))) { trace->hitsupercontents = other_start->supercontents; trace->hitq3surfaceflags = hitq3surfaceflags; @@ -755,7 +741,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *trace_sta { // started inside, update startsolid and friends trace->startsupercontents |= other_start->supercontents; - if (trace->hitsupercontentsmask & other_start->supercontents) + if ((trace->hitsupercontentsmask & other_start->supercontents) && !(trace->skipsupercontentsmask & other_start->supercontents) && !(trace->skipmaterialflagsmask & (starttexture ? starttexture->currentmaterialflags : 0))) { trace->startsolid = true; if (leavefrac < 1) @@ -766,6 +752,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *trace_sta { trace->startdepth = startdepth; VectorCopy(startdepthnormal, trace->startdepthnormal); + trace->starttexture = starttexture; } } } @@ -783,6 +770,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const const texture_t *hittexture = NULL; vec_t startdepth = 1; vec3_t startdepthnormal; + const texture_t *starttexture = NULL; if (collision_debug_tracelineasbox.integer) { @@ -821,6 +809,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const { startdepth = startdist; VectorCopy(startplane, startdepthnormal); + starttexture = other_start->planes[nplane].texture; } if (startdist > enddist) @@ -889,7 +878,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const { // started outside, and overlaps, therefore there is a collision here // store out the impact information - if (trace->hitsupercontentsmask & other_start->supercontents) + if ((trace->hitsupercontentsmask & other_start->supercontents) && !(trace->skipsupercontentsmask & other_start->supercontents) && !(trace->skipmaterialflagsmask & (hittexture ? hittexture->currentmaterialflags : 0))) { trace->hitsupercontents = other_start->supercontents; trace->hitq3surfaceflags = hitq3surfaceflags; @@ -903,7 +892,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const { // started inside, update startsolid and friends trace->startsupercontents |= other_start->supercontents; - if (trace->hitsupercontentsmask & other_start->supercontents) + if ((trace->hitsupercontentsmask & other_start->supercontents) && !(trace->skipsupercontentsmask & other_start->supercontents) && !(trace->skipmaterialflagsmask & (starttexture ? starttexture->currentmaterialflags : 0))) { trace->startsolid = true; if (leavefrac < 1) @@ -914,6 +903,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const { trace->startdepth = startdepth; VectorCopy(startdepthnormal, trace->startdepthnormal); + trace->starttexture = starttexture; } } } @@ -932,16 +922,65 @@ qboolean Collision_PointInsideBrushFloat(const vec3_t point, const colbrushf_t * return true; } -void Collision_TracePointBrushFloat(trace_t *trace, const vec3_t point, const colbrushf_t *thatbrush) +void Collision_TracePointBrushFloat(trace_t *trace, const vec3_t linestart, const colbrushf_t *other_start) { - if (!Collision_PointInsideBrushFloat(point, thatbrush)) - return; + int nplane; + int numplanes = other_start->numplanes; + vec_t startdist; + vec4_t startplane; + vec4_t newimpactplane; + vec_t startdepth = 1; + vec3_t startdepthnormal; + const texture_t *starttexture = NULL; - trace->startsupercontents |= thatbrush->supercontents; - if (trace->hitsupercontentsmask & thatbrush->supercontents) + VectorClear(startdepthnormal); + Vector4Clear(newimpactplane); + + // Separating Axis Theorem: + // if a supporting vector (plane normal) can be found that separates two + // objects, they are not colliding. + // + // Minkowski Sum: + // reduce the size of one object to a point while enlarging the other to + // represent the space that point can not occupy. + // + // try every plane we can construct between the two brushes and measure + // the distance between them. + for (nplane = 0; nplane < numplanes; nplane++) + { + VectorCopy(other_start->planes[nplane].normal, startplane); + startplane[3] = other_start->planes[nplane].dist; + startdist = DotProduct(linestart, startplane) - startplane[3]; + + if (startdist > 0) + return; + + // aside from collisions, this is also used for error correction + if (startdepth < startdist || startdepth == 1) + { + startdepth = startdist; + VectorCopy(startplane, startdepthnormal); + starttexture = other_start->planes[nplane].texture; + } + } + + // at this point we know the trace overlaps the brush because it was not + // rejected at any point in the loop above + + // started inside, update startsolid and friends + trace->startsupercontents |= other_start->supercontents; + if ((trace->hitsupercontentsmask & other_start->supercontents) && !(trace->skipsupercontentsmask & other_start->supercontents) && !(trace->skipmaterialflagsmask & (starttexture ? starttexture->currentmaterialflags : 0))) { trace->startsolid = true; trace->allsolid = true; + VectorCopy(newimpactplane, trace->plane.normal); + trace->plane.dist = newimpactplane[3]; + if (trace->startdepth > startdepth) + { + trace->startdepth = startdepth; + VectorCopy(startdepthnormal, trace->startdepthnormal); + trace->starttexture = starttexture; + } } } @@ -1309,6 +1348,10 @@ void Collision_TraceLineTriangleFloat(trace_t *trace, const vec3_t linestart, co // 8 ops (rare) + // skip if this trace should not be blocked by these contents + if (!(supercontents & trace->hitsupercontentsmask) || (supercontents & trace->skipsupercontentsmask) || (texture->currentmaterialflags & trace->skipmaterialflagsmask)) + return; + // store the new trace fraction trace->fraction = f2; @@ -1408,6 +1451,8 @@ typedef struct collision_cachedtrace_parameters_s vec3_t end; vec3_t start; int hitsupercontentsmask; + int skipsupercontentsmask; + int skipmaterialflagsmask; matrix4x4_t matrix; } collision_cachedtrace_parameters_t; @@ -1537,7 +1582,7 @@ static unsigned int Collision_Cache_HashIndexForArray(unsigned int *array, unsig return hashindex; } -static collision_cachedtrace_t *Collision_Cache_Lookup(dp_model_t *model, const matrix4x4_t *matrix, const matrix4x4_t *inversematrix, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +static collision_cachedtrace_t *Collision_Cache_Lookup(dp_model_t *model, const matrix4x4_t *matrix, const matrix4x4_t *inversematrix, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) { int hashindex = 0; unsigned int fullhashindex; @@ -1560,6 +1605,8 @@ static collision_cachedtrace_t *Collision_Cache_Lookup(dp_model_t *model, const VectorCopy(start, params.start); VectorCopy(end, params.end); params.hitsupercontentsmask = hitsupercontentsmask; + params.skipsupercontentsmask = skipsupercontentsmask; + params.skipmaterialflagsmask = skipmaterialflagsmask; params.matrix = *matrix; fullhashindex = Collision_Cache_HashIndexForArray((unsigned int *)¶ms, sizeof(params) / sizeof(unsigned int)); hashindex = (int)(fullhashindex % (unsigned int)collision_cachedtrace_hashsize); @@ -1577,6 +1624,8 @@ static collision_cachedtrace_t *Collision_Cache_Lookup(dp_model_t *model, const || cached->p.start[1] != params.start[1] || cached->p.start[2] != params.start[2] || cached->p.hitsupercontentsmask != params.hitsupercontentsmask + || cached->p.skipsupercontentsmask != params.skipsupercontentsmask + || cached->p.skipmaterialflagsmask != params.skipmaterialflagsmask || cached->p.matrix.m[0][0] != params.matrix.m[0][0] || cached->p.matrix.m[0][1] != params.matrix.m[0][1] || cached->p.matrix.m[0][2] != params.matrix.m[0][2] @@ -1641,30 +1690,30 @@ static collision_cachedtrace_t *Collision_Cache_Lookup(dp_model_t *model, const return cached; } -void Collision_Cache_ClipLineToGenericEntitySurfaces(trace_t *trace, dp_model_t *model, matrix4x4_t *matrix, matrix4x4_t *inversematrix, const vec3_t start, const vec3_t end, int hitsupercontentsmask) +void Collision_Cache_ClipLineToGenericEntitySurfaces(trace_t *trace, dp_model_t *model, matrix4x4_t *matrix, matrix4x4_t *inversematrix, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) { - collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, matrix, inversematrix, start, end, hitsupercontentsmask); + collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, matrix, inversematrix, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); if (cached->valid) { *trace = cached->result; return; } - Collision_ClipLineToGenericEntity(trace, model, NULL, NULL, vec3_origin, vec3_origin, 0, matrix, inversematrix, start, end, hitsupercontentsmask, collision_extendmovelength.value, true); + Collision_ClipLineToGenericEntity(trace, model, NULL, NULL, vec3_origin, vec3_origin, 0, matrix, inversematrix, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, collision_extendmovelength.value, true); cached->result = *trace; } -void Collision_Cache_ClipLineToWorldSurfaces(trace_t *trace, dp_model_t *model, const vec3_t start, const vec3_t end, int hitsupercontents) +void Collision_Cache_ClipLineToWorldSurfaces(trace_t *trace, dp_model_t *model, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) { - collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, &identitymatrix, &identitymatrix, start, end, hitsupercontents); + collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, &identitymatrix, &identitymatrix, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); if (cached->valid) { *trace = cached->result; return; } - Collision_ClipLineToWorld(trace, model, start, end, hitsupercontents, collision_extendmovelength.value, true); + Collision_ClipLineToWorld(trace, model, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, collision_extendmovelength.value, true); cached->result = *trace; } @@ -1741,7 +1790,7 @@ static void Collision_ClipExtendFinish(extendtraceinfo_t *extendtraceinfo) VectorMA(extendtraceinfo->realstart, trace->fraction, extendtraceinfo->realdelta, trace->endpos); } -void Collision_ClipToGenericEntity(trace_t *trace, dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, const vec3_t bodymins, const vec3_t bodymaxs, int bodysupercontents, matrix4x4_t *matrix, matrix4x4_t *inversematrix, const vec3_t tstart, const vec3_t mins, const vec3_t maxs, const vec3_t tend, int hitsupercontentsmask, float extend) +void Collision_ClipToGenericEntity(trace_t *trace, dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, const vec3_t bodymins, const vec3_t bodymaxs, int bodysupercontents, matrix4x4_t *matrix, matrix4x4_t *inversematrix, const vec3_t tstart, const vec3_t mins, const vec3_t maxs, const vec3_t tend, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend) { vec3_t starttransformed, endtransformed; extendtraceinfo_t extendtraceinfo; @@ -1769,13 +1818,13 @@ void Collision_ClipToGenericEntity(trace_t *trace, dp_model_t *model, const fram Collision_TransformBrush(inversematrix, &thisbrush_end.brush); //Collision_TranslateBrush(starttransformed, &thisbrush_start.brush); //Collision_TranslateBrush(endtransformed, &thisbrush_end.brush); - model->TraceBrush(model, frameblend, skeleton, trace, &thisbrush_start.brush, &thisbrush_end.brush, hitsupercontentsmask); + model->TraceBrush(model, frameblend, skeleton, trace, &thisbrush_start.brush, &thisbrush_end.brush, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); } else // this is only approximate if rotated, quite useless - model->TraceBox(model, frameblend, skeleton, trace, starttransformed, mins, maxs, endtransformed, hitsupercontentsmask); + model->TraceBox(model, frameblend, skeleton, trace, starttransformed, mins, maxs, endtransformed, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); } else // and this requires that the transformation matrix doesn't have angles components, like SV_TraceBox ensures; FIXME may get called if a model is SOLID_BSP but has no TraceBox function - Collision_ClipTrace_Box(trace, bodymins, bodymaxs, starttransformed, mins, maxs, endtransformed, hitsupercontentsmask, bodysupercontents, 0, NULL); + Collision_ClipTrace_Box(trace, bodymins, bodymaxs, starttransformed, mins, maxs, endtransformed, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, bodysupercontents, 0, NULL); Collision_ClipExtendFinish(&extendtraceinfo); @@ -1784,17 +1833,17 @@ void Collision_ClipToGenericEntity(trace_t *trace, dp_model_t *model, const fram Matrix4x4_TransformPositivePlane(matrix, trace->plane.normal[0], trace->plane.normal[1], trace->plane.normal[2], trace->plane.dist, trace->plane.normal_and_dist); } -void Collision_ClipToWorld(trace_t *trace, dp_model_t *model, const vec3_t tstart, const vec3_t mins, const vec3_t maxs, const vec3_t tend, int hitsupercontents, float extend) +void Collision_ClipToWorld(trace_t *trace, dp_model_t *model, const vec3_t tstart, const vec3_t mins, const vec3_t maxs, const vec3_t tend, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend) { extendtraceinfo_t extendtraceinfo; Collision_ClipExtendPrepare(&extendtraceinfo, trace, tstart, tend, extend); // ->TraceBox: TraceBrush not needed here, as worldmodel is never rotated if (model && model->TraceBox) - model->TraceBox(model, NULL, NULL, trace, extendtraceinfo.extendstart, mins, maxs, extendtraceinfo.extendend, hitsupercontents); + model->TraceBox(model, NULL, NULL, trace, extendtraceinfo.extendstart, mins, maxs, extendtraceinfo.extendend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); Collision_ClipExtendFinish(&extendtraceinfo); } -void Collision_ClipLineToGenericEntity(trace_t *trace, dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, const vec3_t bodymins, const vec3_t bodymaxs, int bodysupercontents, matrix4x4_t *matrix, matrix4x4_t *inversematrix, const vec3_t tstart, const vec3_t tend, int hitsupercontentsmask, float extend, qboolean hitsurfaces) +void Collision_ClipLineToGenericEntity(trace_t *trace, dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, const vec3_t bodymins, const vec3_t bodymaxs, int bodysupercontents, matrix4x4_t *matrix, matrix4x4_t *inversematrix, const vec3_t tstart, const vec3_t tend, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend, qboolean hitsurfaces) { vec3_t starttransformed, endtransformed; extendtraceinfo_t extendtraceinfo; @@ -1807,11 +1856,11 @@ void Collision_ClipLineToGenericEntity(trace_t *trace, dp_model_t *model, const #endif if (model && model->TraceLineAgainstSurfaces && hitsurfaces) - model->TraceLineAgainstSurfaces(model, frameblend, skeleton, trace, starttransformed, endtransformed, hitsupercontentsmask); + model->TraceLineAgainstSurfaces(model, frameblend, skeleton, trace, starttransformed, endtransformed, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); else if (model && model->TraceLine) - model->TraceLine(model, frameblend, skeleton, trace, starttransformed, endtransformed, hitsupercontentsmask); + model->TraceLine(model, frameblend, skeleton, trace, starttransformed, endtransformed, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); else - Collision_ClipTrace_Box(trace, bodymins, bodymaxs, starttransformed, vec3_origin, vec3_origin, endtransformed, hitsupercontentsmask, bodysupercontents, 0, NULL); + Collision_ClipTrace_Box(trace, bodymins, bodymaxs, starttransformed, vec3_origin, vec3_origin, endtransformed, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, bodysupercontents, 0, NULL); Collision_ClipExtendFinish(&extendtraceinfo); @@ -1820,20 +1869,20 @@ void Collision_ClipLineToGenericEntity(trace_t *trace, dp_model_t *model, const Matrix4x4_TransformPositivePlane(matrix, trace->plane.normal[0], trace->plane.normal[1], trace->plane.normal[2], trace->plane.dist, trace->plane.normal_and_dist); } -void Collision_ClipLineToWorld(trace_t *trace, dp_model_t *model, const vec3_t tstart, const vec3_t tend, int hitsupercontents, float extend, qboolean hitsurfaces) +void Collision_ClipLineToWorld(trace_t *trace, dp_model_t *model, const vec3_t tstart, const vec3_t tend, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend, qboolean hitsurfaces) { extendtraceinfo_t extendtraceinfo; Collision_ClipExtendPrepare(&extendtraceinfo, trace, tstart, tend, extend); if (model && model->TraceLineAgainstSurfaces && hitsurfaces) - model->TraceLineAgainstSurfaces(model, NULL, NULL, trace, extendtraceinfo.extendstart, extendtraceinfo.extendend, hitsupercontents); + model->TraceLineAgainstSurfaces(model, NULL, NULL, trace, extendtraceinfo.extendstart, extendtraceinfo.extendend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); else if (model && model->TraceLine) - model->TraceLine(model, NULL, NULL, trace, extendtraceinfo.extendstart, extendtraceinfo.extendend, hitsupercontents); + model->TraceLine(model, NULL, NULL, trace, extendtraceinfo.extendstart, extendtraceinfo.extendend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); Collision_ClipExtendFinish(&extendtraceinfo); } -void Collision_ClipPointToGenericEntity(trace_t *trace, dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, const vec3_t bodymins, const vec3_t bodymaxs, int bodysupercontents, matrix4x4_t *matrix, matrix4x4_t *inversematrix, const vec3_t start, int hitsupercontentsmask) +void Collision_ClipPointToGenericEntity(trace_t *trace, dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, const vec3_t bodymins, const vec3_t bodymaxs, int bodysupercontents, matrix4x4_t *matrix, matrix4x4_t *inversematrix, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) { float starttransformed[3]; memset(trace, 0, sizeof(*trace)); @@ -1845,9 +1894,9 @@ void Collision_ClipPointToGenericEntity(trace_t *trace, dp_model_t *model, const #endif if (model && model->TracePoint) - model->TracePoint(model, NULL, NULL, trace, starttransformed, hitsupercontentsmask); + model->TracePoint(model, NULL, NULL, trace, starttransformed, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); else - Collision_ClipTrace_Point(trace, bodymins, bodymaxs, starttransformed, hitsupercontentsmask, bodysupercontents, 0, NULL); + Collision_ClipTrace_Point(trace, bodymins, bodymaxs, starttransformed, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, bodysupercontents, 0, NULL); VectorCopy(start, trace->endpos); // transform plane @@ -1855,12 +1904,12 @@ void Collision_ClipPointToGenericEntity(trace_t *trace, dp_model_t *model, const Matrix4x4_TransformPositivePlane(matrix, trace->plane.normal[0], trace->plane.normal[1], trace->plane.normal[2], trace->plane.dist, trace->plane.normal_and_dist); } -void Collision_ClipPointToWorld(trace_t *trace, dp_model_t *model, const vec3_t start, int hitsupercontents) +void Collision_ClipPointToWorld(trace_t *trace, dp_model_t *model, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask) { memset(trace, 0, sizeof(*trace)); trace->fraction = 1; if (model && model->TracePoint) - model->TracePoint(model, NULL, NULL, trace, start, hitsupercontents); + model->TracePoint(model, NULL, NULL, trace, start, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask); VectorCopy(start, trace->endpos); }