prj/cam/src/physics/phterr.cpp

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6 ///////////////////////////////////////////////////////////////////////////////
   7 // $Header: r:/t2repos/thief2/src/physics/phterr.cpp,v 1.12 2000/02/19 12:32:23 toml Exp $
   8 //
   9 //
  10 //
  11
  12 #include <lg.h>
  13 #include <matrix.h>
  14 #include <math.h>
  15 #include <wrfunc.h>
  16
  17 #include <phcontct.h>
  18 #include <phterr.h>
  19
  20 class cPhysSubModelInst;
  21
  22 ///////////////////////////////////////////////////////////////////////////////
  23 //
  24 // CLASS: cPhysTerrPolyList
  25 //
  26
  27 cPhysTerrPolyList::~cPhysTerrPolyList(void)
  28 {
  29    cPhysTerrPoly *pPoly = GetFirst();
  30    while (pPoly != NULL)
  31    {
  32       delete pPoly;
  33       pPoly = GetFirst();
  34    }
  35 }
  36
  37 ///////////////////////////////////////
  38
  39 BOOL cPhysTerrPolyList::GetNormal(mxs_vector & normal, const mxs_vector &sphere_loc, mxs_real sphere_radius) const
  40 {
  41    cPhysTerrPoly *pPoly = GetFirst();
  42
  43    // count the number of polygons
  44    int poly_count = 0;
  45    while (pPoly != NULL)
  46    {
  47       poly_count++;
  48       pPoly = pPoly->GetNext();
  49    }
  50
  51    switch (poly_count)
  52    {
  53       case 0:
  54       {
  55          Warning(("Zero-length poly list?\n"));
  56          return FALSE;
  57       }
  58
  59       case 1:
  60       {
  61          pPoly = GetFirst();
  62          mx_copy_vec(&normal, &pPoly->GetNormal());
  63          break;
  64       }
  65
  66       case 2:
  67       {
  68          mxs_vector *start, *end;
  69          int cell_id, poly_id;
  70          int offset, offset_max;
  71          int i, j;
  72
  73          mxs_real best_edge_dist = -1.0;
  74
  75          pPoly = GetFirst();
  76          while (pPoly != NULL)
  77          {
  78             cell_id = pPoly->GetCellID();
  79             poly_id = pPoly->GetPolyID();
  80
  81             // Find starting offset of poly
  82             offset = 0;
  83             for (i=0; i<poly_id; i++)
  84                offset += WR_CELL(cell_id)->poly_list[i].num_vertices;
  85
  86             offset_max = offset + WR_CELL(cell_id)->poly_list[poly_id].num_vertices;
  87
  88             // Find an edge that contains the collision point
  89             for (i=offset; i<offset_max; i++)
  90             {
  91                j = ((i - offset + 1) % (offset_max - offset)) + offset;
  92                start = &WR_CELL(cell_id)->vpool[WR_CELL(cell_id)->vertex_list[i]];
  93                end   = &WR_CELL(cell_id)->vpool[WR_CELL(cell_id)->vertex_list[j]];
  94
  95                cEdgeContact edgeContact(*start, *end);
  96                mxs_real edge_dist = fabs(edgeContact.GetDist(sphere_loc) - sphere_radius);
  97                if ((best_edge_dist < 0.0) || (edge_dist < best_edge_dist))
  98                {
  99                   best_edge_dist = edge_dist;
 100                   mx_copy_vec(&normal, &edgeContact.GetNormal(sphere_loc));
 101                }
 102             }
 103
 104             pPoly = pPoly->GetNext();
 105          }
 106
 107          if (best_edge_dist < 0.0)
 108          {
 109             Warning(("No edge found for normal computation!\n"));
 110             mx_unit_vec(&normal, 0); // uh, why not
 111             return FALSE;
 112          }
 113
 114          break;
 115       }
 116
 117       default:
 118       {
 119          if ((poly_count < 0) || (poly_count > 20))
 120          {
 121             Warning(("Suspicious number of polys in list: %d\n", poly_count));
 122             return FALSE;
 123          }
 124
 125          mxs_vector *vertex;
 126          int cell_id, poly_id;
 127          int offset, offset_max;
 128          int i;
 129          mxs_real best_vertex_dist = -1.0;
 130
 131          pPoly = GetFirst();
 132          while (pPoly != NULL)
 133          {
 134             cell_id = pPoly->GetCellID();
 135             poly_id = pPoly->GetPolyID();
 136
 137             // Find starting offset of poly
 138             offset = 0;
 139             for (i=0; i<poly_id; i++)
 140                offset += WR_CELL(cell_id)->poly_list[i].num_vertices;
 141
 142             offset_max = offset + WR_CELL(cell_id)->poly_list[poly_id].num_vertices;
 143
 144             // Find a vertex that is the right distance from the collision point
 145             for (i=offset; i<offset_max; i++)
 146             {
 147                vertex = &WR_CELL(cell_id)->vpool[WR_CELL(cell_id)->vertex_list[i]];
 148
 149                mxs_real vertex_dist = fabs(mx_dist_vec(vertex, &sphere_loc) - sphere_radius);
 150
 151                if ((best_vertex_dist < 0.0) || (vertex_dist < best_vertex_dist))
 152                {
 153                   best_vertex_dist = vertex_dist;
 154                   mx_sub_vec(&normal, &sphere_loc, vertex);
 155                }
 156             }
 157
 158             pPoly = pPoly->GetNext();
 159          }
 160
 161          if (best_vertex_dist < 0.0)
 162          {
 163             Warning(("No edge found for normal computation!\n"));
 164             mx_unit_vec(&normal, 0); // uh, why not
 165             return FALSE;
 166          }
 167
 168          if (mx_mag2_vec(&normal) > 0.0001)
 169             mx_normeq_vec(&normal);
 170
 171          break;
 172       }
 173    }
 174
 175    return TRUE;
 176 }
 177
 178 ///////////////////////////////////////
 179 //
 180 // Find a poly in a list
 181 //
 182
 183 BOOL cPhysTerrPolyList::Find(int cellID, int polyID, cPhysTerrPoly ** ppTerrPoly) const
 184 {
 185    cPhysTerrPoly *pPoly = GetFirst();
 186
 187    while (pPoly != NULL)
 188    {
 189       if ((pPoly->GetCellID() == cellID) && (pPoly->GetPolyID() == polyID))
 190       {
 191          *ppTerrPoly = pPoly;
 192          return TRUE;
 193       }
 194       pPoly = pPoly->GetNext();
 195    }
 196
 197    return FALSE;
 198 }
 199
 200 ///////////////////////////////////////////////////////////////////////////////
 201 //
 202 // CLASS: cPhysTerrPoly
 203 //
 204
 205 #include <wr.h>
 206 #include <memall.h>
 207 #include <dbmem.h>   // must be last header!
 208
 209 int cPhysTerrPoly::GetPlaneID(void) const
 210 {
 211    return WR_CELL(m_cellID)->poly_list[m_polyID].planeid;
 212 }
 213
 214 ///////////////////////////////////////
 215
 216 const mxs_vector & cPhysTerrPoly::GetNormal(void) const
 217 {
 218    return WR_CELL(m_cellID)->plane_list[GetPlaneID()].normal;
 219 }
 220
 221 ///////////////////////////////////////
 222
 223 mxs_real cPhysTerrPoly::GetPlaneConstant(void) const
 224 {
 225    return WR_CELL(m_cellID)->plane_list[GetPlaneID()].plane_constant;
 226 }
 227
 228 ///////////////////////////////////////////////////////////////////////////////
 229 //
 230 // CLASS: cPhysTerrPolyArray
 231 //
 232
 233 ///////////////////////////////////////////////////////////////////////////////
 234