X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;ds=sidebyside;f=collision.c;h=1e8895606a939c9f79dbbba3028f4ce4c83d3e01;hb=6c4d997a497cb5afde74b4bf16f6a9ade5aca37e;hp=20fc83997119c3973d3561eafe3d08651e93806d;hpb=80b09064d8227075b6e9c4dfe4b007c6676082f5;p=xonotic%2Fdarkplaces.git

diff --git a/collision.c b/collision.c
index 20fc8399..1e889560 100644
--- a/collision.c
+++ b/collision.c
@@ -614,13 +614,15 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush
 		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)
 				{
@@ -636,7 +638,7 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush
 						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;
@@ -652,6 +654,8 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush
 			{
 				// 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)
 				{
@@ -668,31 +672,33 @@ void Collision_TraceBrushBrushFloat(trace_t *trace, const colbrushf_t *thisbrush
 	// 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;
+		}
 	}
 }
 
@@ -731,13 +737,15 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const
 		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)
 				{
@@ -753,7 +761,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const
 						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;
@@ -785,31 +793,33 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const
 	// 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;
+		}
 	}
 }
 
@@ -836,11 +846,12 @@ static colbrushf_t polyf_brush;
 
 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;
 	}
 }
 
@@ -857,7 +868,7 @@ void Collision_TraceBrushPolygonFloat(trace_t *trace, const colbrushf_t *thisbru
 	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);
@@ -866,7 +877,6 @@ void Collision_TraceBrushPolygonFloat(trace_t *trace, const colbrushf_t *thisbru
 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;
@@ -879,18 +889,12 @@ void Collision_TraceBrushTriangleMeshFloat(trace_t *trace, const colbrushf_t *th
 	}
 	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);
@@ -909,7 +913,7 @@ void Collision_TraceLinePolygonFloat(trace_t *trace, const vec3_t linestart, con
 	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);
@@ -938,19 +942,12 @@ void Collision_TraceLineTriangleMeshFloat(trace_t *trace, const vec3_t linestart
 	}
 	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);
@@ -991,8 +988,8 @@ void Collision_TraceBrushPolygonTransformFloat(trace_t *trace, const colbrushf_t
 		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);
 
@@ -1455,3 +1452,79 @@ void Collision_BoundingBoxOfBrushTraceSegment(const colbrushf_t *start, const co
 	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;
+}