X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=collision.c;h=f0251fb64a6966675e66cb73f40a1b4d50a508d3;hb=3daa2af221a54912514ea0d751b7b4514b644c67;hp=3438913656ec5581b752f63adcc22151f5c63510;hpb=7df6ca291a248ce599e9a36b6eba1ad8af48d494;p=xonotic%2Fdarkplaces.git diff --git a/collision.c b/collision.c index 34389136..f0251fb6 100644 --- a/collision.c +++ b/collision.c @@ -53,7 +53,7 @@ void Collision_Init (void) -void Collision_PrintBrushAsQHull(colbrushf_t *brush, const char *name) +static void Collision_PrintBrushAsQHull(colbrushf_t *brush, const char *name) { int i; Con_Printf("3 %s\n%i\n", name, brush->numpoints); @@ -65,7 +65,7 @@ void Collision_PrintBrushAsQHull(colbrushf_t *brush, const char *name) Con_Printf("%f %f %f %f\n", brush->planes[i].normal[0], brush->planes[i].normal[1], brush->planes[i].normal[2], brush->planes[i].dist); } -void Collision_ValidateBrush(colbrushf_t *brush) +static void Collision_ValidateBrush(colbrushf_t *brush) { int j, k, pointsoffplanes, pointonplanes, pointswithinsufficientplanes, printbrush; float d; @@ -124,7 +124,7 @@ void Collision_ValidateBrush(colbrushf_t *brush) Collision_PrintBrushAsQHull(brush, "unnamed"); } -float nearestplanedist_float(const float *normal, const colpointf_t *points, int numpoints) +static float nearestplanedist_float(const float *normal, const colpointf_t *points, int numpoints) { float dist, bestdist; if (!numpoints) @@ -140,7 +140,7 @@ float nearestplanedist_float(const float *normal, const colpointf_t *points, int return bestdist; } -float furthestplanedist_float(const float *normal, const colpointf_t *points, int numpoints) +static float furthestplanedist_float(const float *normal, const colpointf_t *points, int numpoints) { float dist, bestdist; if (!numpoints) @@ -156,7 +156,7 @@ float furthestplanedist_float(const float *normal, const colpointf_t *points, in return bestdist; } -void Collision_CalcEdgeDirsForPolygonBrushFloat(colbrushf_t *brush) +static void Collision_CalcEdgeDirsForPolygonBrushFloat(colbrushf_t *brush) { int i, j; for (i = 0, j = brush->numpoints - 1;i < brush->numpoints;j = i, i++) @@ -1032,7 +1032,7 @@ void Collision_TracePointBrushFloat(trace_t *trace, const vec3_t point, const co } } -void Collision_SnapCopyPoints(int numpoints, const colpointf_t *in, colpointf_t *out, float fractionprecision, float invfractionprecision) +static void Collision_SnapCopyPoints(int numpoints, const colpointf_t *in, colpointf_t *out, float fractionprecision, float invfractionprecision) { int i; for (i = 0;i < numpoints;i++) @@ -1247,28 +1247,6 @@ void Collision_BrushForBox(colboxbrushf_t *boxbrush, const vec3_t mins, const ve //Collision_ValidateBrush(&boxbrush->brush); } -void Collision_ClipTrace_BrushBox(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 supercontents, int q3surfaceflags, texture_t *texture) -{ - colboxbrushf_t boxbrush, thisbrush_start, thisbrush_end; - vec3_t startmins, startmaxs, endmins, endmaxs; - - // create brushes for the collision - VectorAdd(start, mins, startmins); - VectorAdd(start, maxs, startmaxs); - VectorAdd(end, mins, endmins); - VectorAdd(end, maxs, endmaxs); - Collision_BrushForBox(&boxbrush, cmins, cmaxs, supercontents, q3surfaceflags, texture); - Collision_BrushForBox(&thisbrush_start, startmins, startmaxs, 0, 0, NULL); - Collision_BrushForBox(&thisbrush_end, endmins, endmaxs, 0, 0, NULL); - - memset(trace, 0, sizeof(trace_t)); - trace->hitsupercontentsmask = hitsupercontentsmask; - trace->fraction = 1; - trace->realfraction = 1; - trace->allsolid = true; - Collision_TraceBrushBrushFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, &boxbrush.brush, &boxbrush.brush); -} - //pseudocode for detecting line/sphere overlap without calculating an impact point //linesphereorigin = sphereorigin - linestart;linediff = lineend - linestart;linespherefrac = DotProduct(linesphereorigin, linediff) / DotProduct(linediff, linediff);return VectorLength2(linesphereorigin - bound(0, linespherefrac, 1) * linediff) >= sphereradius*sphereradius; @@ -1278,7 +1256,7 @@ void Collision_ClipTrace_BrushBox(trace_t *trace, const vec3_t cmins, const vec3 // all the results are correct (impactpoint, impactnormal, and fraction) float Collision_ClipTrace_Line_Sphere(double *linestart, double *lineend, double *sphereorigin, double sphereradius, double *impactpoint, double *impactnormal) { - double dir[3], scale, v[3], deviationdist, impactdist, linelength; + double dir[3], scale, v[3], deviationdist2, impactdist, linelength; // make sure the impactpoint and impactnormal are valid even if there is // no collision VectorCopy(lineend, impactpoint); @@ -1300,13 +1278,12 @@ float Collision_ClipTrace_Line_Sphere(double *linestart, double *lineend, double // of the line from the sphereorigin (deviation, how off-center it is) VectorMA(linestart, impactdist, dir, v); VectorSubtract(v, sphereorigin, v); - deviationdist = VectorLength2(v); - // if outside the radius, it's a miss for sure - // (we do this comparison using squared radius to avoid a sqrt) - if (deviationdist > sphereradius*sphereradius) + deviationdist2 = sphereradius * sphereradius - VectorLength2(v); + // if squared offset length is outside the squared sphere radius, miss + if (deviationdist2 < 0) return 1; // miss (off to the side) // nudge back to find the correct impact distance - impactdist -= sphereradius - deviationdist/sphereradius; + impactdist -= sqrt(deviationdist2); if (impactdist >= linelength) return 1; // miss (not close enough) if (impactdist < 0) @@ -1538,55 +1515,6 @@ void Collision_TraceLineTriangleFloat(trace_t *trace, const vec3_t linestart, co #endif } -typedef struct colbspnode_s -{ - mplane_t plane; - struct colbspnode_s *children[2]; - // the node is reallocated or split if max is reached - int numcolbrushf; - int maxcolbrushf; - colbrushf_t **colbrushflist; - //int numcolbrushd; - //int maxcolbrushd; - //colbrushd_t **colbrushdlist; -} -colbspnode_t; - -typedef struct colbsp_s -{ - mempool_t *mempool; - colbspnode_t *nodes; -} -colbsp_t; - -colbsp_t *Collision_CreateCollisionBSP(mempool_t *mempool) -{ - colbsp_t *bsp; - bsp = (colbsp_t *)Mem_Alloc(mempool, sizeof(colbsp_t)); - bsp->mempool = mempool; - bsp->nodes = (colbspnode_t *)Mem_Alloc(bsp->mempool, sizeof(colbspnode_t)); - return bsp; -} - -void Collision_FreeCollisionBSPNode(colbspnode_t *node) -{ - if (node->children[0]) - Collision_FreeCollisionBSPNode(node->children[0]); - if (node->children[1]) - Collision_FreeCollisionBSPNode(node->children[1]); - while (--node->numcolbrushf) - Mem_Free(node->colbrushflist[node->numcolbrushf]); - //while (--node->numcolbrushd) - // Mem_Free(node->colbrushdlist[node->numcolbrushd]); - Mem_Free(node); -} - -void Collision_FreeCollisionBSP(colbsp_t *bsp) -{ - Collision_FreeCollisionBSPNode(bsp->nodes); - Mem_Free(bsp); -} - void Collision_BoundingBoxOfBrushTraceSegment(const colbrushf_t *start, const colbrushf_t *end, vec3_t mins, vec3_t maxs, float startfrac, float endfrac) { int i; @@ -1615,7 +1543,7 @@ void Collision_BoundingBoxOfBrushTraceSegment(const colbrushf_t *start, const co //=========================================== -void Collision_TranslateBrush(const vec3_t shift, colbrushf_t *brush) +static void Collision_TranslateBrush(const vec3_t shift, colbrushf_t *brush) { int i; // now we can transform the data @@ -1631,7 +1559,7 @@ void Collision_TranslateBrush(const vec3_t shift, colbrushf_t *brush) VectorAdd(brush->maxs, shift, brush->maxs); } -void Collision_TransformBrush(const matrix4x4_t *matrix, colbrushf_t *brush) +static void Collision_TransformBrush(const matrix4x4_t *matrix, colbrushf_t *brush) { int i; vec3_t v; @@ -1666,23 +1594,20 @@ void Collision_TransformBrush(const matrix4x4_t *matrix, colbrushf_t *brush) } } -typedef struct collision_cachedtrace_s +typedef struct collision_cachedtrace_parameters_s { - int next; - int sequence; dp_model_t *model; -// const frameblend_t *frameblend; -// const skeleton_t *skeleton; - vec3_t bodymins; - vec3_t bodymaxs; - int bodysupercontents; - matrix4x4_t matrix; - matrix4x4_t inversematrix; - vec3_t start; - vec3_t mins; - vec3_t maxs; vec3_t end; + vec3_t start; int hitsupercontentsmask; + matrix4x4_t matrix; +} +collision_cachedtrace_parameters_t; + +typedef struct collision_cachedtrace_s +{ + qboolean valid; + collision_cachedtrace_parameters_t p; trace_t result; } collision_cachedtrace_t; @@ -1695,6 +1620,11 @@ static int collision_cachedtrace_max; static int collision_cachedtrace_sequence; static int collision_cachedtrace_hashsize; static int *collision_cachedtrace_hash; +static unsigned int *collision_cachedtrace_arrayfullhashindex; +static unsigned int *collision_cachedtrace_arrayhashindex; +static unsigned int *collision_cachedtrace_arraynext; +static unsigned char *collision_cachedtrace_arrayused; +static qboolean collision_cachedtrace_rebuildhash; void Collision_Cache_Reset(qboolean resetlimits) { @@ -1702,14 +1632,27 @@ void Collision_Cache_Reset(qboolean resetlimits) Mem_Free(collision_cachedtrace_hash); if (collision_cachedtrace_array) Mem_Free(collision_cachedtrace_array); + if (collision_cachedtrace_arrayfullhashindex) + Mem_Free(collision_cachedtrace_arrayfullhashindex); + if (collision_cachedtrace_arrayhashindex) + Mem_Free(collision_cachedtrace_arrayhashindex); + if (collision_cachedtrace_arraynext) + Mem_Free(collision_cachedtrace_arraynext); + if (collision_cachedtrace_arrayused) + Mem_Free(collision_cachedtrace_arrayused); if (resetlimits || !collision_cachedtrace_max) - collision_cachedtrace_max = 1024; + collision_cachedtrace_max = collision_cache.integer ? 128 : 1; collision_cachedtrace_firstfree = 1; collision_cachedtrace_lastused = 0; - collision_cachedtrace_hashsize = collision_cachedtrace_max * 2; + collision_cachedtrace_hashsize = collision_cachedtrace_max; collision_cachedtrace_array = (collision_cachedtrace_t *)Mem_Alloc(collision_cachedtrace_mempool, collision_cachedtrace_max * sizeof(collision_cachedtrace_t)); collision_cachedtrace_hash = (int *)Mem_Alloc(collision_cachedtrace_mempool, collision_cachedtrace_hashsize * sizeof(int)); + collision_cachedtrace_arrayfullhashindex = (unsigned int *)Mem_Alloc(collision_cachedtrace_mempool, collision_cachedtrace_max * sizeof(unsigned int)); + collision_cachedtrace_arrayhashindex = (unsigned int *)Mem_Alloc(collision_cachedtrace_mempool, collision_cachedtrace_max * sizeof(unsigned int)); + collision_cachedtrace_arraynext = (unsigned int *)Mem_Alloc(collision_cachedtrace_mempool, collision_cachedtrace_max * sizeof(unsigned int)); + collision_cachedtrace_arrayused = (unsigned char *)Mem_Alloc(collision_cachedtrace_mempool, collision_cachedtrace_max * sizeof(unsigned char)); collision_cachedtrace_sequence = 1; + collision_cachedtrace_rebuildhash = false; } void Collision_Cache_Init(mempool_t *mempool) @@ -1718,123 +1661,210 @@ void Collision_Cache_Init(mempool_t *mempool) Collision_Cache_Reset(true); } -void Collision_Cache_NewFrame(void) +static void Collision_Cache_RebuildHash(void) { - int hashindex; int index; - int *p; - // unlink all stale traces - for (hashindex = 0;hashindex < collision_cachedtrace_hashsize;hashindex++) + int range = collision_cachedtrace_lastused + 1; + int sequence = collision_cachedtrace_sequence; + int firstfree = collision_cachedtrace_max; + int lastused = 0; + int *hash = collision_cachedtrace_hash; + unsigned int hashindex; + unsigned int *arrayhashindex = collision_cachedtrace_arrayhashindex; + unsigned int *arraynext = collision_cachedtrace_arraynext; + collision_cachedtrace_rebuildhash = false; + memset(collision_cachedtrace_hash, 0, collision_cachedtrace_hashsize * sizeof(int)); + for (index = 1;index < range;index++) { - if (!collision_cachedtrace_hash[hashindex]) - continue; - p = &collision_cachedtrace_hash[hashindex]; - while ((index = *p)) + if (collision_cachedtrace_arrayused[index] == sequence) { - if (collision_cachedtrace_array[index].sequence != collision_cachedtrace_sequence) - { - if (collision_cachedtrace_firstfree > index) - collision_cachedtrace_firstfree = index; - *p = collision_cachedtrace_array[index].next; - collision_cachedtrace_array[index].sequence = 0; - //memset(&collision_cachedtrace_array[index], 0, sizeof(collision_cachedtrace_array[index])); - } - else - p = &collision_cachedtrace_array[index].next; + hashindex = arrayhashindex[index]; + arraynext[index] = hash[hashindex]; + hash[hashindex] = index; + lastused = index; + } + else + { + if (firstfree > index) + firstfree = index; + collision_cachedtrace_arrayused[index] = 0; } } - // shrink used range if possible - index = collision_cachedtrace_lastused; - while (index && collision_cachedtrace_array[index].sequence == 0) - index--; - collision_cachedtrace_lastused = index; - // increment sequence - collision_cachedtrace_sequence++; - // do not allow sequence to wrap to 0 - if (collision_cachedtrace_sequence >= 1<<30) + collision_cachedtrace_firstfree = firstfree; + collision_cachedtrace_lastused = lastused; +} + +void Collision_Cache_NewFrame(void) +{ + if (collision_cache.integer) + { + if (collision_cachedtrace_max < 128) + Collision_Cache_Reset(true); + } + else + { + if (collision_cachedtrace_max > 1) + Collision_Cache_Reset(true); + } + // rebuild hash if sequence would overflow byte, otherwise increment + if (collision_cachedtrace_sequence == 255) + { + Collision_Cache_RebuildHash(); collision_cachedtrace_sequence = 1; + } + else + { + collision_cachedtrace_rebuildhash = true; + collision_cachedtrace_sequence++; + } } -static collision_cachedtrace_t *Collision_Cache_Lookup(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, const vec3_t bodymins, const vec3_t bodymaxs, int bodysupercontents, const matrix4x4_t *matrix, const matrix4x4_t *inversematrix, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask) +static unsigned int Collision_Cache_HashIndexForArray(unsigned int *array, unsigned int size) +{ + unsigned int i; + unsigned int hashindex = 0; + // this is a super-cheesy checksum, designed only for speed + for (i = 0;i < size;i++) + hashindex += array[i] * (1 + i); + 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) { int hashindex = 0; + unsigned int fullhashindex; int index = 0; + int range; + int sequence = collision_cachedtrace_sequence; + int *hash = collision_cachedtrace_hash; + unsigned int *arrayfullhashindex = collision_cachedtrace_arrayfullhashindex; + unsigned int *arraynext = collision_cachedtrace_arraynext; collision_cachedtrace_t *cached = collision_cachedtrace_array + index; + collision_cachedtrace_parameters_t params; // all non-cached traces use the same index - if ((frameblend && frameblend[0].lerp != 1) || (skeleton && skeleton->relativetransforms)) - r_refdef.stats.collisioncache_animated++; - else if (!collision_cache.integer) + if (!collision_cache.integer) r_refdef.stats.collisioncache_traced++; else { // cached trace lookup - hashindex = (int)(((size_t)model + (size_t) + (size_t)(start[0] * 53 + start[1] * 207 + start[2] * 97 + end[0] * 37 + end[1] * 743 + end[2] * 13) + bodysupercontents + hitsupercontentsmask) % collision_cachedtrace_hashsize); - for (index = collision_cachedtrace_hash[hashindex];index;index = cached->next) + memset(¶ms, 0, sizeof(params)); + params.model = model; + VectorCopy(start, params.start); + VectorCopy(end, params.end); + params.hitsupercontentsmask = hitsupercontentsmask; + params.matrix = *matrix; + fullhashindex = Collision_Cache_HashIndexForArray((unsigned int *)¶ms, sizeof(params) / sizeof(unsigned int)); + hashindex = (int)(fullhashindex % (unsigned int)collision_cachedtrace_hashsize); + for (index = hash[hashindex];index;index = arraynext[index]) { + if (arrayfullhashindex[index] != fullhashindex) + continue; cached = collision_cachedtrace_array + index; - if (VectorCompare(cached->start, start) - && VectorCompare(cached->end, end) - && cached->model == model - && VectorCompare(cached->bodymins, bodymins) - && VectorCompare(cached->bodymaxs, bodymaxs) - && cached->bodysupercontents == bodysupercontents - && VectorCompare(cached->mins, mins) - && VectorCompare(cached->maxs, maxs) - && cached->hitsupercontentsmask == hitsupercontentsmask - && !memcmp(&cached->matrix, matrix, sizeof(*matrix))) - { - r_refdef.stats.collisioncache_cached++; - return cached; // found a match - } + //if (memcmp(&cached->p, ¶ms, sizeof(params))) + if (cached->p.model != params.model + || cached->p.end[0] != params.end[0] + || cached->p.end[1] != params.end[1] + || cached->p.end[2] != params.end[2] + || cached->p.start[0] != params.start[0] + || cached->p.start[1] != params.start[1] + || cached->p.start[2] != params.start[2] + || cached->p.hitsupercontentsmask != params.hitsupercontentsmask + || 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] + || cached->p.matrix.m[0][3] != params.matrix.m[0][3] + || cached->p.matrix.m[1][0] != params.matrix.m[1][0] + || cached->p.matrix.m[1][1] != params.matrix.m[1][1] + || cached->p.matrix.m[1][2] != params.matrix.m[1][2] + || cached->p.matrix.m[1][3] != params.matrix.m[1][3] + || cached->p.matrix.m[2][0] != params.matrix.m[2][0] + || cached->p.matrix.m[2][1] != params.matrix.m[2][1] + || cached->p.matrix.m[2][2] != params.matrix.m[2][2] + || cached->p.matrix.m[2][3] != params.matrix.m[2][3] + || cached->p.matrix.m[3][0] != params.matrix.m[3][0] + || cached->p.matrix.m[3][1] != params.matrix.m[3][1] + || cached->p.matrix.m[3][2] != params.matrix.m[3][2] + || cached->p.matrix.m[3][3] != params.matrix.m[3][3] + ) + continue; + // found a matching trace in the cache + r_refdef.stats.collisioncache_cached++; + cached->valid = true; + collision_cachedtrace_arrayused[index] = collision_cachedtrace_sequence; + return cached; } r_refdef.stats.collisioncache_traced++; // find an unused cache entry - for (index = collision_cachedtrace_firstfree;index <= collision_cachedtrace_lastused;index++) - if (!collision_cachedtrace_array[index].sequence) + for (index = collision_cachedtrace_firstfree, range = collision_cachedtrace_max;index < range;index++) + if (collision_cachedtrace_arrayused[index] == 0) break; - collision_cachedtrace_firstfree = index; - if (index > collision_cachedtrace_lastused) + if (index == range) { - // see if we need to reset the cache for growth - if (collision_cachedtrace_max <= index) + // all claimed, but probably some are stale... + for (index = 1, range = collision_cachedtrace_max;index < range;index++) + if (collision_cachedtrace_arrayused[index] != sequence) + break; + if (index < range) + { + // found a stale one, rebuild the hash + Collision_Cache_RebuildHash(); + } + else { + // we need to grow the cache collision_cachedtrace_max *= 2; Collision_Cache_Reset(false); - collision_cachedtrace_firstfree = index = 1; + index = 1; } - collision_cachedtrace_lastused = index; } // link the new cache entry into the hash bucket + collision_cachedtrace_firstfree = index + 1; + if (collision_cachedtrace_lastused < index) + collision_cachedtrace_lastused = index; cached = collision_cachedtrace_array + index; - cached->next = collision_cachedtrace_hash[hashindex]; + collision_cachedtrace_arraynext[index] = collision_cachedtrace_hash[hashindex]; collision_cachedtrace_hash[hashindex] = index; - cached->model = model; - VectorCopy(bodymins, cached->bodymins); - VectorCopy(bodymaxs, cached->bodymaxs); - cached->bodysupercontents = bodysupercontents; - VectorCopy(start, cached->start); - VectorCopy(mins, cached->mins); - VectorCopy(maxs, cached->maxs); - VectorCopy(end, cached->end); - cached->hitsupercontentsmask = hitsupercontentsmask; - cached->matrix = *matrix; - cached->inversematrix = *inversematrix; + collision_cachedtrace_arrayhashindex[index] = hashindex; + cached->valid = false; + cached->p = params; + collision_cachedtrace_arrayfullhashindex[index] = fullhashindex; + collision_cachedtrace_arrayused[index] = collision_cachedtrace_sequence; } - cached->sequence = 0; return cached; } -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 start, const vec3_t mins, const vec3_t maxs, 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) { - float starttransformed[3], endtransformed[3]; - collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, frameblend, skeleton, bodymins, bodymaxs, bodysupercontents, matrix, inversematrix, start, mins, maxs, end, hitsupercontentsmask); - if (cached->sequence) + collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, matrix, inversematrix, start, end, hitsupercontentsmask); + if (cached->valid) { - cached->sequence = collision_cachedtrace_sequence; *trace = cached->result; return; } + Collision_ClipLineToGenericEntity(trace, model, NULL, NULL, vec3_origin, vec3_origin, 0, matrix, inversematrix, start, end, hitsupercontentsmask, 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) +{ + collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, &identitymatrix, &identitymatrix, start, end, hitsupercontents); + if (cached->valid) + { + *trace = cached->result; + return; + } + + Collision_ClipLineToWorld(trace, model, start, end, hitsupercontents, true); + + cached->result = *trace; +} + +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 start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask) +{ + float starttransformed[3], endtransformed[3]; + memset(trace, 0, sizeof(*trace)); trace->fraction = trace->realfraction = 1; @@ -1874,21 +1904,10 @@ void Collision_ClipToGenericEntity(trace_t *trace, dp_model_t *model, const fram // transform plane // NOTE: this relies on plane.dist being directly after plane.normal Matrix4x4_TransformPositivePlane(matrix, trace->plane.normal[0], trace->plane.normal[1], trace->plane.normal[2], trace->plane.dist, trace->plane.normal); - - cached->sequence = collision_cachedtrace_sequence; - cached->result = *trace; } void Collision_ClipToWorld(trace_t *trace, dp_model_t *model, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontents) { - collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, NULL, NULL, vec3_origin, vec3_origin, 0, &identitymatrix, &identitymatrix, start, mins, maxs, end, hitsupercontents); - if (cached->sequence) - { - cached->sequence = collision_cachedtrace_sequence; - *trace = cached->result; - return; - } - memset(trace, 0, sizeof(*trace)); trace->fraction = trace->realfraction = 1; // ->TraceBox: TraceBrush not needed here, as worldmodel is never rotated @@ -1897,22 +1916,11 @@ void Collision_ClipToWorld(trace_t *trace, dp_model_t *model, const vec3_t start trace->fraction = bound(0, trace->fraction, 1); trace->realfraction = bound(0, trace->realfraction, 1); VectorLerp(start, trace->fraction, end, trace->endpos); - - cached->sequence = collision_cachedtrace_sequence; - cached->result = *trace; } 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 start, const vec3_t end, int hitsupercontentsmask, qboolean hitsurfaces) { float starttransformed[3], endtransformed[3]; - collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, frameblend, skeleton, bodymins, bodymaxs, bodysupercontents, matrix, inversematrix, start, vec3_origin, vec3_origin, end, hitsupercontentsmask); - if (cached->sequence) - { - cached->sequence = collision_cachedtrace_sequence; - *trace = cached->result; - return; - } - memset(trace, 0, sizeof(*trace)); trace->fraction = trace->realfraction = 1; @@ -1935,21 +1943,10 @@ void Collision_ClipLineToGenericEntity(trace_t *trace, dp_model_t *model, const // transform plane // NOTE: this relies on plane.dist being directly after plane.normal Matrix4x4_TransformPositivePlane(matrix, trace->plane.normal[0], trace->plane.normal[1], trace->plane.normal[2], trace->plane.dist, trace->plane.normal); - - cached->sequence = collision_cachedtrace_sequence; - cached->result = *trace; } void Collision_ClipLineToWorld(trace_t *trace, dp_model_t *model, const vec3_t start, const vec3_t end, int hitsupercontents, qboolean hitsurfaces) { - collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, NULL, NULL, vec3_origin, vec3_origin, 0, &identitymatrix, &identitymatrix, start, vec3_origin, vec3_origin, end, hitsupercontents); - if (cached->sequence) - { - cached->sequence = collision_cachedtrace_sequence; - *trace = cached->result; - return; - } - memset(trace, 0, sizeof(*trace)); trace->fraction = trace->realfraction = 1; if (model && model->TraceLineAgainstSurfaces && hitsurfaces) @@ -1959,22 +1956,11 @@ void Collision_ClipLineToWorld(trace_t *trace, dp_model_t *model, const vec3_t s trace->fraction = bound(0, trace->fraction, 1); trace->realfraction = bound(0, trace->realfraction, 1); VectorLerp(start, trace->fraction, end, trace->endpos); - - cached->sequence = collision_cachedtrace_sequence; - cached->result = *trace; } 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) { float starttransformed[3]; - collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, frameblend, skeleton, bodymins, bodymaxs, bodysupercontents, matrix, inversematrix, start, vec3_origin, vec3_origin, start, hitsupercontentsmask); - if (cached->sequence) - { - cached->sequence = collision_cachedtrace_sequence; - *trace = cached->result; - return; - } - memset(trace, 0, sizeof(*trace)); trace->fraction = trace->realfraction = 1; @@ -1992,29 +1978,15 @@ void Collision_ClipPointToGenericEntity(trace_t *trace, dp_model_t *model, const // transform plane // NOTE: this relies on plane.dist being directly after plane.normal Matrix4x4_TransformPositivePlane(matrix, trace->plane.normal[0], trace->plane.normal[1], trace->plane.normal[2], trace->plane.dist, trace->plane.normal); - - cached->sequence = collision_cachedtrace_sequence; - cached->result = *trace; } void Collision_ClipPointToWorld(trace_t *trace, dp_model_t *model, const vec3_t start, int hitsupercontents) { - collision_cachedtrace_t *cached = Collision_Cache_Lookup(model, NULL, NULL, vec3_origin, vec3_origin, 0, &identitymatrix, &identitymatrix, start, vec3_origin, vec3_origin, start, hitsupercontents); - if (cached->sequence) - { - cached->sequence = collision_cachedtrace_sequence; - *trace = cached->result; - return; - } - memset(trace, 0, sizeof(*trace)); trace->fraction = trace->realfraction = 1; if (model && model->TracePoint) model->TracePoint(model, NULL, NULL, trace, start, hitsupercontents); VectorCopy(start, trace->endpos); - - cached->sequence = collision_cachedtrace_sequence; - cached->result = *trace; } void Collision_CombineTraces(trace_t *cliptrace, const trace_t *trace, void *touch, qboolean isbmodel)