no time to explain, more changes on the path to q3bsp support
[xonotic/darkplaces.git] / collision.c
index ef8e06f..4936e2d 100644 (file)
@@ -206,39 +206,6 @@ static void RecursiveHullCheckPoint (RecursiveHullCheckTraceInfo_t *t, int num)
 }
 #endif
 
-void Collision_RoundUpToHullSize(const model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs)
-{
-       vec3_t size;
-       const hull_t *hull;
-
-       VectorSubtract(inmaxs, inmins, size);
-       if (cmodel->brushq1.ishlbsp)
-       {
-               if (size[0] < 3)
-                       hull = &cmodel->brushq1.hulls[0]; // 0x0x0
-               else if (size[0] <= 32)
-               {
-                       if (size[2] < 54) // pick the nearest of 36 or 72
-                               hull = &cmodel->brushq1.hulls[3]; // 32x32x36
-                       else
-                               hull = &cmodel->brushq1.hulls[1]; // 32x32x72
-               }
-               else
-                       hull = &cmodel->brushq1.hulls[2]; // 64x64x64
-       }
-       else
-       {
-               if (size[0] < 3)
-                       hull = &cmodel->brushq1.hulls[0]; // 0x0x0
-               else if (size[0] <= 32)
-                       hull = &cmodel->brushq1.hulls[1]; // 32x32x56
-               else
-                       hull = &cmodel->brushq1.hulls[2]; // 64x64x88
-       }
-       VectorCopy(inmins, outmins);
-       VectorAdd(inmins, hull->clip_size, outmaxs);
-}
-
 static hull_t box_hull;
 static dclipnode_t box_clipnodes[6];
 static mplane_t box_planes[6];
@@ -562,301 +529,6 @@ void Collision_TraceBrushPolygonTransformFloat(trace_t *trace, const colbrushf_t
        Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, &polyf_brushstart, &polyf_brushend);
 }
 
