if (d1 > d2)
{
// moving into brush
- if (d2 > 0)
+ if (d2 >= collision_enternudge.value)
return;
if (d1 > 0)
{
// enter
imove = 1 / (d1 - d2);
f = (d1 - collision_enternudge.value) * imove;
+ if (f < 0)
+ f = 0;
// check if this will reduce the collision time range
if (enterfrac < f)
{
return;
// calculate the nudged fraction and impact normal we'll
// need if we accept this collision later
- enterfrac2 = f - collision_impactnudge.value * imove;
+ enterfrac2 = (d1 - collision_impactnudge.value) * imove;
VectorLerp(startplane->normal, enterfrac, endplane->normal, newimpactnormal);
hitq3surfaceflags = startplane->q3surfaceflags;
hittexture = startplane->texture;
{
// leave
f = (d1 + collision_leavenudge.value) / (d1 - d2);
+ if (f > 1)
+ f = 1;
// check if this will reduce the collision time range
if (leavefrac > f)
{
// at this point we know the trace overlaps the brush because it was not
// rejected at any point in the loop above
- // see if this brush can block the trace or not according to contents
- if (trace->hitsupercontentsmask & thatbrush_start->supercontents)
+ // see if the trace started outside the brush or not
+ if (enterfrac > -1)
{
- if (enterfrac == -1)
+ // started outside, and overlaps, therefore there is a collision here
+ // store out the impact information
+ if (trace->hitsupercontentsmask & thatbrush_start->supercontents)
{
- trace->startsupercontents |= thatbrush_start->supercontents;
- trace->startsolid = true;
- if (leavefrac < 1)
- trace->allsolid = true;
+ trace->hitsupercontents = thatbrush_start->supercontents;
+ trace->hitq3surfaceflags = hitq3surfaceflags;
+ trace->hittexture = hittexture;
+ trace->realfraction = bound(0, enterfrac, 1);
+ trace->fraction = bound(0, enterfrac2, 1);
+ if (collision_prefernudgedfraction.integer)
+ trace->realfraction = trace->fraction;
+ VectorCopy(newimpactnormal, trace->plane.normal);
}
- // store out the impact information
- trace->hitsupercontents = thatbrush_start->supercontents;
- trace->hitq3surfaceflags = hitq3surfaceflags;
- trace->hittexture = hittexture;
- trace->realfraction = bound(0, enterfrac, 1);
- trace->fraction = bound(0, enterfrac2, 1);
- if (collision_prefernudgedfraction.integer)
- trace->realfraction = trace->fraction;
- VectorCopy(newimpactnormal, trace->plane.normal);
}
else
{
- // this brush can not block the trace, but it can update start contents
- if (enterfrac == -1)
- trace->startsupercontents |= thatbrush_start->supercontents;
+ // started inside, update startsolid and friends
+ trace->startsupercontents |= thatbrush_start->supercontents;
+ if (trace->hitsupercontentsmask & thatbrush_start->supercontents)
+ {
+ trace->startsolid = true;
+ if (leavefrac < 1)
+ trace->allsolid = true;
+ }
}
}
if (d1 > d2)
{
// moving into brush
- if (d2 > 0)
+ if (d2 >= collision_enternudge.value)
return;
if (d1 > 0)
{
// enter
imove = 1 / (d1 - d2);
f = (d1 - collision_enternudge.value) * imove;
+ if (f < 0)
+ f = 0;
// check if this will reduce the collision time range
if (enterfrac < f)
{
return;
// calculate the nudged fraction and impact normal we'll
// need if we accept this collision later
- enterfrac2 = f - collision_impactnudge.value * imove;
+ enterfrac2 = (d1 - collision_impactnudge.value) * imove;
VectorLerp(startplane->normal, enterfrac, endplane->normal, newimpactnormal);
hitq3surfaceflags = startplane->q3surfaceflags;
hittexture = startplane->texture;
// at this point we know the trace overlaps the brush because it was not
// rejected at any point in the loop above
- // see if this brush can block the trace or not according to contents
- if (trace->hitsupercontentsmask & thatbrush_start->supercontents)
+ // see if the trace started outside the brush or not
+ if (enterfrac > -1)
+ {
+ // started outside, and overlaps, therefore there is a collision here
+ // store out the impact information
+ if (trace->hitsupercontentsmask & thatbrush_start->supercontents)
+ {
+ trace->hitsupercontents = thatbrush_start->supercontents;
+ trace->hitq3surfaceflags = hitq3surfaceflags;
+ trace->hittexture = hittexture;
+ trace->realfraction = bound(0, enterfrac, 1);
+ trace->fraction = bound(0, enterfrac2, 1);
+ if (collision_prefernudgedfraction.integer)
+ trace->realfraction = trace->fraction;
+ VectorCopy(newimpactnormal, trace->plane.normal);
+ }
+ }
+ else
{
- if (enterfrac == -1)
+ // started inside, update startsolid and friends
+ trace->startsupercontents |= thatbrush_start->supercontents;
+ if (trace->hitsupercontentsmask & thatbrush_start->supercontents)
{
- trace->startsupercontents |= thatbrush_start->supercontents;
trace->startsolid = true;
if (leavefrac < 1)
trace->allsolid = true;
}
- // store out the impact information
- trace->hitsupercontents = thatbrush_start->supercontents;
- trace->hitq3surfaceflags = hitq3surfaceflags;
- trace->hittexture = hittexture;
- trace->realfraction = bound(0, enterfrac, 1);
- trace->fraction = bound(0, enterfrac2, 1);
- if (collision_prefernudgedfraction.integer)
- trace->realfraction = trace->fraction;
- VectorCopy(newimpactnormal, trace->plane.normal);
- }
- else
- {
- // this brush can not block the trace, but it can update start contents
- if (enterfrac == -1)
- trace->startsupercontents |= thatbrush_start->supercontents;
}
}
-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)
void Collision_SnapCopyPoints(int numpoints, const colpointf_t *in, colpointf_t *out, float fractionprecision, float invfractionprecision)
{
- while (numpoints--)
+ int i;
+ for (i = 0;i < numpoints;i++)
{
- out->v[0] = floor(in->v[0] * fractionprecision + 0.5f) * invfractionprecision;
- out->v[1] = floor(in->v[1] * fractionprecision + 0.5f) * invfractionprecision;
- out->v[2] = floor(in->v[2] * fractionprecision + 0.5f) * invfractionprecision;
+ out[i].v[0] = floor(in[i].v[0] * fractionprecision + 0.5f) * invfractionprecision;
+ out[i].v[1] = floor(in[i].v[1] * fractionprecision + 0.5f) * invfractionprecision;
+ out[i].v[2] = floor(in[i].v[2] * fractionprecision + 0.5f) * invfractionprecision;
}
}
polyf_brush.planes = polyf_planes;
polyf_brush.supercontents = supercontents;
polyf_brush.points = polyf_points;
- Collision_SnapCopyPoints(numpoints, (colpointf_t *)points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP);
+ Collision_SnapCopyPoints(polyf_brush.numpoints, (colpointf_t *)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);
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)
{
int i;
- float facemins[3], facemaxs[3];
polyf_brush.numpoints = 3;
polyf_brush.numplanes = 5;
polyf_brush.points = polyf_points;
}
for (i = 0;i < numtriangles;i++, element3i += 3)
{
- 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(3, polyf_points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP);
- facemins[0] = min(polyf_points[0].v[0], min(polyf_points[1].v[0], polyf_points[2].v[0]));
- facemins[1] = min(polyf_points[0].v[1], min(polyf_points[1].v[1], polyf_points[2].v[1]));
- facemins[2] = min(polyf_points[0].v[2], min(polyf_points[1].v[2], polyf_points[2].v[2]));
- facemaxs[0] = max(polyf_points[0].v[0], max(polyf_points[1].v[0], polyf_points[2].v[0]));
- facemaxs[1] = max(polyf_points[0].v[1], max(polyf_points[1].v[1], polyf_points[2].v[1]));
- facemaxs[2] = max(polyf_points[0].v[2], max(polyf_points[1].v[2], polyf_points[2].v[2]));
- if (BoxesOverlap(segmentmins, segmentmaxs, facemins, facemaxs))
+ 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);
polyf_brush.numplanes = numpoints + 2;
//polyf_brush.points = (colpointf_t *)points;
polyf_brush.points = polyf_points;
- Collision_SnapCopyPoints(numpoints, (colpointf_t *)points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP);
+ Collision_SnapCopyPoints(polyf_brush.numpoints, (colpointf_t *)points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP);
polyf_brush.planes = polyf_planes;
polyf_brush.supercontents = supercontents;
Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush);
}
for (i = 0;i < numtriangles;i++, element3i += 3)
{
- float facemins[3], facemaxs[3];
- 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(numpoints, polyf_points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP);
- facemins[0] = min(polyf_points[0].v[0], min(polyf_points[1].v[0], polyf_points[2].v[0]));
- facemins[1] = min(polyf_points[0].v[1], min(polyf_points[1].v[1], polyf_points[2].v[1]));
- facemins[2] = min(polyf_points[0].v[2], min(polyf_points[1].v[2], polyf_points[2].v[2]));
- facemaxs[0] = max(polyf_points[0].v[0], max(polyf_points[1].v[0], polyf_points[2].v[0]));
- facemaxs[1] = max(polyf_points[0].v[1], max(polyf_points[1].v[1], polyf_points[2].v[1]));
- facemaxs[2] = max(polyf_points[0].v[2], max(polyf_points[1].v[2], polyf_points[2].v[2]));
- if (BoxesOverlap(segmentmins, segmentmaxs, facemins, facemaxs))
+ if (TriangleOverlapsBox(vertex3f + element3i[0]*3, vertex3 + [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_TraceLineBrushFloat(trace, linestart, lineend, &polyf_brush, &polyf_brush);
polyf_brushstart.planes[i].q3surfaceflags = q3surfaceflags;
polyf_brushstart.planes[i].texture = texture;
}
- Collision_SnapCopyPoints(numpoints, polyf_pointsstart, polyf_pointsstart, COLLISION_SNAPSCALE, COLLISION_SNAP);
- Collision_SnapCopyPoints(numpoints, polyf_pointsend, polyf_pointsend, COLLISION_SNAPSCALE, COLLISION_SNAP);
+ Collision_SnapCopyPoints(polyf_brushstart.numpoints, polyf_pointsstart, polyf_pointsstart, COLLISION_SNAPSCALE, COLLISION_SNAP);
+ Collision_SnapCopyPoints(polyf_brushend.numpoints, polyf_pointsend, polyf_pointsend, COLLISION_SNAPSCALE, COLLISION_SNAP);
Collision_CalcPlanesForPolygonBrushFloat(&polyf_brushstart);
Collision_CalcPlanesForPolygonBrushFloat(&polyf_brushend);
#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];
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)
maxs[2] += 1;
}
+//===========================================
+
+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)
+{
+ float tempnormal[3], starttransformed[3], endtransformed[3];
+
+ memset(trace, 0, sizeof(*trace));
+ trace->fraction = trace->realfraction = 1;
+ VectorCopy(end, trace->endpos);
+
+ Matrix4x4_Transform(inversematrix, start, starttransformed);
+ Matrix4x4_Transform(inversematrix, end, endtransformed);
+#if COLLISIONPARANOID >= 3
+ Con_Printf("trans(%f %f %f -> %f %f %f, %f %f %f -> %f %f %f)", start[0], start[1], start[2], starttransformed[0], starttransformed[1], starttransformed[2], end[0], end[1], end[2], endtransformed[0], endtransformed[1], endtransformed[2]);
+#endif
+
+ if (model && model->TraceBox)
+ model->TraceBox(model, bound(0, frame, (model->numframes - 1)), trace, starttransformed, mins, maxs, endtransformed, hitsupercontentsmask);
+ else
+ Collision_ClipTrace_Box(trace, bodymins, bodymaxs, starttransformed, mins, maxs, endtransformed, hitsupercontentsmask, bodysupercontents, 0, NULL);
+ 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
+ }
+}
+
+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)
+{
+ memset(trace, 0, sizeof(*trace));
+ trace->fraction = trace->realfraction = 1;
+ if (model && model->TraceBox)
+ model->TraceBox(model, 0, trace, start, mins, maxs, end, hitsupercontents);
+ trace->fraction = bound(0, trace->fraction, 1);
+ trace->realfraction = bound(0, trace->realfraction, 1);
+ VectorLerp(start, trace->fraction, end, trace->endpos);
+}
+
+void Collision_CombineTraces(trace_t *cliptrace, const trace_t *trace, void *touch, qboolean isbmodel)
+{
+ // take the 'best' answers from the new trace and combine with existing data
+ if (trace->allsolid)
+ cliptrace->allsolid = true;
+ if (trace->startsolid)
+ {
+ if (isbmodel)
+ cliptrace->bmodelstartsolid = true;
+ cliptrace->startsolid = true;
+ if (cliptrace->realfraction == 1)
+ cliptrace->ent = touch;
+ }
+ // don't set this except on the world, because it can easily confuse
+ // monsters underwater if there's a bmodel involved in the trace
+ // (inopen && inwater is how they check water visibility)
+ //if (trace->inopen)
+ // cliptrace->inopen = true;
+ if (trace->inwater)
+ cliptrace->inwater = true;
+ if (trace->realfraction < cliptrace->realfraction)
+ {
+ cliptrace->fraction = trace->fraction;
+ cliptrace->realfraction = trace->realfraction;
+ VectorCopy(trace->endpos, cliptrace->endpos);
+ cliptrace->plane = trace->plane;
+ cliptrace->ent = touch;
+ cliptrace->hitsupercontents = trace->hitsupercontents;
+ cliptrace->hitq3surfaceflags = trace->hitq3surfaceflags;
+ cliptrace->hittexture = trace->hittexture;
+ }
+ cliptrace->startsupercontents |= trace->startsupercontents;
+}
projects / xonotic / darkplaces.git / blobdiff