![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pmovetst.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quakeworld / client|
Return to pmovetst.c CVS log | Up to [Quake] / quakeworld / client |
1.1 ! root 1: /* ! 2: Copyright (C) 1996-1997 Id Software, Inc. ! 3: ! 4: This program is free software; you can redistribute it and/or ! 5: modify it under the terms of the GNU General Public License ! 6: as published by the Free Software Foundation; either version 2 ! 7: of the License, or (at your option) any later version. ! 8: ! 9: This program is distributed in the hope that it will be useful, ! 10: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ! 12: ! 13: See the GNU General Public License for more details. ! 14: ! 15: You should have received a copy of the GNU General Public License ! 16: along with this program; if not, write to the Free Software ! 17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ! 18: ! 19: */ ! 20: #include "quakedef.h" ! 21: ! 22: static hull_t box_hull; ! 23: static dclipnode_t box_clipnodes[6]; ! 24: static mplane_t box_planes[6]; ! 25: ! 26: extern vec3_t player_mins; ! 27: extern vec3_t player_maxs; ! 28: ! 29: /* ! 30: =================== ! 31: PM_InitBoxHull ! 32: ! 33: Set up the planes and clipnodes so that the six floats of a bounding box ! 34: can just be stored out and get a proper hull_t structure. ! 35: =================== ! 36: */ ! 37: void PM_InitBoxHull (void) ! 38: { ! 39: int i; ! 40: int side; ! 41: ! 42: box_hull.clipnodes = box_clipnodes; ! 43: box_hull.planes = box_planes; ! 44: box_hull.firstclipnode = 0; ! 45: box_hull.lastclipnode = 5; ! 46: ! 47: for (i=0 ; i<6 ; i++) ! 48: { ! 49: box_clipnodes[i].planenum = i; ! 50: ! 51: side = i&1; ! 52: ! 53: box_clipnodes[i].children[side] = CONTENTS_EMPTY; ! 54: if (i != 5) ! 55: box_clipnodes[i].children[side^1] = i + 1; ! 56: else ! 57: box_clipnodes[i].children[side^1] = CONTENTS_SOLID; ! 58: ! 59: box_planes[i].type = i>>1; ! 60: box_planes[i].normal[i>>1] = 1; ! 61: } ! 62: ! 63: } ! 64: ! 65: ! 66: /* ! 67: =================== ! 68: PM_HullForBox ! 69: ! 70: To keep everything totally uniform, bounding boxes are turned into small ! 71: BSP trees instead of being compared directly. ! 72: =================== ! 73: */ ! 74: hull_t *PM_HullForBox (vec3_t mins, vec3_t maxs) ! 75: { ! 76: box_planes[0].dist = maxs[0]; ! 77: box_planes[1].dist = mins[0]; ! 78: box_planes[2].dist = maxs[1]; ! 79: box_planes[3].dist = mins[1]; ! 80: box_planes[4].dist = maxs[2]; ! 81: box_planes[5].dist = mins[2]; ! 82: ! 83: return &box_hull; ! 84: } ! 85: ! 86: ! 87: /* ! 88: ================== ! 89: PM_HullPointContents ! 90: ! 91: ================== ! 92: */ ! 93: int PM_HullPointContents (hull_t *hull, int num, vec3_t p) ! 94: { ! 95: float d; ! 96: dclipnode_t *node; ! 97: mplane_t *plane; ! 98: ! 99: while (num >= 0) ! 100: { ! 101: if (num < hull->firstclipnode || num > hull->lastclipnode) ! 102: Sys_Error ("PM_HullPointContents: bad node number"); ! 103: ! 104: node = hull->clipnodes + num; ! 105: plane = hull->planes + node->planenum; ! 106: ! 107: if (plane->type < 3) ! 108: d = p[plane->type] - plane->dist; ! 109: else ! 110: d = DotProduct (plane->normal, p) - plane->dist; ! 111: if (d < 0) ! 112: num = node->children[1]; ! 113: else ! 114: num = node->children[0]; ! 115: } ! 116: ! 117: return num; ! 118: } ! 119: ! 120: /* ! 121: ================== ! 122: PM_PointContents ! 123: ! 124: ================== ! 125: */ ! 126: int PM_PointContents (vec3_t p) ! 127: { ! 128: float d; ! 129: dclipnode_t *node; ! 130: mplane_t *plane; ! 131: hull_t *hull; ! 132: int num; ! 133: ! 134: hull = &pmove.physents[0].model->hulls[0]; ! 135: ! 136: num = hull->firstclipnode; ! 137: ! 138: while (num >= 0) ! 139: { ! 140: if (num < hull->firstclipnode || num > hull->lastclipnode) ! 141: Sys_Error ("PM_HullPointContents: bad node number"); ! 142: ! 143: node = hull->clipnodes + num; ! 144: plane = hull->planes + node->planenum; ! 145: ! 146: if (plane->type < 3) ! 147: d = p[plane->type] - plane->dist; ! 148: else ! 149: d = DotProduct (plane->normal, p) - plane->dist; ! 150: if (d < 0) ! 151: num = node->children[1]; ! 152: else ! 153: num = node->children[0]; ! 154: } ! 155: ! 156: return num; ! 157: } ! 158: ! 159: /* ! 160: =============================================================================== ! 161: ! 162: LINE TESTING IN HULLS ! 163: ! 164: =============================================================================== ! 165: */ ! 166: ! 167: // 1/32 epsilon to keep floating point happy ! 168: #define DIST_EPSILON (0.03125) ! 169: ! 170: /* ! 171: ================== ! 172: PM_RecursiveHullCheck ! 173: ! 174: ================== ! 175: */ ! 176: qboolean PM_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t p1, vec3_t p2, pmtrace_t *trace) ! 177: { ! 178: dclipnode_t *node; ! 179: mplane_t *plane; ! 180: float t1, t2; ! 181: float frac; ! 182: int i; ! 183: vec3_t mid; ! 184: int side; ! 185: float midf; ! 186: ! 187: // check for empty ! 188: if (num < 0) ! 189: { ! 190: if (num != CONTENTS_SOLID) ! 191: { ! 192: trace->allsolid = false; ! 193: if (num == CONTENTS_EMPTY) ! 194: trace->inopen = true; ! 195: else ! 196: trace->inwater = true; ! 197: } ! 198: else ! 199: trace->startsolid = true; ! 200: return true; // empty ! 201: } ! 202: ! 203: if (num < hull->firstclipnode || num > hull->lastclipnode) ! 204: Sys_Error ("PM_RecursiveHullCheck: bad node number"); ! 205: ! 206: // ! 207: // find the point distances ! 208: // ! 209: node = hull->clipnodes + num; ! 210: plane = hull->planes + node->planenum; ! 211: ! 212: if (plane->type < 3) ! 213: { ! 214: t1 = p1[plane->type] - plane->dist; ! 215: t2 = p2[plane->type] - plane->dist; ! 216: } ! 217: else ! 218: { ! 219: t1 = DotProduct (plane->normal, p1) - plane->dist; ! 220: t2 = DotProduct (plane->normal, p2) - plane->dist; ! 221: } ! 222: ! 223: #if 1 ! 224: if (t1 >= 0 && t2 >= 0) ! 225: return PM_RecursiveHullCheck (hull, node->children[0], p1f, p2f, p1, p2, trace); ! 226: if (t1 < 0 && t2 < 0) ! 227: return PM_RecursiveHullCheck (hull, node->children[1], p1f, p2f, p1, p2, trace); ! 228: #else ! 229: if ( (t1 >= DIST_EPSILON && t2 >= DIST_EPSILON) || (t2 > t1 && t1 >= 0) ) ! 230: return PM_RecursiveHullCheck (hull, node->children[0], p1f, p2f, p1, p2, trace); ! 231: if ( (t1 <= -DIST_EPSILON && t2 <= -DIST_EPSILON) || (t2 < t1 && t1 <= 0) ) ! 232: return PM_RecursiveHullCheck (hull, node->children[1], p1f, p2f, p1, p2, trace); ! 233: #endif ! 234: ! 235: // put the crosspoint DIST_EPSILON pixels on the near side ! 236: if (t1 < 0) ! 237: frac = (t1 + DIST_EPSILON)/(t1-t2); ! 238: else ! 239: frac = (t1 - DIST_EPSILON)/(t1-t2); ! 240: if (frac < 0) ! 241: frac = 0; ! 242: if (frac > 1) ! 243: frac = 1; ! 244: ! 245: midf = p1f + (p2f - p1f)*frac; ! 246: for (i=0 ; i<3 ; i++) ! 247: mid[i] = p1[i] + frac*(p2[i] - p1[i]); ! 248: ! 249: side = (t1 < 0); ! 250: ! 251: // move up to the node ! 252: if (!PM_RecursiveHullCheck (hull, node->children[side], p1f, midf, p1, mid, trace) ) ! 253: return false; ! 254: ! 255: #ifdef PARANOID ! 256: if (PM_HullPointContents (pm_hullmodel, mid, node->children[side]) ! 257: == CONTENTS_SOLID) ! 258: { ! 259: Con_Printf ("mid PointInHullSolid\n"); ! 260: return false; ! 261: } ! 262: #endif ! 263: ! 264: if (PM_HullPointContents (hull, node->children[side^1], mid) ! 265: != CONTENTS_SOLID) ! 266: // go past the node ! 267: return PM_RecursiveHullCheck (hull, node->children[side^1], midf, p2f, mid, p2, trace); ! 268: ! 269: if (trace->allsolid) ! 270: return false; // never got out of the solid area ! 271: ! 272: //================== ! 273: // the other side of the node is solid, this is the impact point ! 274: //================== ! 275: if (!side) ! 276: { ! 277: VectorCopy (plane->normal, trace->plane.normal); ! 278: trace->plane.dist = plane->dist; ! 279: } ! 280: else ! 281: { ! 282: VectorSubtract (vec3_origin, plane->normal, trace->plane.normal); ! 283: trace->plane.dist = -plane->dist; ! 284: } ! 285: ! 286: while (PM_HullPointContents (hull, hull->firstclipnode, mid) ! 287: == CONTENTS_SOLID) ! 288: { // shouldn't really happen, but does occasionally ! 289: frac -= 0.1; ! 290: if (frac < 0) ! 291: { ! 292: trace->fraction = midf; ! 293: VectorCopy (mid, trace->endpos); ! 294: Con_DPrintf ("backup past 0\n"); ! 295: return false; ! 296: } ! 297: midf = p1f + (p2f - p1f)*frac; ! 298: for (i=0 ; i<3 ; i++) ! 299: mid[i] = p1[i] + frac*(p2[i] - p1[i]); ! 300: } ! 301: ! 302: trace->fraction = midf; ! 303: VectorCopy (mid, trace->endpos); ! 304: ! 305: return false; ! 306: } ! 307: ! 308: ! 309: /* ! 310: ================ ! 311: PM_TestPlayerPosition ! 312: ! 313: Returns false if the given player position is not valid (in solid) ! 314: ================ ! 315: */ ! 316: qboolean PM_TestPlayerPosition (vec3_t pos) ! 317: { ! 318: int i; ! 319: physent_t *pe; ! 320: vec3_t mins, maxs, test; ! 321: hull_t *hull; ! 322: ! 323: for (i=0 ; i< pmove.numphysent ; i++) ! 324: { ! 325: pe = &pmove.physents[i]; ! 326: // get the clipping hull ! 327: if (pe->model) ! 328: hull = &pmove.physents[i].model->hulls[1]; ! 329: else ! 330: { ! 331: VectorSubtract (pe->mins, player_maxs, mins); ! 332: VectorSubtract (pe->maxs, player_mins, maxs); ! 333: hull = PM_HullForBox (mins, maxs); ! 334: } ! 335: ! 336: VectorSubtract (pos, pe->origin, test); ! 337: ! 338: if (PM_HullPointContents (hull, hull->firstclipnode, test) == CONTENTS_SOLID) ! 339: return false; ! 340: } ! 341: ! 342: return true; ! 343: } ! 344: ! 345: /* ! 346: ================ ! 347: PM_PlayerMove ! 348: ================ ! 349: */ ! 350: pmtrace_t PM_PlayerMove (vec3_t start, vec3_t end) ! 351: { ! 352: pmtrace_t trace, total; ! 353: vec3_t offset; ! 354: vec3_t start_l, end_l; ! 355: hull_t *hull; ! 356: int i; ! 357: physent_t *pe; ! 358: vec3_t mins, maxs; ! 359: ! 360: // fill in a default trace ! 361: memset (&total, 0, sizeof(pmtrace_t)); ! 362: total.fraction = 1; ! 363: total.ent = -1; ! 364: VectorCopy (end, total.endpos); ! 365: ! 366: for (i=0 ; i< pmove.numphysent ; i++) ! 367: { ! 368: pe = &pmove.physents[i]; ! 369: // get the clipping hull ! 370: if (pe->model) ! 371: hull = &pmove.physents[i].model->hulls[1]; ! 372: else ! 373: { ! 374: VectorSubtract (pe->mins, player_maxs, mins); ! 375: VectorSubtract (pe->maxs, player_mins, maxs); ! 376: hull = PM_HullForBox (mins, maxs); ! 377: } ! 378: ! 379: // PM_HullForEntity (ent, mins, maxs, offset); ! 380: VectorCopy (pe->origin, offset); ! 381: ! 382: VectorSubtract (start, offset, start_l); ! 383: VectorSubtract (end, offset, end_l); ! 384: ! 385: // fill in a default trace ! 386: memset (&trace, 0, sizeof(pmtrace_t)); ! 387: trace.fraction = 1; ! 388: trace.allsolid = true; ! 389: // trace.startsolid = true; ! 390: VectorCopy (end, trace.endpos); ! 391: ! 392: // trace a line through the apropriate clipping hull ! 393: PM_RecursiveHullCheck (hull, hull->firstclipnode, 0, 1, start_l, end_l, &trace); ! 394: ! 395: if (trace.allsolid) ! 396: trace.startsolid = true; ! 397: if (trace.startsolid) ! 398: trace.fraction = 0; ! 399: ! 400: // did we clip the move? ! 401: if (trace.fraction < total.fraction) ! 402: { ! 403: // fix trace up by the offset ! 404: VectorAdd (trace.endpos, offset, trace.endpos); ! 405: total = trace; ! 406: total.ent = i; ! 407: } ! 408: ! 409: } ! 410: ! 411: return total; ! 412: } ! 413: ! 414:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.