r_nearclip cvar

[xonotic/darkplaces.git] / collision.c

diff --git a/collision.c b/collision.c
index 6fc28f0aa9106062e96f17e780e31ff746ab7dc1..e132341bd356ec9ac345ac4f572e31f4156dd502 100644 (file)
--- a/collision.c
+++ b/collision.c
@@ -5,11 +5,11 @@
 #define COLLISION_SNAPSCALE (8.0f)
 #define COLLISION_SNAP (1.0f / COLLISION_SNAPSCALE)
 
-cvar_t collision_impactnudge = {0, "collision_impactnudge", "0.03125"};
-cvar_t collision_startnudge = {0, "collision_startnudge", "0"};
-cvar_t collision_endnudge = {0, "collision_endnudge", "0"};
-cvar_t collision_enternudge = {0, "collision_enternudge", "0"};
-cvar_t collision_leavenudge = {0, "collision_leavenudge", "0"};
+cvar_t collision_impactnudge = {0, "collision_impactnudge", "0.03125", "how much to back off from the impact"};
+cvar_t collision_startnudge = {0, "collision_startnudge", "0", "how much to bias collision trace start"};
+cvar_t collision_endnudge = {0, "collision_endnudge", "0", "how much to bias collision trace end"};
+cvar_t collision_enternudge = {0, "collision_enternudge", "0", "how much to bias collision entry fraction"};
+cvar_t collision_leavenudge = {0, "collision_leavenudge", "0", "how much to bias collision exit fraction"};
 
 void Collision_Init (void)
 {
@@ -183,7 +183,7 @@ colbrushf_t *Collision_NewBrushFromPlanes(mempool_t *mempool, int numoriginalpla
                        {
                                // we want to keep the inside of the brush plane so we flip
                                // the cutting plane
-                               PolygonD_Divide(pnumpoints, p[w], -originalplanes[k].normal[0], -originalplanes[k].normal[1], -originalplanes[k].normal[2], -originalplanes[k].dist, 1.0/32.0, pmaxpoints, p[!w], &pnumpoints, 0, NULL, NULL);
+                               PolygonD_Divide(pnumpoints, p[w], -originalplanes[k].normal[0], -originalplanes[k].normal[1], -originalplanes[k].normal[2], -originalplanes[k].dist, 1.0/32.0, pmaxpoints, p[!w], &pnumpoints, 0, NULL, NULL, NULL);
                                w = !w;
                        }
                }
@@ -322,14 +322,14 @@ colbrushf_t *Collision_NewBrushFromPlanes(mempool_t *mempool, int numoriginalpla
 colbrushf_t *Collision_AllocBrushFloat(mempool_t *mempool, int numpoints, int numplanes, int numtriangles, int supercontents)
 {
        colbrushf_t *brush;
-       brush = Mem_Alloc(mempool, sizeof(colbrushf_t) + sizeof(colpointf_t) * numpoints + sizeof(colplanef_t) * numplanes + sizeof(int[3]) * numtriangles);
+       brush = (colbrushf_t *)Mem_Alloc(mempool, sizeof(colbrushf_t) + sizeof(colpointf_t) * numpoints + sizeof(colplanef_t) * numplanes + sizeof(int[3]) * numtriangles);
        brush->supercontents = supercontents;
        brush->numplanes = numplanes;
        brush->numpoints = numpoints;
        brush->numtriangles = numtriangles;
-       brush->planes = (void *)(brush + 1);
-       brush->points = (void *)(brush->planes + brush->numplanes);
-       brush->elements = (void *)(brush->points + brush->numpoints);
+       brush->planes = (colplanef_t *)(brush + 1);
+       brush->points = (colpointf_t *)(brush->planes + brush->numplanes);
+       brush->elements = (int *)(brush->points + brush->numpoints);
        return brush;
 }
 
@@ -505,13 +505,13 @@ void Collision_CalcPlanesForPolygonBrushFloat(colbrushf_t *brush)
 colbrushf_t *Collision_AllocBrushFromPermanentPolygonFloat(mempool_t *mempool, int numpoints, float *points, int supercontents)
 {
        colbrushf_t *brush;
-       brush = Mem_Alloc(mempool, sizeof(colbrushf_t) + sizeof(colplanef_t) * (numpoints + 2));
+       brush = (colbrushf_t *)Mem_Alloc(mempool, sizeof(colbrushf_t) + sizeof(colplanef_t) * (numpoints + 2));
        brush->supercontents = supercontents;
        brush->numpoints = numpoints;
        brush->numplanes = numpoints + 2;
-       brush->planes = (void *)(brush + 1);
+       brush->planes = (colplanef_t *)(brush + 1);
        brush->points = (colpointf_t *)points;
-       Sys_Error("Collision_AllocBrushFromPermanentPolygonFloat: FIXME: this code needs to be updated to generate a mesh...\n");
+       Sys_Error("Collision_AllocBrushFromPermanentPolygonFloat: FIXME: this code needs to be updated to generate a mesh...");
        return brush;
 }
 
@@ -743,7 +743,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const
        // penetrating line segment is normally zero length if this brush was
        // generated from a polygon (infinitely thin), and could even be slightly
        // positive or negative due to rounding errors in that case.
-       if (brushsolid && enterfrac > -1 && enterfrac < trace->realfraction && enterfrac - (1.0f / 1024.0f) <= leavefrac)
+       if (brushsolid && enterfrac > -1 && enterfrac < trace->realfraction && enterfrac <= leavefrac)
        {
 #if 0
                // broken
@@ -840,12 +840,12 @@ void Collision_TraceBrushTriangleMeshFloat(trace_t *trace, const colbrushf_t *th
                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])) - 1;
-               facemins[1] = min(polyf_points[0].v[1], min(polyf_points[1].v[1], polyf_points[2].v[1])) - 1;
-               facemins[2] = min(polyf_points[0].v[2], min(polyf_points[1].v[2], polyf_points[2].v[2])) - 1;
-               facemaxs[0] = max(polyf_points[0].v[0], max(polyf_points[1].v[0], polyf_points[2].v[0])) + 1;
-               facemaxs[1] = max(polyf_points[0].v[1], max(polyf_points[1].v[1], polyf_points[2].v[1])) + 1;
-               facemaxs[2] = max(polyf_points[0].v[2], max(polyf_points[1].v[2], polyf_points[2].v[2])) + 1;
+               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))
                {
                        Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush);
