/*
================
CM_TraceToLeaf
================
*/
void CM_TraceToLeaf( traceWork_t *tw, cLeaf_t *leaf, clipMap_t *local ) {
int k;
int brushnum;
cbrush_t *b;
cPatch_t *patch;
// trace line against all brushes in the leaf
for ( k = 0 ; k < leaf->numLeafBrushes ; k++ ) {
brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
b = &local->brushes[brushnum];
if ( b->checkcount == local->checkcount ) {
continue; // already checked this brush in another leaf
}
b->checkcount = local->checkcount;
if ( !(b->contents & tw->contents) ) {
continue;
}
#ifndef BSPC
#ifndef _XBOX // Removing terrain from Xbox
if ( com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
{
// Invalidate the checkcount for terrain as the terrain brush has to be processed
// many times.
b->checkcount--;
CM_TraceThroughTerrain( tw, tw->trace, b );
// If inside a terrain brush don't bother with regular brush collision
continue;
}
#endif
#endif
//if (b->contents & CONTENTS_PLAYERCLIP) continue;
CM_TraceThroughBrush( tw, b );
if ( !tw->trace.fraction ) {
return;
}
}
// trace line against all patches in the leaf
#ifdef BSPC
if (1) {
#else
if ( !cm_noCurves->integer ) {
#endif
for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
#ifdef _XBOX
int index = CM_GetSurfaceIndex(leaf->firstLeafSurface + k);
patch = cmg.surfaces[ index ];
#else
patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
#endif
if ( !patch ) {
continue;
}
if ( patch->checkcount == local->checkcount ) {
continue; // already checked this patch in another leaf
}
patch->checkcount = local->checkcount;
if ( !(patch->contents & tw->contents) ) {
continue;
}
CM_TraceThroughPatch( tw, patch );
if ( !tw->trace.fraction ) {
return;
}
}
}
}
//=========================================================================================
/*
==================
CM_TraceThroughTree
Traverse all the contacted leafs from the start to the end position.
If the trace is a point, they will be exactly in order, but for larger
trace volumes it is possible to hit something in a later leaf with
a smaller intercept fraction.
==================
*/
void CM_TraceThroughTree( traceWork_t *tw, clipMap_t *local, int num, float p1f, float p2f, vec3_t p1, vec3_t p2) {
cNode_t *node;
cplane_t *plane;
float t1, t2, offset;
float frac, frac2;
float idist;
vec3_t mid;
int side;
float midf;
#ifdef _XBOX
if(!tr.world) {
return;
}
#endif
if (tw->trace.fraction <= p1f) {
return; // already hit something nearer
}
// if < 0, we are in a leaf node
if (num < 0) {
CM_TraceToLeaf( tw, &local->leafs[-1-num], local );
return;
}
//
// find the point distances to the seperating plane
// and the offset for the size of the box
//
node = local->nodes + num;
#ifdef _XBOX
plane = cmg.planes + tr.world->nodes[num].planeNum;
#else
plane = node->plane;
#endif
#if 0
// uncomment this to test against every leaf in the world for debugging
CM_TraceThroughTree( tw, local, node->children[0], p1f, p2f, p1, p2 );
CM_TraceThroughTree( tw, local, node->children[1], p1f, p2f, p1, p2 );
return;
#endif
// adjust the plane distance apropriately for mins/maxs
if ( plane->type < 3 ) {
t1 = p1[plane->type] - plane->dist;
t2 = p2[plane->type] - plane->dist;
offset = tw->extents[plane->type];
} else {
t1 = DotProduct (plane->normal, p1) - plane->dist;
t2 = DotProduct (plane->normal, p2) - plane->dist;
if ( tw->isPoint ) {
offset = 0;
} else {
// an axial brush right behind a slanted bsp plane
// will poke through when expanded, so adjust
// by sqrt(3)
offset = fabs(tw->extents[0]*plane->normal[0]) +
fabs(tw->extents[1]*plane->normal[1]) +
fabs(tw->extents[2]*plane->normal[2]);
offset *= 2;
#if 0
CM_TraceThroughTree( tw, local, node->children[0], p1f, p2f, p1, p2 );
CM_TraceThroughTree( tw, local, node->children[1], p1f, p2f, p1, p2 );
return;
#endif
offset = tw->maxOffset;
offset = 2048;
}
}
// see which sides we need to consider
if ( t1 >= offset + 1 && t2 >= offset + 1 ) {
CM_TraceThroughTree( tw, local, node->children[0], p1f, p2f, p1, p2 );
return;
}
if ( t1 < -offset - 1 && t2 < -offset - 1 ) {
CM_TraceThroughTree( tw, local, node->children[1], p1f, p2f, p1, p2 );
return;
}
// put the crosspoint SURFACE_CLIP_EPSILON pixels on the near side
if ( t1 < t2 ) {
idist = 1.0/(t1-t2);
side = 1;
frac2 = (t1 + offset + SURFACE_CLIP_EPSILON)*idist;
frac = (t1 - offset + SURFACE_CLIP_EPSILON)*idist;
} else if (t1 > t2) {
idist = 1.0/(t1-t2);
side = 0;
frac2 = (t1 - offset - SURFACE_CLIP_EPSILON)*idist;
frac = (t1 + offset + SURFACE_CLIP_EPSILON)*idist;
} else {
side = 0;
frac = 1;
frac2 = 0;
}
// move up to the node
if ( frac < 0 ) {
frac = 0;
}
if ( frac > 1 ) {
frac = 1;
}
midf = p1f + (p2f - p1f)*frac;
mid[0] = p1[0] + frac*(p2[0] - p1[0]);
mid[1] = p1[1] + frac*(p2[1] - p1[1]);
mid[2] = p1[2] + frac*(p2[2] - p1[2]);
CM_TraceThroughTree( tw, local, node->children[side], p1f, midf, p1, mid );
// go past the node
if ( frac2 < 0 ) {
frac2 = 0;
}
if ( frac2 > 1 ) {
frac2 = 1;
}
midf = p1f + (p2f - p1f)*frac2;
mid[0] = p1[0] + frac2*(p2[0] - p1[0]);
mid[1] = p1[1] + frac2*(p2[1] - p1[1]);
mid[2] = p1[2] + frac2*(p2[2] - p1[2]);
CM_TraceThroughTree( tw, local, node->children[side^1], midf, p2f, mid, p2 );
}
/*
================
CM_TestInLeaf
================
*/
void CM_TestInLeaf( traceWork_t *tw, cLeaf_t *leaf, clipMap_t *local ) {
int k;
int brushnum;
cbrush_t *b;
cPatch_t *patch;
// test box position against all brushes in the leaf
for (k=0 ; k<leaf->numLeafBrushes ; k++) {
brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
b = &local->brushes[brushnum];
if (b->checkcount == local->checkcount) {
continue; // already checked this brush in another leaf
}
b->checkcount = local->checkcount;
if ( !(b->contents & tw->contents)) {
continue;
}
#ifndef BSPC
#ifndef _XBOX // Removing terrain from Xbox
if (com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
{
// Invalidate the checkcount for terrain as the terrain brush has to be processed
// many times.
b->checkcount--;
CM_TraceThroughTerrain( tw, tw->trace, b );
// If inside a terrain brush don't bother with regular brush collision
continue;
}
#endif
#endif
CM_TestBoxInBrush( tw, b );
if ( tw->trace.allsolid ) {
return;
}
}
// test against all patches
#ifdef BSPC
if (1) {
#else
if ( !cm_noCurves->integer ) {
#endif //BSPC
for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
#ifdef _XBOX
int index = CM_GetSurfaceIndex(leaf->firstLeafSurface + k);
patch = cmg.surfaces[ index ];
#else
patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
#endif
if ( !patch ) {
continue;
}
if ( patch->checkcount == local->checkcount ) {
continue; // already checked this brush in another leaf
}
patch->checkcount = local->checkcount;
if ( !(patch->contents & tw->contents)) {
continue;
}
if ( CM_PositionTestInPatchCollide( tw, patch->pc ) ) {
tw->trace.startsolid = tw->trace.allsolid = qtrue;
tw->trace.fraction = 0;
tw->trace.contents = patch->contents;
return;
}
}
}
}
/*
==================
CM_PositionTest
==================
*/
#define MAX_POSITION_LEAFS 1024
void CM_PositionTest( traceWork_t *tw ) {
int leafs[MAX_POSITION_LEAFS];
int i;
leafList_t ll;
// identify the leafs we are touching
VectorAdd( tw->start, tw->size[0], ll.bounds[0] );
VectorAdd( tw->start, tw->size[1], ll.bounds[1] );
for (i=0 ; i<3 ; i++) {
ll.bounds[0][i] -= 1;
ll.bounds[1][i] += 1;
}
ll.count = 0;
ll.maxcount = MAX_POSITION_LEAFS;
ll.list = leafs;
ll.storeLeafs = CM_StoreLeafs;
ll.lastLeaf = 0;
ll.overflowed = qfalse;
cmg.checkcount++;
CM_BoxLeafnums_r( &ll, 0 );
cmg.checkcount++;
// test the contents of the leafs
for (i=0 ; i < ll.count ; i++) {
CM_TestInLeaf( tw, &cmg.leafs[leafs[i]], &cmg );
if ( tw->trace.allsolid ) {
break;
}
}
}
/*
================
CM_TestInLeaf
================
*/
void CM_TestInLeaf( traceWork_t *tw, trace_t &trace, cLeaf_t *leaf, clipMap_t *local )
{
int k;
int brushnum;
cbrush_t *b;
cPatch_t *patch;
// test box position against all brushes in the leaf
for (k=0 ; k<leaf->numLeafBrushes ; k++) {
brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
b = &local->brushes[brushnum];
if (b->checkcount == local->checkcount) {
continue; // already checked this brush in another leaf
}
b->checkcount = local->checkcount;
if ( !(b->contents & tw->contents)) {
continue;
}
#ifndef BSPC
if (com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
{
// Invalidate the checkcount for terrain as the terrain brush has to be processed
// many times.
b->checkcount--;
CM_TraceThroughTerrain( tw, trace, b );
// If inside a terrain brush don't bother with regular brush collision
continue;
}
#endif
CM_TestBoxInBrush( tw, trace, b );
if ( trace.allsolid ) {
return;
}
}
// test against all patches
#ifdef BSPC
if (1) {
#else
if ( !cm_noCurves->integer ) {
#endif //BSPC
for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
if ( !patch ) {
continue;
}
if ( patch->checkcount == local->checkcount ) {
continue; // already checked this brush in another leaf
}
patch->checkcount = local->checkcount;
if ( !(patch->contents & tw->contents)) {
continue;
}
if ( CM_PositionTestInPatchCollide( tw, patch->pc ) ) {
trace.startsolid = trace.allsolid = qtrue;
trace.fraction = 0;
trace.contents = patch->contents;
return;
}
}
}
}
/*
==================
CM_TestCapsuleInCapsule
capsule inside capsule check
==================
*/
void CM_TestCapsuleInCapsule( traceWork_t *tw, trace_t &trace, clipHandle_t model ) {
int i;
vec3_t mins, maxs;
vec3_t top, bottom;
vec3_t p1, p2, tmp;
vec3_t offset, symetricSize[2];
float radius, halfwidth, halfheight, offs, r;
CM_ModelBounds(model, mins, maxs);
VectorAdd(tw->start, tw->sphere.offset, top);
VectorSubtract(tw->start, tw->sphere.offset, bottom);
for ( i = 0 ; i < 3 ; i++ ) {
offset[i] = ( mins[i] + maxs[i] ) * 0.5;
symetricSize[0][i] = mins[i] - offset[i];
symetricSize[1][i] = maxs[i] - offset[i];
}
halfwidth = symetricSize[ 1 ][ 0 ];
halfheight = symetricSize[ 1 ][ 2 ];
radius = ( halfwidth > halfheight ) ? halfheight : halfwidth;
offs = halfheight - radius;
r = Square(tw->sphere.radius + radius);
// check if any of the spheres overlap
VectorCopy(offset, p1);
p1[2] += offs;
VectorSubtract(p1, top, tmp);
if ( VectorLengthSquared(tmp) < r ) {
trace.startsolid = trace.allsolid = qtrue;
trace.fraction = 0;
}
VectorSubtract(p1, bottom, tmp);
if ( VectorLengthSquared(tmp) < r ) {
trace.startsolid = trace.allsolid = qtrue;
trace.fraction = 0;
}
VectorCopy(offset, p2);
p2[2] -= offs;
VectorSubtract(p2, top, tmp);
if ( VectorLengthSquared(tmp) < r ) {
trace.startsolid = trace.allsolid = qtrue;
trace.fraction = 0;
}
VectorSubtract(p2, bottom, tmp);
if ( VectorLengthSquared(tmp) < r ) {
trace.startsolid = trace.allsolid = qtrue;
trace.fraction = 0;
}
// if between cylinder up and lower bounds
if ( (top[2] >= p1[2] && top[2] <= p2[2]) ||
(bottom[2] >= p1[2] && bottom[2] <= p2[2]) ) {
// 2d coordinates
top[2] = p1[2] = 0;
// if the cylinders overlap
VectorSubtract(top, p1, tmp);
if ( VectorLengthSquared(tmp) < r ) {
trace.startsolid = trace.allsolid = qtrue;
trace.fraction = 0;
}
}
}
/*
================
CM_TraceThroughLeaf
================
*/
void CM_TraceThroughLeaf( traceWork_t *tw, trace_t &trace, clipMap_t *local, cLeaf_t *leaf ) {
int k;
int brushnum;
cbrush_t *b;
cPatch_t *patch;
// trace line against all brushes in the leaf
for ( k = 0 ; k < leaf->numLeafBrushes ; k++ ) {
brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
b = &local->brushes[brushnum];
if ( b->checkcount == local->checkcount ) {
continue; // already checked this brush in another leaf
}
b->checkcount = local->checkcount;
if ( !(b->contents & tw->contents) ) {
continue;
}
#ifndef BSPC
if (com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
{
// Invalidate the checkcount for terrain as the terrain brush has to be processed
// many times.
b->checkcount--;
CM_TraceThroughTerrain( tw, trace, b );
}
else
#endif
{
CM_TraceThroughBrush( tw, trace, b, false );
}
if ( !trace.fraction ) {
return;
}
}
// trace line against all patches in the leaf
#ifdef BSPC
if (1) {
#else
if ( !cm_noCurves->integer ) {
#endif
for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
if ( !patch ) {
continue;
}
if ( patch->checkcount == local->checkcount ) {
continue; // already checked this patch in another leaf
}
patch->checkcount = local->checkcount;
if ( !(patch->contents & tw->contents) ) {
continue;
}
CM_TraceThroughPatch( tw, trace, patch );
if ( !trace.fraction ) {
return;
}
}
}
}
#define RADIUS_EPSILON 1.0f
/*
================
CM_TraceThroughSphere
get the first intersection of the ray with the sphere
================
*/
void CM_TraceThroughSphere( traceWork_t *tw, trace_t &trace, vec3_t origin, float radius, vec3_t start, vec3_t end ) {
float l1, l2, length, scale, fraction;
float /*a, */b, c, d, sqrtd;
vec3_t v1, dir, intersection;
// if inside the sphere
VectorSubtract(start, origin, dir);
l1 = VectorLengthSquared(dir);
if (l1 < Square(radius)) {
trace.fraction = 0;
trace.startsolid = qtrue;
// test for allsolid
VectorSubtract(end, origin, dir);
l1 = VectorLengthSquared(dir);
if (l1 < Square(radius)) {
trace.allsolid = qtrue;
}
return;
}
//
VectorSubtract(end, start, dir);
length = VectorNormalize(dir);
//
l1 = CM_DistanceFromLineSquared(origin, start, end, dir);
VectorSubtract(end, origin, v1);
l2 = VectorLengthSquared(v1);
// if no intersection with the sphere and the end point is at least an epsilon away
if (l1 >= Square(radius) && l2 > Square(radius+SURFACE_CLIP_EPSILON)) {
return;
}
//
// | origin - (start + t * dir) | = radius
// a = dir[0]^2 + dir[1]^2 + dir[2]^2;
// b = 2 * (dir[0] * (start[0] - origin[0]) + dir[1] * (start[1] - origin[1]) + dir[2] * (start[2] - origin[2]));
// c = (start[0] - origin[0])^2 + (start[1] - origin[1])^2 + (start[2] - origin[2])^2 - radius^2;
//
VectorSubtract(start, origin, v1);
// dir is normalized so a = 1
//a = 1.0f;//dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2];
b = 2.0f * (dir[0] * v1[0] + dir[1] * v1[1] + dir[2] * v1[2]);
c = v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] - (radius+RADIUS_EPSILON) * (radius+RADIUS_EPSILON);
d = b * b - 4.0f * c;// * a;
if (d > 0) {
sqrtd = sqrtf(d);
// = (- b + sqrtd) * 0.5f; // / (2.0f * a);
fraction = (- b - sqrtd) * 0.5f; // / (2.0f * a);
//
if (fraction < 0) {
fraction = 0;
}
else {
fraction /= length;
}
if ( fraction < trace.fraction ) {
trace.fraction = fraction;
VectorSubtract(end, start, dir);
VectorMA(start, fraction, dir, intersection);
VectorSubtract(intersection, origin, dir);
#ifdef CAPSULE_DEBUG
l2 = VectorLength(dir);
if (l2 < radius) {
int bah = 1;
}
#endif
scale = 1 / (radius+RADIUS_EPSILON);
VectorScale(dir, scale, dir);
VectorCopy(dir, trace.plane.normal);
VectorAdd( tw->modelOrigin, intersection, intersection);
trace.plane.dist = DotProduct(trace.plane.normal, intersection);
trace.contents = CONTENTS_BODY;
}
}
else if (d == 0) {
//t1 = (- b ) / 2;
// slide along the sphere
}
// no intersection at all
}
/*
==================
CM_Trace
==================
*/
void CM_Trace( trace_t *trace, const vec3_t start, const vec3_t end,
const vec3_t mins, const vec3_t maxs,
clipHandle_t model, const vec3_t origin, int brushmask, int capsule, sphere_t *sphere ) {
int i;
traceWork_t tw;
vec3_t offset;
cmodel_t *cmod;
clipMap_t *local = 0;
cmod = CM_ClipHandleToModel( model, &local );
local->checkcount++; // for multi-check avoidance
c_traces++; // for statistics, may be zeroed
// fill in a default trace
Com_Memset( &tw, 0, sizeof(tw) );
memset(trace, 0, sizeof(*trace));
trace->fraction = 1; // assume it goes the entire distance until shown otherwise
VectorCopy(origin, tw.modelOrigin);
if (!local->numNodes) {
return; // map not loaded, shouldn't happen
}
// allow NULL to be passed in for 0,0,0
if ( !mins ) {
mins = vec3_origin;
}
if ( !maxs ) {
maxs = vec3_origin;
}
// set basic parms
tw.contents = brushmask;
// adjust so that mins and maxs are always symetric, which
// avoids some complications with plane expanding of rotated
// bmodels
for ( i = 0 ; i < 3 ; i++ ) {
offset[i] = ( mins[i] + maxs[i] ) * 0.5;
tw.size[0][i] = mins[i] - offset[i];
tw.size[1][i] = maxs[i] - offset[i];
tw.start[i] = start[i] + offset[i];
tw.end[i] = end[i] + offset[i];
}
// if a sphere is already specified
if ( sphere ) {
tw.sphere = *sphere;
}
else {
tw.sphere.use = (qboolean)capsule;
tw.sphere.radius = ( tw.size[1][0] > tw.size[1][2] ) ? tw.size[1][2]: tw.size[1][0];
tw.sphere.halfheight = tw.size[1][2];
VectorSet( tw.sphere.offset, 0, 0, tw.size[1][2] - tw.sphere.radius );
}
tw.maxOffset = tw.size[1][0] + tw.size[1][1] + tw.size[1][2];
// tw.offsets[signbits] = vector to appropriately corner from origin
tw.offsets[0][0] = tw.size[0][0];
tw.offsets[0][1] = tw.size[0][1];
tw.offsets[0][2] = tw.size[0][2];
tw.offsets[1][0] = tw.size[1][0];
tw.offsets[1][1] = tw.size[0][1];
tw.offsets[1][2] = tw.size[0][2];
tw.offsets[2][0] = tw.size[0][0];
tw.offsets[2][1] = tw.size[1][1];
tw.offsets[2][2] = tw.size[0][2];
tw.offsets[3][0] = tw.size[1][0];
tw.offsets[3][1] = tw.size[1][1];
tw.offsets[3][2] = tw.size[0][2];
tw.offsets[4][0] = tw.size[0][0];
tw.offsets[4][1] = tw.size[0][1];
tw.offsets[4][2] = tw.size[1][2];
tw.offsets[5][0] = tw.size[1][0];
tw.offsets[5][1] = tw.size[0][1];
tw.offsets[5][2] = tw.size[1][2];
tw.offsets[6][0] = tw.size[0][0];
tw.offsets[6][1] = tw.size[1][1];
tw.offsets[6][2] = tw.size[1][2];
tw.offsets[7][0] = tw.size[1][0];
tw.offsets[7][1] = tw.size[1][1];
tw.offsets[7][2] = tw.size[1][2];
//
// calculate bounds
//
if ( tw.sphere.use ) {
for ( i = 0 ; i < 3 ; i++ ) {
if ( tw.start[i] < tw.end[i] ) {
tw.bounds[0][i] = tw.start[i] - fabs(tw.sphere.offset[i]) - tw.sphere.radius;
tw.bounds[1][i] = tw.end[i] + fabs(tw.sphere.offset[i]) + tw.sphere.radius;
} else {
tw.bounds[0][i] = tw.end[i] - fabs(tw.sphere.offset[i]) - tw.sphere.radius;
tw.bounds[1][i] = tw.start[i] + fabs(tw.sphere.offset[i]) + tw.sphere.radius;
}
}
}
else {
for ( i = 0 ; i < 3 ; i++ ) {
if ( tw.start[i] < tw.end[i] ) {
tw.bounds[0][i] = tw.start[i] + tw.size[0][i];
tw.bounds[1][i] = tw.end[i] + tw.size[1][i];
} else {
tw.bounds[0][i] = tw.end[i] + tw.size[0][i];
tw.bounds[1][i] = tw.start[i] + tw.size[1][i];
}
}
}
//
// check for position test special case
//
if (start[0] == end[0] && start[1] == end[1] && start[2] == end[2] &&
tw.size[0][0] == 0 && tw.size[0][1] == 0 && tw.size[0][2] == 0)
{
if ( model && cmod->firstNode == -1)
{
#ifdef ALWAYS_BBOX_VS_BBOX // bk010201 - FIXME - compile time flag?
if ( model == BOX_MODEL_HANDLE || model == CAPSULE_MODEL_HANDLE)
{
tw.sphere.use = qfalse;
CM_TestInLeaf( &tw, &cmod->leaf );
}
else
#elif defined(ALWAYS_CAPSULE_VS_CAPSULE)
if ( model == BOX_MODEL_HANDLE || model == CAPSULE_MODEL_HANDLE)
{
CM_TestCapsuleInCapsule( &tw, model );
}
else
#endif
if ( model == CAPSULE_MODEL_HANDLE )
{
if ( tw.sphere.use )
{
CM_TestCapsuleInCapsule( &tw, *trace, model );
}
else
{
CM_TestBoundingBoxInCapsule( &tw, *trace, model );
}
}
else
{
CM_TestInLeaf( &tw, *trace, &cmod->leaf, local );
}
}
#ifdef TEST_TERRAIN_PHYSICS
else if (cmg.landScape && !model && !cmod->firstNode)
{
CM_TraceThroughTerrain( &tw, *trace, cmg.landScape );
}
#endif // #ifdef TEST_TERRAIN_PHYSICS
else if (cmod->firstNode == -1)
{
CM_PositionTest( &tw, *trace );
}
else
{
CM_TraceThroughTree( &tw, *trace, local, cmod->firstNode, 0, 1, tw.start, tw.end );
}
}
else
{
//
// check for point special case
//
if ( tw.size[0][0] == 0 && tw.size[0][1] == 0 && tw.size[0][2] == 0 )
{
tw.isPoint = qtrue;
VectorClear( tw.extents );
}
else
{
tw.isPoint = qfalse;
tw.extents[0] = tw.size[1][0];
tw.extents[1] = tw.size[1][1];
tw.extents[2] = tw.size[1][2];
}
//
// general sweeping through world
//
if ( model && cmod->firstNode == -1)
{
#ifdef ALWAYS_BBOX_VS_BBOX
if ( model == BOX_MODEL_HANDLE || model == CAPSULE_MODEL_HANDLE)
{
tw.sphere.use = qfalse;
CM_TraceThroughLeaf( &tw, &cmod->leaf );
}
else
#elif defined(ALWAYS_CAPSULE_VS_CAPSULE)
if ( model == BOX_MODEL_HANDLE || model == CAPSULE_MODEL_HANDLE)
{
CM_TraceCapsuleThroughCapsule( &tw, model );
}
else
#endif
if ( model == CAPSULE_MODEL_HANDLE )
{
if ( tw.sphere.use )
{
CM_TraceCapsuleThroughCapsule( &tw, *trace, model );
}
else
{
CM_TraceBoundingBoxThroughCapsule( &tw, *trace, model );
}
}
else
{
CM_TraceThroughLeaf( &tw, *trace, local, &cmod->leaf );
}
}
#ifdef TEST_TERRAIN_PHYSICS
else if (cmg.landScape && !model && !cmod->firstNode)
{
CM_TraceThroughTerrain( &tw, *trace, cmg.landScape );
}
#endif // #ifdef TEST_TERRAIN_PHYSICS
else
{
CM_TraceThroughTree( &tw, *trace, local, cmod->firstNode, 0, 1, tw.start, tw.end );
}
}
// generate endpos from the original, unmodified start/end
if ( trace->fraction == 1 ) {
VectorCopy (end, trace->endpos);
} else {
for ( i=0 ; i<3 ; i++ ) {
trace->endpos[i] = start[i] + trace->fraction * (end[i] - start[i]);
}
}
// If allsolid is set (was entirely inside something solid), the plane is not valid.
// If fraction == 1.0, we never hit anything, and thus the plane is not valid.
// Otherwise, the normal on the plane should have unit length
assert(trace->allsolid ||
trace->fraction == 1.0 ||
VectorLengthSquared(trace->plane.normal) > 0.9999);
}