-colbrushd_t *Collision_AllocBrushDouble(mempool_t *mempool, int numpoints, int numplanes)
-{
-       colbrushd_t *brush;
-       brush = Mem_Alloc(mempool, sizeof(colbrushd_t) + sizeof(colpointd_t) * numpoints + sizeof(colplaned_t) * numplanes);
-       brush->numpoints = numpoints;
-       brush->numplanes = numplanes;
-       brush->planes = (void *)(brush + 1);
-       brush->points = (void *)(brush->planes + brush->numplanes);
-       return brush;
-}
-
-void Collision_CalcPlanesForPolygonBrushDouble(colbrushd_t *brush)
-{
-       int i;
-       double edge0[3], edge1[3], normal[3], dist, bestdist;
-       colpointd_t *p, *p2;
-
-       // choose best surface normal for polygon's plane
-       bestdist = 0;
-       for (i = 2, p = brush->points + 2;i < brush->numpoints;i++, p++)
-       {
-               VectorSubtract(p[-1].v, p[0].v, edge0);
-               VectorSubtract(p[1].v, p[0].v, edge1);
-               CrossProduct(edge0, edge1, normal);
-               dist = DotProduct(normal, normal);
-               if (i == 2 || bestdist < dist)
-               {
-                       bestdist = dist;
-                       VectorCopy(normal, brush->planes->normal);
-               }
-       }
-
-       VectorNormalize(brush->planes->normal);
-       brush->planes->dist = DotProduct(brush->points->v, brush->planes->normal);
-
-       // negate plane to create other side
-       VectorNegate(brush->planes[0].normal, brush->planes[1].normal);
-       brush->planes[1].dist = -brush->planes[0].dist;
-       for (i = 0, p = brush->points + (brush->numpoints - 1), p2 = brush->points + 2;i < brush->numpoints;i++, p = p2, p2++)
-       {
-               VectorSubtract(p->v, p2->v, edge0);
-               CrossProduct(edge0, brush->planes->normal, brush->planes[i].normal);
-               VectorNormalize(brush->planes[i].normal);
-               brush->planes[i].dist = DotProduct(p->v, brush->planes[i].normal);
-       }
-
-#if 1
-       // validity check - will be disabled later
-       for (i = 0;i < brush->numplanes;i++)
-       {
-               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 + (1.0 / 32.0))
-                               Con_Printf("Error in brush plane generation, plane %i\n");
-       }
-#endif
-}
-
-colbrushd_t *Collision_AllocBrushFromPermanentPolygonDouble(mempool_t *mempool, int numpoints, double *points)
-{
-       colbrushd_t *brush;
-       brush = Mem_Alloc(mempool, sizeof(colbrushd_t) + sizeof(colplaned_t) * (numpoints + 2));
-       brush->numpoints = numpoints;
-       brush->numplanes = numpoints + 2;
-       brush->planes = (void *)(brush + 1);
-       brush->points = (colpointd_t *)points;
-       return brush;
-}
-
-
-double nearestplanedist_double(const double *normal, const colpointd_t *points, int numpoints)
-{
-       double dist, bestdist;
-       bestdist = DotProduct(points->v, normal);
-       points++;
-       while(--numpoints)
-       {
-               dist = DotProduct(points->v, normal);
-               if (bestdist > dist)
-                       bestdist = dist;
-               points++;
-       }
-       return bestdist;
-}
-
-double furthestplanedist_double(const double *normal, const colpointd_t *points, int numpoints)
-{
-       double dist, bestdist;
-       bestdist = DotProduct(points->v, normal);
-       points++;
-       while(--numpoints)
-       {
-               dist = DotProduct(points->v, normal);
-               if (bestdist < dist)
-                       bestdist = dist;
-               points++;
-       }
-       return bestdist;
-}
-
-// NOTE: start and end of each brush pair must have same numplanes/numpoints
-void Collision_TraceBrushBrushDouble(trace_t *trace, const colbrushd_t *thisbrush_start, const colbrushd_t *thisbrush_end, const colbrushd_t *thatbrush_start, const colbrushd_t *thatbrush_end)
-{
-       int nplane, nplane2, fstartsolid, fendsolid;
-       double enterfrac, leavefrac, d1, d2, f, newimpactnormal[3];
-       const colplaned_t *startplane, *endplane;
-
-       enterfrac = -1;
-       leavefrac = 1;
-       fstartsolid = true;
-       fendsolid = true;
-
-       for (nplane = 0;nplane < thatbrush_start->numplanes + thisbrush_start->numplanes;nplane++)
-       {
-               nplane2 = nplane;
-               if (nplane2 >= thatbrush_start->numplanes)
-               {
-                       nplane2 -= thatbrush_start->numplanes;
-                       startplane = thisbrush_start->planes + nplane2;
-                       endplane = thisbrush_end->planes + nplane2;
-               }
-               else
-               {
-                       startplane = thatbrush_start->planes + nplane2;
-                       endplane = thatbrush_end->planes + nplane2;
-               }
-               d1 = nearestplanedist_double(startplane->normal, thisbrush_start->points, thisbrush_start->numpoints) - furthestplanedist_double(startplane->normal, thatbrush_start->points, thatbrush_start->numpoints);
-               d2 = nearestplanedist_double(endplane->normal, thisbrush_end->points, thisbrush_end->numpoints) - furthestplanedist_double(endplane->normal, thatbrush_end->points, thatbrush_end->numpoints) - COLLISIONEPSILON2;
-               //Con_Printf("%c%i: d1 = %f, d2 = %f, d1 / (d1 - d2) = %f\n", nplane2 != nplane ? 'b' : 'a', nplane2, d1, d2, d1 / (d1 - d2));
-
-               f = d1 - d2;
-               if (f >= 0)
-               {
-                       // moving into brush
-                       if (d2 > 0)
-                               return;
-                       if (d1 < 0)
-                               continue;
-                       // enter
-                       fstartsolid = false;
-                       f = (d1 - COLLISIONEPSILON) / f;
-                       f = bound(0, f, 1);
-                       if (enterfrac < f)
-                       {
-                               enterfrac = f;
-                               VectorBlend(startplane->normal, endplane->normal, enterfrac, newimpactnormal);
-                       }
-               }
-               else if (f < 0)
-               {
-                       // moving out of brush
-                       if (d1 > 0)
-                               return;
-                       if (d2 < 0)
-                               continue;
-                       // leave
-                       fendsolid = false;
-                       f = (d1 + COLLISIONEPSILON) / f;
-                       f = bound(0, f, 1);
-                       if (leavefrac > f)
-                               leavefrac = f;
-               }
-       }
-
-       if (fstartsolid)
-       {
-               trace->startsolid = true;
-               if (fendsolid)
-                       trace->allsolid = true;
-       }
-
-       // LordHavoc: we need an epsilon nudge here because for a point trace the
-       // 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 (enterfrac > -1 && enterfrac < trace->fraction && enterfrac - (1.0f / 1024.0f) <= leavefrac)
-       {
-               trace->fraction = bound(0, enterfrac, 1);
-               VectorCopy(newimpactnormal, trace->plane.normal);
-       }
-}
-
-static colplaned_t polyd_planes[256 + 2];
-static colbrushd_t polyd_brush;
-void Collision_TraceBrushPolygonDouble(trace_t *trace, const colbrushd_t *thisbrush_start, const colbrushd_t *thisbrush_end, int numpoints, const double *points)
-{
-       if (numpoints > 256)
-       {
-               Con_Printf("Polygon with more than 256 points not supported yet (fixme!)\n");
-               return;
-       }
-       polyd_brush.numpoints = numpoints;
-       polyd_brush.numplanes = numpoints + 2;
-       polyd_brush.points = (colpointd_t *)points;
-       polyd_brush.planes = polyd_planes;
-       Collision_CalcPlanesForPolygonBrushDouble(&polyd_brush);
-       Collision_TraceBrushBrushDouble(trace, thisbrush_start, thisbrush_end, &polyd_brush, &polyd_brush);
-}
-
-
-
-
-typedef struct colbrushbmodelinfo_s
-{
-       model_t *model;
-       trace_t *trace;
-       const matrix4x4_t *modelmatrixstart;
-       const matrix4x4_t *modelmatrixend;
-       const colbrushf_t *thisbrush_start;
-       const colbrushf_t *thisbrush_end;
-}
-colbrushbmodelinfo_t;
-
-static int colframecount = 1;
-
-void Collision_RecursiveTraceBrushNode(colbrushbmodelinfo_t *info, mnode_t *node)
-{
-       if (node->contents)
-       {
-               // collide with surfaces marked by this leaf
-               int i, *mark;
-               mleaf_t *leaf = (mleaf_t *)node;
-               msurface_t *surf;
-               for (i = 0, mark = leaf->firstmarksurface;i < leaf->nummarksurfaces;i++, mark++)
-               {
-                       surf = info->model->brushq1.surfaces + *mark;
-                       // don't check a surface twice
-                       if (surf->colframe != colframecount)
-                       {
-                               surf->colframe = colframecount;
-                               if (surf->flags & SURF_SOLIDCLIP)
-                               {
-                                       Collision_TraceBrushPolygonFloat(info->trace, info->thisbrush_start, info->thisbrush_end, surf->poly_numverts, surf->poly_verts);
-                                       //Collision_TraceBrushPolygonTransformFloat(info->trace, info->thisbrush_start, info->thisbrush_end, surf->poly_numverts, surf->poly_verts, info->modelmatrixstart, info->modelmatrixend);
-                               }
-                       }
-               }
-       }
-       else
-       {
-               // recurse down node sides
-               int i;
-               float dist;
-               colpointf_t *ps, *pe;
-               // FIXME? if TraceBrushPolygonTransform were to be made usable, the
-               // node planes would need to be transformed too
-               dist = node->plane->dist - (1.0f / 8.0f);
-               for (i = 0, ps = info->thisbrush_start->points, pe = info->thisbrush_end->points;i < info->thisbrush_start->numpoints;i++, ps++, pe++)
-               {
-                       if (DotProduct(ps->v, node->plane->normal) > dist || DotProduct(pe->v, node->plane->normal) > dist)
-                       {
-                               Collision_RecursiveTraceBrushNode(info, node->children[0]);
-                               break;
-                       }
-               }
-               dist = node->plane->dist + (1.0f / 8.0f);
-               for (i = 0, ps = info->thisbrush_start->points, pe = info->thisbrush_end->points;i < info->thisbrush_start->numpoints;i++, ps++, pe++)
-               {
-                       if (DotProduct(ps->v, node->plane->normal) < dist || DotProduct(pe->v, node->plane->normal) < dist)
-                       {
-                               Collision_RecursiveTraceBrushNode(info, node->children[1]);
-                               break;
-                       }
-               }
-       }
-}
-
-void Collision_TraceBrushBModel(trace_t *trace, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, model_t *model)
-{
-       colbrushbmodelinfo_t info;
-       colframecount++;
-       memset(trace, 0, sizeof(*trace));
-       trace->fraction = 1;
-       info.trace = trace;
-       info.model = model;
-       info.thisbrush_start = thisbrush_start;
-       info.thisbrush_end = thisbrush_end;
-       Collision_RecursiveTraceBrushNode(&info, model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode);
-}
-
-void Collision_TraceBrushBModelTransform(trace_t *trace, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, model_t *model, const matrix4x4_t *modelmatrixstart, const matrix4x4_t *modelmatrixend)
-{
-       colbrushbmodelinfo_t info;
-       colframecount++;
-       memset(trace, 0, sizeof(*trace));
-       trace->fraction = 1;
-       info.trace = trace;
-       info.model = model;
-       info.modelmatrixstart = modelmatrixstart;
-       info.modelmatrixend = modelmatrixend;
-       info.thisbrush_start = thisbrush_start;
-       info.thisbrush_end = thisbrush_end;
-       Collision_RecursiveTraceBrushNode(&info, model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode);
-}
-
 
 
 #define MAX_BRUSHFORBOX 16