@@ -894,12 +894,12 @@ void Collision_TraceLineTriangleMeshFloat(trace_t *trace, const vec3_t linestart
                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])) - 1;
-               facemins[1] = min(polyf_points[0].v[1], min(polyf_points[1].v[1], polyf_points[2].v[1])) - 1;
-               facemins[2] = min(polyf_points[0].v[2], min(polyf_points[1].v[2], polyf_points[2].v[2])) - 1;
-               facemaxs[0] = max(polyf_points[0].v[0], max(polyf_points[1].v[0], polyf_points[2].v[0])) + 1;
-               facemaxs[1] = max(polyf_points[0].v[1], max(polyf_points[1].v[1], polyf_points[2].v[1])) + 1;
-               facemaxs[2] = max(polyf_points[0].v[2], max(polyf_points[1].v[2], polyf_points[2].v[2])) + 1;
+               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))
                {
                        Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush);
@@ -1035,7 +1035,6 @@ colbrushf_t *Collision_BrushForBox(const matrix4x4_t *matrix, const vec3_t mins,
 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)
 {
        colbrushf_t *boxbrush, *thisbrush_start, *thisbrush_end;
-       matrix4x4_t identitymatrix;
        vec3_t startmins, startmaxs, endmins, endmaxs;
 
        // create brushes for the collision
@@ -1043,7 +1042,6 @@ void Collision_ClipTrace_BrushBox(trace_t *trace, const vec3_t cmins, const vec3
        VectorAdd(start, maxs, startmaxs);
        VectorAdd(end, mins, endmins);
        VectorAdd(end, maxs, endmaxs);
-       Matrix4x4_CreateIdentity(&identitymatrix);
        boxbrush = Collision_BrushForBox(&identitymatrix, cmins, cmaxs);
        thisbrush_start = Collision_BrushForBox(&identitymatrix, startmins, startmaxs);
        thisbrush_end = Collision_BrushForBox(&identitymatrix, endmins, endmaxs);
@@ -1339,9 +1337,9 @@ colbsp_t;
 colbsp_t *Collision_CreateCollisionBSP(mempool_t *mempool)
 {
        colbsp_t *bsp;
-       bsp = Mem_Alloc(mempool, sizeof(colbsp_t));
+       bsp = (colbsp_t *)Mem_Alloc(mempool, sizeof(colbsp_t));
        bsp->mempool = mempool;
-       bsp->nodes = Mem_Alloc(bsp->mempool, sizeof(colbspnode_t));
+       bsp->nodes = (colbspnode_t *)Mem_Alloc(bsp->mempool, sizeof(colbspnode_t));
        return bsp;
 }