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"};
cvar_t collision_prefernudgedfraction = {0, "collision_prefernudgedfraction", "1", "whether to sort collision events by nudged fraction (1) or real fraction (0)"};
+#ifdef COLLISION_STUPID_TRACE_ENDPOS_IN_SOLID_WORKAROUND
+cvar_t collision_endposnudge = {0, "collision_endposnudge", "0", "workaround to fix trace_endpos sometimes being returned where it would be inside solid by making that collision hit (recommended: values like 1)"};
+#endif
void Collision_Init (void)
{
Cvar_RegisterVariable(&collision_enternudge);
Cvar_RegisterVariable(&collision_leavenudge);
Cvar_RegisterVariable(&collision_prefernudgedfraction);
+#ifdef COLLISION_STUPID_TRACE_ENDPOS_IN_SOLID_WORKAROUND
+ Cvar_RegisterVariable(&collision_endposnudge);
+#endif
}
VectorSubtract(brush->points[i].v, brush->points[j].v, brush->edgedirs[j].v);
}
-colbrushf_t *Collision_NewBrushFromPlanes(mempool_t *mempool, int numoriginalplanes, const colplanef_t *originalplanes, int supercontents, int q3surfaceflags, texture_t *texture, int hasaabbplanes)
+colbrushf_t *Collision_NewBrushFromPlanes(mempool_t *mempool, int numoriginalplanes, const colplanef_t *originalplanes, int supercontents, int q3surfaceflags, const texture_t *texture, int hasaabbplanes)
{
// TODO: planesbuf could be replaced by a remapping table
int j, k, l, m, w, xyzflags;
brush->planes[3].dist = DotProduct(brush->points[0].v, brush->planes[3].normal);
brush->planes[4].dist = DotProduct(brush->points[1].v, brush->planes[4].normal);
- if (developer.integer >= 100)
+ if (developer_extra.integer)
{
// validation code
#if 0
VectorNormalize(normal);
VectorSubtract(normal, brush->planes[0].normal, temp);
if (VectorLength(temp) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: TriangleNormal gave wrong answer (%f %f %f != correct answer %f %f %f)\n", brush->planes->normal[0], brush->planes->normal[1], brush->planes->normal[2], normal[0], normal[1], normal[2]);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: TriangleNormal gave wrong answer (%f %f %f != correct answer %f %f %f)\n", brush->planes->normal[0], brush->planes->normal[1], brush->planes->normal[2], normal[0], normal[1], normal[2]);
if (fabs(DotProduct(brush->planes[1].normal, brush->planes[0].normal) - -1.0f) > 0.01f || fabs(brush->planes[1].dist - -brush->planes[0].dist) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: plane 1 (%f %f %f %f) is not opposite plane 0 (%f %f %f %f)\n", brush->planes[1].normal[0], brush->planes[1].normal[1], brush->planes[1].normal[2], brush->planes[1].dist, brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[0].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: plane 1 (%f %f %f %f) is not opposite plane 0 (%f %f %f %f)\n", brush->planes[1].normal[0], brush->planes[1].normal[1], brush->planes[1].normal[2], brush->planes[1].dist, brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[0].dist);
#if 0
if (fabs(DotProduct(brush->planes[2].normal, brush->planes[0].normal)) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: plane 2 (%f %f %f %f) is not perpendicular to plane 0 (%f %f %f %f)\n", brush->planes[2].normal[0], brush->planes[2].normal[1], brush->planes[2].normal[2], brush->planes[2].dist, brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[2].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: plane 2 (%f %f %f %f) is not perpendicular to plane 0 (%f %f %f %f)\n", brush->planes[2].normal[0], brush->planes[2].normal[1], brush->planes[2].normal[2], brush->planes[2].dist, brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[2].dist);
if (fabs(DotProduct(brush->planes[3].normal, brush->planes[0].normal)) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: plane 3 (%f %f %f %f) is not perpendicular to plane 0 (%f %f %f %f)\n", brush->planes[3].normal[0], brush->planes[3].normal[1], brush->planes[3].normal[2], brush->planes[3].dist, brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[3].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: plane 3 (%f %f %f %f) is not perpendicular to plane 0 (%f %f %f %f)\n", brush->planes[3].normal[0], brush->planes[3].normal[1], brush->planes[3].normal[2], brush->planes[3].dist, brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[3].dist);
if (fabs(DotProduct(brush->planes[4].normal, brush->planes[0].normal)) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: plane 4 (%f %f %f %f) is not perpendicular to plane 0 (%f %f %f %f)\n", brush->planes[4].normal[0], brush->planes[4].normal[1], brush->planes[4].normal[2], brush->planes[4].dist, brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[4].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: plane 4 (%f %f %f %f) is not perpendicular to plane 0 (%f %f %f %f)\n", brush->planes[4].normal[0], brush->planes[4].normal[1], brush->planes[4].normal[2], brush->planes[4].dist, brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[4].dist);
if (fabs(DotProduct(brush->planes[2].normal, edge0)) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: plane 2 (%f %f %f %f) is not perpendicular to edge 0 (%f %f %f to %f %f %f)\n", brush->planes[2].normal[0], brush->planes[2].normal[1], brush->planes[2].normal[2], brush->planes[2].dist, brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2]);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: plane 2 (%f %f %f %f) is not perpendicular to edge 0 (%f %f %f to %f %f %f)\n", brush->planes[2].normal[0], brush->planes[2].normal[1], brush->planes[2].normal[2], brush->planes[2].dist, brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2]);
if (fabs(DotProduct(brush->planes[3].normal, edge1)) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: plane 3 (%f %f %f %f) is not perpendicular to edge 1 (%f %f %f to %f %f %f)\n", brush->planes[3].normal[0], brush->planes[3].normal[1], brush->planes[3].normal[2], brush->planes[3].dist, brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2]);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: plane 3 (%f %f %f %f) is not perpendicular to edge 1 (%f %f %f to %f %f %f)\n", brush->planes[3].normal[0], brush->planes[3].normal[1], brush->planes[3].normal[2], brush->planes[3].dist, brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2]);
if (fabs(DotProduct(brush->planes[4].normal, edge2)) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: plane 4 (%f %f %f %f) is not perpendicular to edge 2 (%f %f %f to %f %f %f)\n", brush->planes[4].normal[0], brush->planes[4].normal[1], brush->planes[4].normal[2], brush->planes[4].dist, brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2]);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: plane 4 (%f %f %f %f) is not perpendicular to edge 2 (%f %f %f to %f %f %f)\n", brush->planes[4].normal[0], brush->planes[4].normal[1], brush->planes[4].normal[2], brush->planes[4].dist, brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2]);
#endif
#endif
if (fabs(DotProduct(brush->points[0].v, brush->planes[0].normal) - brush->planes[0].dist) > 0.01f || fabs(DotProduct(brush->points[1].v, brush->planes[0].normal) - brush->planes[0].dist) > 0.01f || fabs(DotProduct(brush->points[2].v, brush->planes[0].normal) - brush->planes[0].dist) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: edges (%f %f %f to %f %f %f to %f %f %f) off front plane 0 (%f %f %f %f)\n", brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[0].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: edges (%f %f %f to %f %f %f to %f %f %f) off front plane 0 (%f %f %f %f)\n", brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->planes[0].normal[0], brush->planes[0].normal[1], brush->planes[0].normal[2], brush->planes[0].dist);
if (fabs(DotProduct(brush->points[0].v, brush->planes[1].normal) - brush->planes[1].dist) > 0.01f || fabs(DotProduct(brush->points[1].v, brush->planes[1].normal) - brush->planes[1].dist) > 0.01f || fabs(DotProduct(brush->points[2].v, brush->planes[1].normal) - brush->planes[1].dist) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: edges (%f %f %f to %f %f %f to %f %f %f) off back plane 1 (%f %f %f %f)\n", brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->planes[1].normal[0], brush->planes[1].normal[1], brush->planes[1].normal[2], brush->planes[1].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: edges (%f %f %f to %f %f %f to %f %f %f) off back plane 1 (%f %f %f %f)\n", brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->planes[1].normal[0], brush->planes[1].normal[1], brush->planes[1].normal[2], brush->planes[1].dist);
if (fabs(DotProduct(brush->points[2].v, brush->planes[2].normal) - brush->planes[2].dist) > 0.01f || fabs(DotProduct(brush->points[0].v, brush->planes[2].normal) - brush->planes[2].dist) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: edge 0 (%f %f %f to %f %f %f) off front plane 2 (%f %f %f %f)\n", brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->planes[2].normal[0], brush->planes[2].normal[1], brush->planes[2].normal[2], brush->planes[2].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: edge 0 (%f %f %f to %f %f %f) off front plane 2 (%f %f %f %f)\n", brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->planes[2].normal[0], brush->planes[2].normal[1], brush->planes[2].normal[2], brush->planes[2].dist);
if (fabs(DotProduct(brush->points[0].v, brush->planes[3].normal) - brush->planes[3].dist) > 0.01f || fabs(DotProduct(brush->points[1].v, brush->planes[3].normal) - brush->planes[3].dist) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: edge 0 (%f %f %f to %f %f %f) off front plane 2 (%f %f %f %f)\n", brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->planes[3].normal[0], brush->planes[3].normal[1], brush->planes[3].normal[2], brush->planes[3].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: edge 0 (%f %f %f to %f %f %f) off front plane 2 (%f %f %f %f)\n", brush->points[0].v[0], brush->points[0].v[1], brush->points[0].v[2], brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->planes[3].normal[0], brush->planes[3].normal[1], brush->planes[3].normal[2], brush->planes[3].dist);
if (fabs(DotProduct(brush->points[1].v, brush->planes[4].normal) - brush->planes[4].dist) > 0.01f || fabs(DotProduct(brush->points[2].v, brush->planes[4].normal) - brush->planes[4].dist) > 0.01f)
- Con_Printf("Collision_CalcPlanesForPolygonBrushFloat: edge 0 (%f %f %f to %f %f %f) off front plane 2 (%f %f %f %f)\n", brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->planes[4].normal[0], brush->planes[4].normal[1], brush->planes[4].normal[2], brush->planes[4].dist);
+ Con_DPrintf("Collision_CalcPlanesForPolygonBrushFloat: edge 0 (%f %f %f to %f %f %f) off front plane 2 (%f %f %f %f)\n", brush->points[1].v[0], brush->points[1].v[1], brush->points[1].v[2], brush->points[2].v[0], brush->points[2].v[1], brush->points[2].v[2], brush->planes[4].normal[0], brush->planes[4].normal[1], brush->planes[4].normal[2], brush->planes[4].dist);
}
}
}
}
}
- if (developer.integer >= 100)
+ if (developer_extra.integer)
{
// validity check - will be disabled later
Collision_ValidateBrush(brush);
int j;
for (j = 0, p = brush->points;j < brush->numpoints;j++, p++)
if (DotProduct(p->v, brush->planes[i].normal) > brush->planes[i].dist + COLLISION_PLANE_DIST_EPSILON)
- Con_Printf("Error in brush plane generation, plane %i\n", i);
+ Con_DPrintf("Error in brush plane generation, plane %i\n", i);
}
}
}
-colbrushf_t *Collision_AllocBrushFromPermanentPolygonFloat(mempool_t *mempool, int numpoints, float *points, int supercontents, int q3surfaceflags, texture_t *texture)
+colbrushf_t *Collision_AllocBrushFromPermanentPolygonFloat(mempool_t *mempool, int numpoints, float *points, int supercontents, int q3surfaceflags, const texture_t *texture)
{
colbrushf_t *brush;
brush = (colbrushf_t *)Mem_Alloc(mempool, sizeof(colbrushf_t) + sizeof(colplanef_t) * (numpoints + 2) + sizeof(colpointf_t) * numpoints);
vec4_t startplane;
vec4_t endplane;
vec4_t newimpactplane;
- texture_t *hittexture = NULL;
+ const texture_t *hittexture = NULL;
vec_t startdepth = 1;
vec3_t startdepthnormal;
//Con_Printf("%c%i: startdist = %f, enddist = %f, startdist / (startdist - enddist) = %f\n", nplane2 != nplane ? 'b' : 'a', nplane2, startdist, enddist, startdist / (startdist - enddist));
// aside from collisions, this is also used for error correction
- if (startdist < 0 && (startdepth < startdist || startdepth == 1))
+ if (startdist < collision_impactnudge.value && nplane < numplanes1 && (startdepth < startdist || startdepth == 1))
{
startdepth = startdist;
VectorCopy(startplane, startdepthnormal);
}
+ if (startdist >= -collision_impactnudge.value && enddist >= startdist)
+ return;
+ if (startdist <= 0 && enddist <= 0)
+ continue;
if (startdist > enddist)
{
// moving into brush
vec4_t startplane;
vec4_t endplane;
vec4_t newimpactplane;
- texture_t *hittexture = NULL;
+ const texture_t *hittexture = NULL;
vec_t startdepth = 1;
vec3_t startdepthnormal;
//Con_Printf("%c%i: startdist = %f, enddist = %f, startdist / (startdist - enddist) = %f\n", nplane2 != nplane ? 'b' : 'a', nplane2, startdist, enddist, startdist / (startdist - enddist));
// aside from collisions, this is also used for error correction
- if (startdist < 0 && (startdepth < startdist || startdepth == 1))
+ if (startdist < collision_impactnudge.value && (startdepth < startdist || startdepth == 1))
{
startdepth = startdist;
VectorCopy(startplane, startdepthnormal);
}
+ if (startdist >= -collision_impactnudge.value && enddist >= startdist)
+ return;
+ if (startdist <= 0 && enddist <= 0)
+ continue;
if (startdist > enddist)
{
// moving into brush
}
}
-static colpointf_t polyf_points[256];
-static colpointf_t polyf_edgedirs[256];
-static colplanef_t polyf_planes[256 + 2];
-static colbrushf_t polyf_brush;
-
void Collision_SnapCopyPoints(int numpoints, const colpointf_t *in, colpointf_t *out, float fractionprecision, float invfractionprecision)
{
int i;
}
}
-void Collision_TraceBrushPolygonFloat(trace_t *trace, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int numpoints, const float *points, int supercontents, int q3surfaceflags, texture_t *texture)
-{
- if (numpoints > 256)
- {
- Con_Print("Polygon with more than 256 points not supported yet (fixme!)\n");
- return;
- }
- memset(&polyf_brush, 0, sizeof(polyf_brush));
- polyf_brush.isaabb = false;
- polyf_brush.hasaabbplanes = false;
- polyf_brush.numpoints = numpoints;
- polyf_brush.numedgedirs = numpoints;
- polyf_brush.numplanes = numpoints + 2;
- //polyf_brush.points = (colpointf_t *)points;
- polyf_brush.planes = polyf_planes;
- polyf_brush.edgedirs = polyf_edgedirs;
- polyf_brush.supercontents = supercontents;
- polyf_brush.points = polyf_points;
- polyf_brush.q3surfaceflags = q3surfaceflags;
- polyf_brush.texture = texture;
- Collision_SnapCopyPoints(polyf_brush.numpoints, (colpointf_t *)points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP);
- Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush);
- Collision_CalcEdgeDirsForPolygonBrushFloat(&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 stride, float *bbox6f, 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, const texture_t *texture, const vec3_t segmentmins, const vec3_t segmentmaxs)
{
int i;
- memset(&polyf_brush, 0, sizeof(polyf_brush));
- polyf_brush.isaabb = false;
- polyf_brush.hasaabbplanes = false;
- polyf_brush.numpoints = 3;
- polyf_brush.numedgedirs = 3;
- polyf_brush.numplanes = 5;
- polyf_brush.points = polyf_points;
- polyf_brush.edgedirs = polyf_edgedirs;
- polyf_brush.planes = polyf_planes;
- polyf_brush.supercontents = supercontents;
- polyf_brush.q3surfaceflags = q3surfaceflags;
- polyf_brush.texture = texture;
- for (i = 0;i < polyf_brush.numplanes;i++)
+ colpointf_t points[3];
+ colpointf_t edgedirs[3];
+ colplanef_t planes[5];
+ colbrushf_t brush;
+ memset(&brush, 0, sizeof(brush));
+ brush.isaabb = false;
+ brush.hasaabbplanes = false;
+ brush.numpoints = 3;
+ brush.numedgedirs = 3;
+ brush.numplanes = 5;
+ brush.points = points;
+ brush.edgedirs = edgedirs;
+ brush.planes = planes;
+ brush.supercontents = supercontents;
+ brush.q3surfaceflags = q3surfaceflags;
+ brush.texture = texture;
+ for (i = 0;i < brush.numplanes;i++)
{
- polyf_brush.planes[i].q3surfaceflags = q3surfaceflags;
- polyf_brush.planes[i].texture = texture;
+ brush.planes[i].q3surfaceflags = q3surfaceflags;
+ brush.planes[i].texture = texture;
}
- if(stride)
+ if(stride > 0)
{
int k, cnt, tri;
cnt = (numtriangles + stride - 1) / stride;
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_CalcEdgeDirsForPolygonBrushFloat(&polyf_brush);
- Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush);
- //Collision_PrintBrushAsQHull(&polyf_brush, "polyf_brush");
- Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &polyf_brush, &polyf_brush);
+ VectorCopy(vertex3f + element3i[tri * 3 + 0] * 3, points[0].v);
+ VectorCopy(vertex3f + element3i[tri * 3 + 1] * 3, points[1].v);
+ VectorCopy(vertex3f + element3i[tri * 3 + 2] * 3, points[2].v);
+ Collision_SnapCopyPoints(brush.numpoints, points, points, COLLISION_SNAPSCALE, COLLISION_SNAP);
+ Collision_CalcEdgeDirsForPolygonBrushFloat(&brush);
+ Collision_CalcPlanesForPolygonBrushFloat(&brush);
+ //Collision_PrintBrushAsQHull(&brush, "brush");
+ Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &brush, &brush);
}
}
}
}
- else
+ else if(stride == 0)
{
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_CalcEdgeDirsForPolygonBrushFloat(&polyf_brush);
- Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush);
- //Collision_PrintBrushAsQHull(&polyf_brush, "polyf_brush");
- Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &polyf_brush, &polyf_brush);
+ VectorCopy(vertex3f + element3i[0] * 3, points[0].v);
+ VectorCopy(vertex3f + element3i[1] * 3, points[1].v);
+ VectorCopy(vertex3f + element3i[2] * 3, points[2].v);
+ Collision_SnapCopyPoints(brush.numpoints, points, points, COLLISION_SNAPSCALE, COLLISION_SNAP);
+ Collision_CalcEdgeDirsForPolygonBrushFloat(&brush);
+ Collision_CalcPlanesForPolygonBrushFloat(&brush);
+ //Collision_PrintBrushAsQHull(&brush, "brush");
+ Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &brush, &brush);
}
}
}
-}
-
-void Collision_TraceLinePolygonFloat(trace_t *trace, const vec3_t linestart, const vec3_t lineend, int numpoints, const float *points, int supercontents, int q3surfaceflags, texture_t *texture)
-{
- if (numpoints > 256)
+ else
{
- Con_Print("Polygon with more than 256 points not supported yet (fixme!)\n");
- return;
+ for (i = 0;i < numtriangles;i++, element3i += 3)
+ {
+ VectorCopy(vertex3f + element3i[0] * 3, points[0].v);
+ VectorCopy(vertex3f + element3i[1] * 3, points[1].v);
+ VectorCopy(vertex3f + element3i[2] * 3, points[2].v);
+ Collision_SnapCopyPoints(brush.numpoints, points, points, COLLISION_SNAPSCALE, COLLISION_SNAP);
+ Collision_CalcEdgeDirsForPolygonBrushFloat(&brush);
+ Collision_CalcPlanesForPolygonBrushFloat(&brush);
+ //Collision_PrintBrushAsQHull(&brush, "brush");
+ Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &brush, &brush);
+ }
}
- polyf_brush.numpoints = numpoints;
- polyf_brush.numedgedirs = numpoints;
- polyf_brush.numplanes = numpoints + 2;
- //polyf_brush.points = (colpointf_t *)points;
- polyf_brush.points = polyf_points;
- Collision_SnapCopyPoints(polyf_brush.numpoints, (colpointf_t *)points, polyf_points, COLLISION_SNAPSCALE, COLLISION_SNAP);
- polyf_brush.edgedirs = polyf_edgedirs;
- polyf_brush.planes = polyf_planes;
- polyf_brush.supercontents = supercontents;
- polyf_brush.q3surfaceflags = q3surfaceflags;
- polyf_brush.texture = texture;
- //Collision_CalcEdgeDirsForPolygonBrushFloat(&polyf_brush);
- Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush);
- //Collision_PrintBrushAsQHull(&polyf_brush, "polyf_brush");
- 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 stride, float *bbox6f, 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, const texture_t *texture, const vec3_t segmentmins, const vec3_t segmentmaxs)
{
int i;
-#if 1
// FIXME: snap vertices?
- if(stride)
+ if(stride > 0)
{
int k, cnt, tri;
cnt = (numtriangles + stride - 1) / stride;
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.numedgedirs = 3;
- polyf_brush.numplanes = 5;
- polyf_brush.points = polyf_points;
- polyf_brush.edgedirs = polyf_edgedirs;
- polyf_brush.planes = polyf_planes;
- polyf_brush.supercontents = supercontents;
- polyf_brush.q3surfaceflags = q3surfaceflags;
- polyf_brush.texture = texture;
- for (i = 0;i < polyf_brush.numplanes;i++)
- {
- polyf_brush.planes[i].supercontents = supercontents;
- polyf_brush.planes[i].q3surfaceflags = q3surfaceflags;
- polyf_brush.planes[i].texture = texture;
- }
- for (i = 0;i < numtriangles;i++, element3i += 3)
- {
- 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_CalcEdgeDirsForPolygonBrushFloat(&polyf_brush);
- Collision_CalcPlanesForPolygonBrushFloat(&polyf_brush);
- //Collision_PrintBrushAsQHull(&polyf_brush, "polyf_brush");
- Collision_TraceLineBrushFloat(trace, linestart, lineend, &polyf_brush, &polyf_brush);
- }
- }
-#endif
}
-
-#define MAX_BRUSHFORBOX 16
-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 colpointf_t brushforbox_edgedir[MAX_BRUSHFORBOX*3];
-static colplanef_t brushforbox_plane[MAX_BRUSHFORBOX*6];
-static colbrushf_t brushforbox_brush[MAX_BRUSHFORBOX];
-static colbrushf_t brushforpoint_brush[MAX_BRUSHFORBOX];
-
-void Collision_InitBrushForBox(void)
+void Collision_TraceBrushTriangleFloat(trace_t *trace, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, const float *v0, const float *v1, const float *v2, int supercontents, int q3surfaceflags, const texture_t *texture)
{
int i;
- memset(brushforbox_brush, 0, sizeof(brushforbox_brush));
- memset(brushforpoint_brush, 0, sizeof(brushforpoint_brush));
- for (i = 0;i < MAX_BRUSHFORBOX;i++)
+ colpointf_t points[3];
+ colpointf_t edgedirs[3];
+ colplanef_t planes[5];
+ colbrushf_t brush;
+ memset(&brush, 0, sizeof(brush));
+ brush.isaabb = false;
+ brush.hasaabbplanes = false;
+ brush.numpoints = 3;
+ brush.numedgedirs = 3;
+ brush.numplanes = 5;
+ brush.points = points;
+ brush.edgedirs = edgedirs;
+ brush.planes = planes;
+ brush.supercontents = supercontents;
+ brush.q3surfaceflags = q3surfaceflags;
+ brush.texture = texture;
+ for (i = 0;i < brush.numplanes;i++)
{
- brushforbox_brush[i].isaabb = true;
- brushforbox_brush[i].hasaabbplanes = true;
- brushforbox_brush[i].numpoints = 8;
- brushforbox_brush[i].numedgedirs = 3;
- brushforbox_brush[i].numplanes = 6;
- brushforbox_brush[i].points = brushforbox_point + i * 8;
- brushforbox_brush[i].edgedirs = brushforbox_edgedir + i * 3;
- brushforbox_brush[i].planes = brushforbox_plane + i * 6;
- brushforpoint_brush[i].isaabb = true;
- brushforpoint_brush[i].hasaabbplanes = true;
- brushforpoint_brush[i].numpoints = 1;
- brushforpoint_brush[i].numedgedirs = 0;
- brushforpoint_brush[i].numplanes = 0;
- brushforpoint_brush[i].points = brushforbox_point + i * 8;
- brushforpoint_brush[i].edgedirs = brushforbox_edgedir + i * 6;
- brushforpoint_brush[i].planes = brushforbox_plane + i * 6;
+ brush.planes[i].q3surfaceflags = q3surfaceflags;
+ brush.planes[i].texture = texture;
}
+ VectorCopy(v0, points[0].v);
+ VectorCopy(v1, points[1].v);
+ VectorCopy(v2, points[2].v);
+ Collision_SnapCopyPoints(brush.numpoints, points, points, COLLISION_SNAPSCALE, COLLISION_SNAP);
+ Collision_CalcEdgeDirsForPolygonBrushFloat(&brush);
+ Collision_CalcPlanesForPolygonBrushFloat(&brush);
+ //Collision_PrintBrushAsQHull(&brush, "brush");
+ Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &brush, &brush);
}
-colbrushf_t *Collision_BrushForBox(const vec3_t mins, const vec3_t maxs, int supercontents, int q3surfaceflags, texture_t *texture)
+void Collision_BrushForBox(colboxbrushf_t *boxbrush, const vec3_t mins, const vec3_t maxs, int supercontents, int q3surfaceflags, const texture_t *texture)
{
int i;
- colbrushf_t *brush;
- if (brushforbox_brush[0].numpoints == 0)
- Collision_InitBrushForBox();
- // FIXME: these probably don't actually need to be normalized if the collision code does not care
+ memset(boxbrush, 0, sizeof(*boxbrush));
+ boxbrush->brush.isaabb = true;
+ boxbrush->brush.hasaabbplanes = true;
+ boxbrush->brush.points = boxbrush->points;
+ boxbrush->brush.edgedirs = boxbrush->edgedirs;
+ boxbrush->brush.planes = boxbrush->planes;
+ boxbrush->brush.supercontents = supercontents;
+ boxbrush->brush.q3surfaceflags = q3surfaceflags;
+ boxbrush->brush.texture = texture;
if (VectorCompare(mins, maxs))
{
// point brush
- brush = brushforpoint_brush + ((brushforbox_index++) % MAX_BRUSHFORBOX);
- VectorCopy(mins, brush->points->v);
+ boxbrush->brush.numpoints = 1;
+ boxbrush->brush.numedgedirs = 0;
+ boxbrush->brush.numplanes = 0;
+ VectorCopy(mins, boxbrush->brush.points[0].v);
}
else
{
- brush = brushforbox_brush + ((brushforbox_index++) % MAX_BRUSHFORBOX);
+ boxbrush->brush.numpoints = 8;
+ boxbrush->brush.numedgedirs = 3;
+ boxbrush->brush.numplanes = 6;
// there are 8 points on a box
// there are 3 edgedirs on a box (both signs are tested in collision)
// there are 6 planes on a box
- VectorSet(brush->points[0].v, mins[0], mins[1], mins[2]);
- VectorSet(brush->points[1].v, maxs[0], mins[1], mins[2]);
- VectorSet(brush->points[2].v, mins[0], maxs[1], mins[2]);
- VectorSet(brush->points[3].v, maxs[0], maxs[1], mins[2]);
- VectorSet(brush->points[4].v, mins[0], mins[1], maxs[2]);
- VectorSet(brush->points[5].v, maxs[0], mins[1], maxs[2]);
- VectorSet(brush->points[6].v, mins[0], maxs[1], maxs[2]);
- VectorSet(brush->points[7].v, maxs[0], maxs[1], maxs[2]);
- VectorSet(brush->edgedirs[0].v, 1, 0, 0);
- VectorSet(brush->edgedirs[1].v, 0, 1, 0);
- VectorSet(brush->edgedirs[2].v, 0, 0, 1);
- VectorSet(brush->planes[0].normal, -1, 0, 0);brush->planes[0].dist = -mins[0];
- VectorSet(brush->planes[1].normal, 1, 0, 0);brush->planes[1].dist = maxs[0];
- VectorSet(brush->planes[2].normal, 0, -1, 0);brush->planes[2].dist = -mins[1];
- VectorSet(brush->planes[3].normal, 0, 1, 0);brush->planes[3].dist = maxs[1];
- VectorSet(brush->planes[4].normal, 0, 0, -1);brush->planes[4].dist = -mins[2];
- VectorSet(brush->planes[5].normal, 0, 0, 1);brush->planes[5].dist = maxs[2];
+ VectorSet(boxbrush->brush.points[0].v, mins[0], mins[1], mins[2]);
+ VectorSet(boxbrush->brush.points[1].v, maxs[0], mins[1], mins[2]);
+ VectorSet(boxbrush->brush.points[2].v, mins[0], maxs[1], mins[2]);
+ VectorSet(boxbrush->brush.points[3].v, maxs[0], maxs[1], mins[2]);
+ VectorSet(boxbrush->brush.points[4].v, mins[0], mins[1], maxs[2]);
+ VectorSet(boxbrush->brush.points[5].v, maxs[0], mins[1], maxs[2]);
+ VectorSet(boxbrush->brush.points[6].v, mins[0], maxs[1], maxs[2]);
+ VectorSet(boxbrush->brush.points[7].v, maxs[0], maxs[1], maxs[2]);
+ VectorSet(boxbrush->brush.edgedirs[0].v, 1, 0, 0);
+ VectorSet(boxbrush->brush.edgedirs[1].v, 0, 1, 0);
+ VectorSet(boxbrush->brush.edgedirs[2].v, 0, 0, 1);
+ VectorSet(boxbrush->brush.planes[0].normal, -1, 0, 0);boxbrush->brush.planes[0].dist = -mins[0];
+ VectorSet(boxbrush->brush.planes[1].normal, 1, 0, 0);boxbrush->brush.planes[1].dist = maxs[0];
+ VectorSet(boxbrush->brush.planes[2].normal, 0, -1, 0);boxbrush->brush.planes[2].dist = -mins[1];
+ VectorSet(boxbrush->brush.planes[3].normal, 0, 1, 0);boxbrush->brush.planes[3].dist = maxs[1];
+ VectorSet(boxbrush->brush.planes[4].normal, 0, 0, -1);boxbrush->brush.planes[4].dist = -mins[2];
+ VectorSet(boxbrush->brush.planes[5].normal, 0, 0, 1);boxbrush->brush.planes[5].dist = maxs[2];
for (i = 0;i < 6;i++)
{
- brush->planes[i].q3surfaceflags = q3surfaceflags;
- brush->planes[i].texture = texture;
+ boxbrush->brush.planes[i].q3surfaceflags = q3surfaceflags;
+ boxbrush->brush.planes[i].texture = texture;
}
}
- brush->supercontents = supercontents;
- brush->q3surfaceflags = q3surfaceflags;
- brush->texture = texture;
- VectorSet(brush->mins, mins[0] - 1, mins[1] - 1, mins[2] - 1);
- VectorSet(brush->maxs, maxs[0] + 1, maxs[1] + 1, maxs[2] + 1);
- Collision_ValidateBrush(brush);
- return brush;
+ boxbrush->brush.supercontents = supercontents;
+ boxbrush->brush.q3surfaceflags = q3surfaceflags;
+ boxbrush->brush.texture = texture;
+ VectorSet(boxbrush->brush.mins, mins[0] - 1, mins[1] - 1, mins[2] - 1);
+ VectorSet(boxbrush->brush.maxs, maxs[0] + 1, maxs[1] + 1, maxs[2] + 1);
+ 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)
{
- colbrushf_t *boxbrush, *thisbrush_start, *thisbrush_end;
+ colboxbrushf_t boxbrush, thisbrush_start, thisbrush_end;
vec3_t startmins, startmaxs, endmins, endmaxs;
// create brushes for the collision
VectorAdd(start, maxs, startmaxs);
VectorAdd(end, mins, endmins);
VectorAdd(end, maxs, endmaxs);
- boxbrush = Collision_BrushForBox(cmins, cmaxs, supercontents, q3surfaceflags, texture);
- thisbrush_start = Collision_BrushForBox(startmins, startmaxs, 0, 0, NULL);
- thisbrush_end = Collision_BrushForBox(endmins, endmaxs, 0, 0, NULL);
+ 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, thisbrush_end, boxbrush, boxbrush);
+ Collision_TraceBrushBrushFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, &boxbrush.brush, &boxbrush.brush);
}
//pseudocode for detecting line/sphere overlap without calculating an impact point
return impactdist / linelength;
}
-void Collision_TraceLineTriangleFloat(trace_t *trace, const vec3_t linestart, const vec3_t lineend, const float *point0, const float *point1, const float *point2, int supercontents, int q3surfaceflags, texture_t *texture)
+void Collision_TraceLineTriangleFloat(trace_t *trace, const vec3_t linestart, const vec3_t lineend, const float *point0, const float *point1, const float *point2, int supercontents, int q3surfaceflags, const texture_t *texture)
{
#if 1
// more optimized
//===========================================
-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)
+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];
#endif
if (model && model->TraceBox)
- model->TraceBox(model, bound(0, frame, (model->numframes - 1)), trace, starttransformed, mins, maxs, endtransformed, hitsupercontentsmask);
+ model->TraceBox(model, frameblend, skeleton, 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);
memset(trace, 0, sizeof(*trace));
trace->fraction = trace->realfraction = 1;
if (model && model->TraceBox)
- model->TraceBox(model, 0, trace, start, mins, maxs, end, hitsupercontents);
+ model->TraceBox(model, NULL, NULL, 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_ClipLineToGenericEntity(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 end, int hitsupercontentsmask)
+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)
{
float starttransformed[3], endtransformed[3];
#endif
if (model && model->TraceLine)
- model->TraceLine(model, bound(0, frame, (model->numframes - 1)), trace, starttransformed, endtransformed, hitsupercontentsmask);
+ model->TraceLine(model, frameblend, skeleton, trace, starttransformed, endtransformed, hitsupercontentsmask);
else
Collision_ClipTrace_Box(trace, bodymins, bodymaxs, starttransformed, vec3_origin, vec3_origin, endtransformed, hitsupercontentsmask, bodysupercontents, 0, NULL);
trace->fraction = bound(0, trace->fraction, 1);
memset(trace, 0, sizeof(*trace));
trace->fraction = trace->realfraction = 1;
if (model && model->TraceLine)
- model->TraceLine(model, 0, trace, start, end, hitsupercontents);
+ model->TraceLine(model, NULL, NULL, trace, start, 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_ClipPointToGenericEntity(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, int hitsupercontentsmask)
+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];
#endif
if (model && model->TracePoint)
- model->TracePoint(model, bound(0, frame, (model->numframes - 1)), trace, starttransformed, hitsupercontentsmask);
+ model->TracePoint(model, NULL, NULL, trace, starttransformed, hitsupercontentsmask);
else
Collision_ClipTrace_Point(trace, bodymins, bodymaxs, starttransformed, hitsupercontentsmask, bodysupercontents, 0, NULL);
memset(trace, 0, sizeof(*trace));
trace->fraction = trace->realfraction = 1;
if (model && model->TracePoint)
- model->TracePoint(model, 0, trace, start, hitsupercontents);
+ model->TracePoint(model, NULL, NULL, trace, start, hitsupercontents);
VectorCopy(start, trace->endpos);
}
projects / xonotic / darkplaces.git / blobdiff