X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=collision.c;h=31498891d27c96916faedffc83f508a6e0e9847e;hb=1584b69e04ea4dcd6042197b925f8d72127f5120;hp=1e8895606a939c9f79dbbba3028f4ce4c83d3e01;hpb=f489a657f28418efa08ca8907f5f78e17b44655f;p=xonotic%2Fdarkplaces.git diff --git a/collision.c b/collision.c index 1e889560..31498891 100644 --- a/collision.c +++ b/collision.c @@ -561,11 +561,13 @@ colbrushf_t *Collision_AllocBrushFromPermanentPolygonFloat(mempool_t *mempool, i void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, const colbrushf_t *thatbrush_start, const colbrushf_t *thatbrush_end) { int nplane, nplane2, hitq3surfaceflags = 0; - float enterfrac = -1, leavefrac = 1, d1, d2, f, imove, newimpactnormal[3], enterfrac2 = -1; + float enterfrac = -1, leavefrac = 1, d1, d2, s, e, ie, f, imove, enterfrac2 = -1; const colplanef_t *startplane, *endplane; + plane_t newimpactplane; texture_t *hittexture = NULL; - VectorClear(newimpactnormal); + VectorClear(newimpactplane.normal); + newimpactplane.dist = 0; for (nplane = 0;nplane < thatbrush_start->numplanes + thisbrush_start->numplanes;nplane++) { @@ -587,8 +589,10 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush if (fabs(f - startplane->dist) > COLLISION_PLANE_DIST_EPSILON) Con_Printf("startplane->dist %f != calculated %f (thisbrush_start)\n", startplane->dist, f); } - d1 = nearestplanedist_float(startplane->normal, thisbrush_start->points, thisbrush_start->numpoints) - furthestplanedist_float(startplane->normal, thatbrush_start->points, thatbrush_start->numpoints) - collision_startnudge.value; - d2 = nearestplanedist_float(endplane->normal, thisbrush_end->points, thisbrush_end->numpoints) - furthestplanedist_float(endplane->normal, thatbrush_end->points, thatbrush_end->numpoints) - collision_endnudge.value; + s = furthestplanedist_float(startplane->normal, thatbrush_start->points, thatbrush_start->numpoints); + e = furthestplanedist_float(endplane->normal, thatbrush_end->points, thatbrush_end->numpoints); + d1 = nearestplanedist_float(startplane->normal, thisbrush_start->points, thisbrush_start->numpoints) - s - collision_startnudge.value; + d2 = nearestplanedist_float(endplane->normal, thisbrush_end->points, thisbrush_end->numpoints) - e - collision_endnudge.value; } else { @@ -606,8 +610,10 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush if (fabs(f - startplane->dist) > COLLISION_PLANE_DIST_EPSILON) Con_Printf("startplane->dist %f != calculated %f (thatbrush_start)\n", startplane->dist, f); } - d1 = nearestplanedist_float(startplane->normal, thisbrush_start->points, thisbrush_start->numpoints) - startplane->dist - collision_startnudge.value; - d2 = nearestplanedist_float(endplane->normal, thisbrush_end->points, thisbrush_end->numpoints) - endplane->dist - collision_endnudge.value; + s = startplane->dist; + e = endplane->dist; + d1 = nearestplanedist_float(startplane->normal, thisbrush_start->points, thisbrush_start->numpoints) - s - collision_startnudge.value; + d2 = nearestplanedist_float(endplane->normal, thisbrush_end->points, thisbrush_end->numpoints) - e - collision_endnudge.value; } //Con_Printf("%c%i: d1 = %f, d2 = %f, d1 / (d1 - d2) = %f\n", nplane2 != nplane ? 'b' : 'a', nplane2, d1, d2, d1 / (d1 - d2)); @@ -639,7 +645,11 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush // calculate the nudged fraction and impact normal we'll // need if we accept this collision later enterfrac2 = (d1 - collision_impactnudge.value) * imove; - VectorLerp(startplane->normal, enterfrac, endplane->normal, newimpactnormal); + ie = 1.0f - enterfrac; + newimpactplane.normal[0] = startplane->normal[0] * ie + endplane->normal[0] * enterfrac; + newimpactplane.normal[1] = startplane->normal[1] * ie + endplane->normal[1] * enterfrac; + newimpactplane.normal[2] = startplane->normal[2] * ie + endplane->normal[2] * enterfrac; + newimpactplane.dist = s * ie + e * enterfrac; hitq3surfaceflags = startplane->q3surfaceflags; hittexture = startplane->texture; } @@ -686,7 +696,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush trace->fraction = bound(0, enterfrac2, 1); if (collision_prefernudgedfraction.integer) trace->realfraction = trace->fraction; - VectorCopy(newimpactnormal, trace->plane.normal); + trace->plane = newimpactplane; } } else @@ -698,6 +708,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush trace->startsolid = true; if (leavefrac < 1) trace->allsolid = true; + trace->plane = newimpactplane; } } } @@ -706,11 +717,13 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const vec3_t lineend, const colbrushf_t *thatbrush_start, const colbrushf_t *thatbrush_end) { int nplane, hitq3surfaceflags = 0; - float enterfrac = -1, leavefrac = 1, d1, d2, f, imove, newimpactnormal[3], enterfrac2 = -1; + float enterfrac = -1, leavefrac = 1, d1, d2, ie, f, imove, enterfrac2 = -1; const colplanef_t *startplane, *endplane; + plane_t newimpactplane; texture_t *hittexture = NULL; - VectorClear(newimpactnormal); + VectorClear(newimpactplane.normal); + newimpactplane.dist = 0; for (nplane = 0;nplane < thatbrush_start->numplanes;nplane++) { @@ -762,7 +775,11 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const // calculate the nudged fraction and impact normal we'll // need if we accept this collision later enterfrac2 = (d1 - collision_impactnudge.value) * imove; - VectorLerp(startplane->normal, enterfrac, endplane->normal, newimpactnormal); + ie = 1.0f - enterfrac; + newimpactplane.normal[0] = startplane->normal[0] * ie + endplane->normal[0] * enterfrac; + newimpactplane.normal[1] = startplane->normal[1] * ie + endplane->normal[1] * enterfrac; + newimpactplane.normal[2] = startplane->normal[2] * ie + endplane->normal[2] * enterfrac; + newimpactplane.dist = startplane->dist * ie + endplane->dist * enterfrac; hitq3surfaceflags = startplane->q3surfaceflags; hittexture = startplane->texture; } @@ -807,7 +824,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const trace->fraction = bound(0, enterfrac2, 1); if (collision_prefernudgedfraction.integer) trace->realfraction = trace->fraction; - VectorCopy(newimpactnormal, trace->plane.normal); + trace->plane = newimpactplane; } } else @@ -819,18 +836,28 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const trace->startsolid = true; if (leavefrac < 1) trace->allsolid = true; + trace->plane = newimpactplane; } } } -void Collision_TracePointBrushFloat(trace_t *trace, const vec3_t point, const colbrushf_t *thatbrush) +qboolean Collision_PointInsideBrushFloat(const vec3_t point, const colbrushf_t *brush) { int nplane; const colplanef_t *plane; - for (nplane = 0, plane = thatbrush->planes;nplane < thatbrush->numplanes;nplane++, plane++) + if (!BoxesOverlap(point, point, brush->mins, brush->maxs)) + return false; + for (nplane = 0, plane = brush->planes;nplane < brush->numplanes;nplane++, plane++) if (DotProduct(plane->normal, point) > plane->dist) - return; + return false; + return true; +} + +void Collision_TracePointBrushFloat(trace_t *trace, const vec3_t point, const colbrushf_t *thatbrush) +{ + if (!Collision_PointInsideBrushFloat(point, thatbrush)) + return; trace->startsupercontents |= thatbrush->supercontents; if (trace->hitsupercontentsmask & thatbrush->supercontents) @@ -874,7 +901,7 @@ void Collision_TraceBrushPolygonFloat(trace_t *trace, const colbrushf_t *thisbru Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &polyf_brush, &polyf_brush); } -void Collision_TraceBrushTriangleMeshFloat(trace_t *trace, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int numtriangles, const int *element3i, const float *vertex3f, int supercontents, int q3surfaceflags, texture_t *texture, const vec3_t segmentmins, const vec3_t segmentmaxs) +void Collision_TraceBrushTriangleMeshFloat(trace_t *trace, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int numtriangles, const int *element3i, const float *vertex3f, int stride, float *bbox6f, int supercontents, int q3surfaceflags, texture_t *texture, const vec3_t segmentmins, const vec3_t segmentmaxs) { int i; polyf_brush.numpoints = 3; @@ -887,17 +914,44 @@ void Collision_TraceBrushTriangleMeshFloat(trace_t *trace, const colbrushf_t *th polyf_brush.planes[i].q3surfaceflags = q3surfaceflags; polyf_brush.planes[i].texture = texture; } - for (i = 0;i < numtriangles;i++, element3i += 3) + if(stride) { - if (TriangleOverlapsBox(vertex3f + element3i[0]*3, vertex3f + element3i[1]*3, vertex3f + element3i[2]*3, segmentmins, segmentmaxs)) + int k, cnt, tri; + cnt = (numtriangles + stride - 1) / stride; + for(i = 0; i < cnt; ++i) { - VectorCopy(vertex3f + element3i[0] * 3, polyf_points[0].v); - VectorCopy(vertex3f + element3i[1] * 3, polyf_points[1].v); - VectorCopy(vertex3f + element3i[2] * 3, polyf_points[2].v); - Collision_SnapCopyPoints(polyf_brush.numpoints, polyf_points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP); - Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush); - //Collision_PrintBrushAsQHull(&polyf_brush, "polyf_brush"); - Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &polyf_brush, &polyf_brush); + if(BoxesOverlap(bbox6f + i * 6, bbox6f + i * 6 + 3, segmentmins, segmentmaxs)) + { + for(k = 0; k < stride; ++k) + { + tri = i * stride + k; + if(tri >= numtriangles) + break; + VectorCopy(vertex3f + element3i[tri * 3 + 0] * 3, polyf_points[0].v); + VectorCopy(vertex3f + element3i[tri * 3 + 1] * 3, polyf_points[1].v); + VectorCopy(vertex3f + element3i[tri * 3 + 2] * 3, polyf_points[2].v); + Collision_SnapCopyPoints(polyf_brush.numpoints, polyf_points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP); + Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush); + //Collision_PrintBrushAsQHull(&polyf_brush, "polyf_brush"); + Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &polyf_brush, &polyf_brush); + } + } + } + } + else + { + for (i = 0;i < numtriangles;i++, element3i += 3) + { + if (TriangleOverlapsBox(vertex3f + element3i[0]*3, vertex3f + element3i[1]*3, vertex3f + element3i[2]*3, segmentmins, segmentmaxs)) + { + VectorCopy(vertex3f + element3i[0] * 3, polyf_points[0].v); + VectorCopy(vertex3f + element3i[1] * 3, polyf_points[1].v); + VectorCopy(vertex3f + element3i[2] * 3, polyf_points[2].v); + Collision_SnapCopyPoints(polyf_brush.numpoints, polyf_points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP); + Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush); + //Collision_PrintBrushAsQHull(&polyf_brush, "polyf_brush"); + Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &polyf_brush, &polyf_brush); + } } } } @@ -921,13 +975,34 @@ void Collision_TraceLinePolygonFloat(trace_t *trace, const vec3_t linestart, con Collision_TraceLineBrushFloat(trace, linestart, lineend, &polyf_brush, &polyf_brush); } -void Collision_TraceLineTriangleMeshFloat(trace_t *trace, const vec3_t linestart, const vec3_t lineend, int numtriangles, const int *element3i, const float *vertex3f, int supercontents, int q3surfaceflags, texture_t *texture, const vec3_t segmentmins, const vec3_t segmentmaxs) +void Collision_TraceLineTriangleMeshFloat(trace_t *trace, const vec3_t linestart, const vec3_t lineend, int numtriangles, const int *element3i, const float *vertex3f, int stride, float *bbox6f, int supercontents, int q3surfaceflags, texture_t *texture, const vec3_t segmentmins, const vec3_t segmentmaxs) { int i; #if 1 // FIXME: snap vertices? - for (i = 0;i < numtriangles;i++, element3i += 3) - Collision_TraceLineTriangleFloat(trace, linestart, lineend, vertex3f + element3i[0] * 3, vertex3f + element3i[1] * 3, vertex3f + element3i[2] * 3, supercontents, q3surfaceflags, texture); + if(stride) + { + int k, cnt, tri; + cnt = (numtriangles + stride - 1) / stride; + for(i = 0; i < cnt; ++i) + { + if(BoxesOverlap(bbox6f + i * 6, bbox6f + i * 6 + 3, segmentmins, segmentmaxs)) + { + for(k = 0; k < stride; ++k) + { + tri = i * stride + k; + if(tri >= numtriangles) + break; + Collision_TraceLineTriangleFloat(trace, linestart, lineend, vertex3f + element3i[tri * 3 + 0] * 3, vertex3f + element3i[tri * 3 + 1] * 3, vertex3f + element3i[tri * 3 + 2] * 3, supercontents, q3surfaceflags, texture); + } + } + } + } + else + { + for (i = 0;i < numtriangles;i++, element3i += 3) + Collision_TraceLineTriangleFloat(trace, linestart, lineend, vertex3f + element3i[0] * 3, vertex3f + element3i[1] * 3, vertex3f + element3i[2] * 3, supercontents, q3surfaceflags, texture); + } #else polyf_brush.numpoints = 3; polyf_brush.numplanes = 5; @@ -1002,7 +1077,9 @@ void Collision_TraceBrushPolygonTransformFloat(trace_t *trace, const colbrushf_t #define MAX_BRUSHFORBOX 16 -static int brushforbox_index = 0; +static unsigned int brushforbox_index = 0; +// note: this relies on integer overflow to be consistent with modulo +// MAX_BRUSHFORBOX, or in other words, MAX_BRUSHFORBOX must be a power of two! static colpointf_t brushforbox_point[MAX_BRUSHFORBOX*8]; static colplanef_t brushforbox_plane[MAX_BRUSHFORBOX*6]; static colbrushf_t brushforbox_brush[MAX_BRUSHFORBOX]; @@ -1145,7 +1222,7 @@ float Collision_ClipTrace_Line_Sphere(double *linestart, double *lineend, double if (deviationdist > sphereradius*sphereradius) return 1; // miss (off to the side) // nudge back to find the correct impact distance - impactdist += deviationdist - sphereradius; + impactdist -= sphereradius - deviationdist/sphereradius; if (impactdist >= linelength) return 1; // miss (not close enough) if (impactdist < 0) @@ -1454,9 +1531,9 @@ void Collision_BoundingBoxOfBrushTraceSegment(const colbrushf_t *start, const co //=========================================== -void Collision_ClipToGenericEntity(trace_t *trace, model_t *model, int frame, 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_ClipToGenericEntity(trace_t *trace, dp_model_t *model, int frame, 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 tempnormal[3], starttransformed[3], endtransformed[3]; + float starttransformed[3], endtransformed[3]; memset(trace, 0, sizeof(*trace)); trace->fraction = trace->realfraction = 1; @@ -1475,16 +1552,13 @@ void Collision_ClipToGenericEntity(trace_t *trace, model_t *model, int frame, co trace->fraction = bound(0, trace->fraction, 1); trace->realfraction = bound(0, trace->realfraction, 1); - if (trace->fraction < 1) - { - VectorLerp(start, trace->fraction, end, trace->endpos); - VectorCopy(trace->plane.normal, tempnormal); - Matrix4x4_Transform3x3(matrix, tempnormal, trace->plane.normal); - // FIXME: should recalc trace->plane.dist - } + VectorLerp(start, trace->fraction, end, trace->endpos); + // 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); } -void Collision_ClipToWorld(trace_t *trace, model_t *model, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontents) +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) { memset(trace, 0, sizeof(*trace)); trace->fraction = trace->realfraction = 1; @@ -1515,7 +1589,7 @@ void Collision_CombineTraces(trace_t *cliptrace, const trace_t *trace, void *tou // cliptrace->inopen = true; if (trace->inwater) cliptrace->inwater = true; - if (trace->realfraction < cliptrace->realfraction) + if ((trace->realfraction <= cliptrace->realfraction) && (VectorLength2(trace->plane.normal) > 0)) { cliptrace->fraction = trace->fraction; cliptrace->realfraction = trace->realfraction; @@ -1528,3 +1602,22 @@ void Collision_CombineTraces(trace_t *cliptrace, const trace_t *trace, void *tou } cliptrace->startsupercontents |= trace->startsupercontents; } + +void Collision_ShortenTrace(trace_t *trace, float shorten_factor, const vec3_t end) +{ + // now undo our moving end 1 qu farther... + trace->fraction = bound(trace->fraction, trace->fraction / shorten_factor - 1e-6, 1); // we subtract 1e-6 to guard for roundoff errors + trace->realfraction = bound(trace->realfraction, trace->realfraction / shorten_factor - 1e-6, 1); // we subtract 1e-6 to guard for roundoff errors + if(trace->fraction >= 1) // trace would NOT hit if not expanded! + { + trace->fraction = 1; + trace->realfraction = 1; + VectorCopy(end, trace->endpos); + memset(&trace->plane, 0, sizeof(trace->plane)); + trace->ent = NULL; + trace->hitsupercontentsmask = 0; + trace->hitsupercontents = 0; + trace->hitq3surfaceflags = 0; + trace->hittexture = NULL; + } +}