@@ -905,60 +577,6 @@ colbrushf_t *Collision_BrushForBox(const matrix4x4_t *matrix, const vec3_t mins,
        return brush;
 }
 
-void Collision_PolygonClipTrace (trace_t *trace, const void *cent, model_t *cmodel, const vec3_t corigin, const vec3_t cangles, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end)
-{
-       vec3_t impactnormal;
-       //vec3_t mins2, maxs2;
-       matrix4x4_t cmatrix, cimatrix, startmatrix, endmatrix;
-       matrix4x4_t mstartmatrix, mendmatrix, identitymatrix;
-       colbrushf_t *thisbrush_start, *thisbrush_end, *cbrush;
-
-       Matrix4x4_CreateFromQuakeEntity(&cmatrix, corigin[0], corigin[1], corigin[2], cangles[0], cangles[1], cangles[2], 1);
-       Matrix4x4_Invert_Simple(&cimatrix, &cmatrix);
-       Matrix4x4_CreateTranslate(&startmatrix, start[0], start[1], start[2]);
-       Matrix4x4_CreateTranslate(&endmatrix, end[0], end[1], end[2]);
-
-       Matrix4x4_CreateIdentity(&identitymatrix);
-       Matrix4x4_Concat(&mstartmatrix, &cimatrix, &startmatrix);
-       Matrix4x4_Concat(&mendmatrix, &cimatrix, &endmatrix);
-       thisbrush_start = Collision_BrushForBox(&mstartmatrix, mins, maxs);
-       //mins2[0] = mins[0] - 0.0625;mins2[1] = mins[1] - 0.0625;mins2[2] = mins[2] - 0.0625;
-       //maxs2[0] = maxs[0] + 0.0625;maxs2[1] = maxs[1] + 0.0625;maxs2[2] = maxs[2] + 0.0625;
-       thisbrush_end = Collision_BrushForBox(&mendmatrix, mins, maxs);
-
-       //Collision_PrintBrushAsQHull(thisbrush_start, "thisbrush_start");
-       //Collision_PrintBrushAsQHull(thisbrush_end, "thisbrush_end");
-       memset (trace, 0, sizeof(trace_t));
-       if (cmodel && cmodel->type == mod_brush)
-       {
-               // brush model
-               Collision_TraceBrushBModel(trace, thisbrush_start, thisbrush_end, cmodel);
-               //Collision_TraceBrushBModelTransform(trace, thisbrush_start, thisbrush_end, cmodel, &cmatrix, &cmatrix);
-       }
-       else
-       {
-               // bounding box
-               cbrush = Collision_BrushForBox(&identitymatrix, cmins, cmaxs);
-               Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, cbrush, cbrush);
-               //cbrush = Collision_BrushForBox(&cmatrix, cmins, cmaxs);
-               //trace->fraction = Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, cbrush, cbrush);
-       }
-
-       if (trace->fraction < 0 || trace->fraction > 1)
-               Con_Printf("fraction out of bounds %f %s:%d\n", trace->fraction, __FILE__, __LINE__);
-
-       VectorBlend(start, end, trace->fraction, trace->endpos);
-       if (trace->fraction < 1)
-       {
-               trace->ent = (void *) cent;
-               VectorCopy(trace->plane.normal, impactnormal);
-               Matrix4x4_Transform(&cmatrix, impactnormal, trace->plane.normal);
-               VectorNormalize(trace->plane.normal);
-               //Con_Printf("fraction %f normal %f %f %f\n", trace->fraction, trace->plane.normal[0], trace->plane.normal[1], trace->plane.normal[2]);
-       }
-}
-
-
 // LordHavoc: currently unused and not yet tested
 // note: this can be used for tracing a moving sphere vs a stationary sphere,
 // by simply adding the moving sphere's radius to the sphereradius parameter,