Paranoia2/pm_shared/trace.cpp

568 lines
15 KiB
C++
Raw Normal View History

2020-08-31 18:50:41 +02:00
/*
trace.cpp - trace triangle meshes
Copyright (C) 2012 Uncle Mike
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#define WIN32_LEAN_AND_MEAN
#include "windows.h"
#include <alert.h>
#include "vector.h"
#include "matrix.h"
#include "const.h"
#include "com_model.h"
#include "trace.h"
#include "mathlib.h"
#ifdef CLIENT_DLL
#include "cl_dll.h"
#include "render_api.h"
#else
#include "edict.h"
#include "eiface.h"
#include "physcallback.h"
#endif
#include "enginecallback.h"
void TraceMesh :: SetTraceMesh( mmesh_t *cached_mesh, areanode_t *tree, int modelindex )
{
m_pModel = (model_t *)MODEL_HANDLE( modelindex );
mesh = cached_mesh;
areanodes = tree;
}
mstudiomaterial_t *TraceMesh :: GetMaterialForFacet( const mfacet_t *facet )
{
if( !m_pModel ) return NULL;
mstudiomaterial_t *materials = m_pModel->materials;
studiohdr_t *phdr = (studiohdr_t *)m_pModel->cache.data;
if( !materials || !phdr ) return NULL;
short *pskinref = (short *)((byte *)phdr + phdr->skinindex);
if( m_iSkin > 0 && m_iSkin < phdr->numskinfamilies )
pskinref += (m_iSkin * phdr->numskinref);
return &materials[pskinref[facet->skinref]];
}
mstudiotexture_t *TraceMesh :: GetTextureForFacet( const mfacet_t *facet )
{
mstudiomaterial_t *material = GetMaterialForFacet( facet );
if( material )
return material->pSource;
return NULL;
}
bool TraceMesh :: IsTrans( const mfacet_t *facet )
{
mstudiotexture_t *texture = GetTextureForFacet( facet );
return (texture && FBitSet( texture->flags, STUDIO_NF_MASKED ));
}
void CheckAngles( Vector &angles )
{
// blackmagic to avoid invalid signbits state
if( angles.y != 0.0f && fmod( angles.y, 45.0f ) == 0.0f )
angles.y += 0.01f;
}
void TraceMesh :: SetupTrace( const Vector &start, const Vector &mins, const Vector &maxs, const Vector &end, trace_t *tr )
{
trace = tr;
memset( trace, 0, sizeof( *trace ));
trace->fraction = m_flRealFraction = 1.0f;
Vector lmins = mins, lmaxs = maxs, offset;
float t, halfwidth, halfheight;
int i, total_signbits = 0;
m_vecSrcStart = start;
m_vecSrcEnd = end;
// 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.5f;
lmins[i] = mins[i] - offset[i];
lmaxs[i] = maxs[i] - offset[i];
m_vecSrcStart[i] = start[i] + offset[i];
m_vecSrcEnd[i] = end[i] + offset[i];
}
// HACKHACK: shrink bbox a bit...
if( mins != maxs )
ExpandBounds( lmins, lmaxs, -(1.0f/8.0f));
halfwidth = lmaxs[0];
halfheight = lmaxs[2];
bUseCapsule = (offset == g_vecZero) ? false : true;
m_flSphereRadius = ( halfwidth > halfheight ) ? halfheight : halfwidth;
t = halfheight - m_flSphereRadius;
CheckAngles( m_vecAngles );
// inverse pitch because of stupid quake bug
m_transform = matrix4x4( m_vecOrigin, Vector( -m_vecAngles.x, m_vecAngles.y, m_vecAngles.z ), m_vecScale ).InvertFull();
m_vecStart = m_transform.VectorTransform( m_vecSrcStart );
m_vecEnd = m_transform.VectorTransform( m_vecSrcEnd );
if( mins != maxs )
{
// compute a full bounding box
for( i = 0; i < 8; i++ )
{
Vector p1, p2;
p1.x = ( i & 1 ) ? lmins[0] : lmaxs[0];
p1.y = ( i & 2 ) ? lmins[1] : lmaxs[1];
p1.z = ( i & 4 ) ? lmins[2] : lmaxs[2];
p2 = m_transform.VectorRotate( p1 );
// NOTE: this is looks silly but it works for some reasons:
// bbox are symetric and stored in local space
// signbits are detected normals for bbox side tests
int j = SignbitsForPlane( -p2 );
m_vecOffsets[j] = p2;
total_signbits += j;
}
if( total_signbits != 28 )
{
ALERT( at_error, "total signbits %d != 28 (mins %g %g %g) maxs( %g %g %g)\n",
total_signbits, lmins.x, lmins.y, lmins.z, lmaxs.x, lmaxs.y, lmaxs.z );
ALERT( at_error, "rotated angles %g %g %g\n", -m_vecAngles.x, m_vecAngles.y, m_vecAngles.z );
for( i = 0; i < 8; i++ )
{
Vector p1, p2;
p1.x = ( i & 1 ) ? lmins[0] : lmaxs[0];
p1.y = ( i & 2 ) ? lmins[1] : lmaxs[1];
p1.z = ( i & 4 ) ? lmins[2] : lmaxs[2];
p2 = m_transform.VectorRotate( p1 );
// NOTE: this is looks silly but it works for some reasons:
// bbox are symetric and stored in local space
// signbits are detected normals for bbox side tests
int j = SignbitsForPlane( -p2 );
Msg( "#%i (%g %g %g) -> (%g %g %g), signbits %d\n", i, p1.x, p1.y, p1.z, p2.x, p2.y, p2.z, j );
}
}
}
else
{
// just reset offsets
memset( m_vecOffsets, 0, sizeof( m_vecOffsets ));
}
// rotated sphere offset for capsule
m_flSphereOffset[0] = m_transform[2][0] * t;
m_flSphereOffset[1] = -m_transform[2][1] * t;
m_flSphereOffset[2] = m_transform[2][2] * t;
// now calculate the local bbox
ClearBounds( lmins, lmaxs );
for( i = 0; i < 8; i++ )
AddPointToBounds( m_vecOffsets[i], lmins, lmaxs );
material = NULL;
m_vecTraceDirection = m_vecEnd - m_vecStart;
m_flTraceDistance = m_vecTraceDirection.Length();
m_vecTraceDirection = m_vecTraceDirection.Normalize();
// build a bounding box of the entire move
ClearBounds( m_vecAbsMins, m_vecAbsMaxs );
AddPointToBounds( m_vecStart + lmins, m_vecAbsMins, m_vecAbsMaxs );
AddPointToBounds( m_vecStart + lmaxs, m_vecAbsMins, m_vecAbsMaxs );
AddPointToBounds( m_vecEnd + lmins, m_vecAbsMins, m_vecAbsMaxs );
AddPointToBounds( m_vecEnd + lmaxs, m_vecAbsMins, m_vecAbsMaxs );
// spread min\max by a pixel
for( i = 0; i < 3; i++ )
{
m_vecAbsMins[i] -= 1.0f;
m_vecAbsMaxs[i] += 1.0f;
}
// use untransformed values to avoid FP rounding errors
if( mins == maxs )
bIsTraceLine = true;
else bIsTraceLine = false;
if( start == end )
bIsTestPosition = true;
else bIsTestPosition = false;
}
void TraceMesh :: ClipBoxToFacet( mfacet_t *facet )
{
mplane_t *p, *clipplane;
float enterfrac, leavefrac, distfrac;
mstudiotexture_t *ptexture;
bool getout, startout;
Vector startp, endp;
float d, d1, d2, f;
if( !facet->numplanes )
return;
ptexture = GetTextureForFacet( facet );
if( !bIsTraceLine && ptexture )
{
if( FBitSet( ptexture->flags, STUDIO_NF_MASKED ) && !FBitSet( ptexture->flags, STUDIO_NF_ALPHASOLID ))
return;
}
enterfrac = -1.0f;
leavefrac = 1.0f;
clipplane = NULL;
checkcount++;
getout = false;
startout = false;
for( int i = 0; i < facet->numplanes; i++ )
{
p = &mesh->planes[facet->indices[i]];
if( bUseCapsule )
{
// adjust the plane distance apropriately for radius
float dist = p->dist + m_flSphereRadius;
// find the closest point on the capsule to the plane
float t = DotProduct( p->normal, m_flSphereOffset );
if( t > 0.0f )
{
startp = m_vecStart - m_flSphereOffset;
endp = m_vecEnd - m_flSphereOffset;
}
else
{
startp = m_vecStart + m_flSphereOffset;
endp = m_vecEnd + m_flSphereOffset;
}
d1 = DotProduct( startp, p->normal ) - dist;
d2 = DotProduct( endp, p->normal ) - dist;
}
else
{
// adjust the plane distance apropriately for mins/maxs
float dist = p->dist - DotProduct( m_vecOffsets[p->signbits], p->normal );
d1 = DotProduct( m_vecStart, p->normal ) - dist;
d2 = DotProduct( m_vecEnd, p->normal ) - dist;
}
if( d2 > 0.0f ) getout = true; // endpoint is not in solid
if( d1 > 0.0f ) startout = true;
// if completely in front of face, no intersection
if( d1 > 0 && d2 >= d1 )
return;
if( d1 <= 0 && d2 <= 0 )
continue;
// crosses face
d = 1.0f / (d1 - d2);
f = d1 * d;
if( d > 0.0f )
{
// enter
if( f > enterfrac )
{
distfrac = d;
enterfrac = f;
clipplane = p;
}
}
else if( d < 0.0f )
{
// leave
if( f < leavefrac )
leavefrac = f;
}
}
if( !startout )
{
// original point was inside brush
trace->startsolid = true;
if( !getout ) trace->allsolid = true;
return;
}
if( enterfrac - FRAC_EPSILON <= leavefrac )
{
if( enterfrac > -1.0f && enterfrac < m_flRealFraction )
{
if( enterfrac < 0 ) enterfrac = 0;
m_flRealFraction = enterfrac;
trace->plane.normal = clipplane->normal;
trace->plane.dist = clipplane->dist;
trace->fraction = enterfrac - DIST_EPSILON * distfrac;
material = GetMaterialForFacet( facet ); // material was hit
}
}
}
void TraceMesh :: TestBoxInFacet( mfacet_t *facet )
{
mstudiotexture_t *ptexture;
Vector startp;
float d1;
mplane_t *p;
if( !facet->numplanes )
return;
ptexture = GetTextureForFacet( facet );
if( !bIsTraceLine && ptexture )
{
if( FBitSet( ptexture->flags, STUDIO_NF_MASKED ) && !FBitSet( ptexture->flags, STUDIO_NF_ALPHASOLID ))
return;
}
checkcount++;
for( int i = 0; i < facet->numplanes; i++ )
{
p = &mesh->planes[facet->indices[i]];
if( bUseCapsule )
{
// adjust the plane distance apropriately for radius
float dist = p->dist + m_flSphereRadius;
// find the closest point on the capsule to the plane
float t = DotProduct( p->normal, m_flSphereOffset );
if( t > 0.0f ) startp = m_vecStart - m_flSphereOffset;
else startp = m_vecStart + m_flSphereOffset;
d1 = DotProduct( startp, p->normal ) - dist;
}
else
{
// adjust the plane distance apropriately for mins/maxs
float dist = p->dist - DotProduct( m_vecOffsets[p->signbits], p->normal );
d1 = DotProduct( m_vecStart, p->normal ) - dist;
}
// if completely in front of face, no intersection
if( d1 > 0 ) return;
}
// inside this brush
m_flRealFraction = 0.0f;
trace->startsolid = true;
trace->allsolid = true;
}
bool TraceMesh :: ClipRayToFacet( const mfacet_t *facet )
{
// begin calculating determinant - also used to calculate u parameter
Vector pvec = CrossProduct( m_vecTraceDirection, facet->edge2 );
// if determinant is near zero, trace lies in plane of triangle
float det = DotProduct( facet->edge1, pvec );
// the non-culling branch
if( fabs( det ) < COPLANAR_EPSILON )
return false;
checkcount++;
Vector n = CrossProduct( facet->edge2, facet->edge1 );
Vector p = m_vecEnd - m_vecStart;
// calculate distance from first vertex to ray origin
Vector tvec = m_vecStart - facet->triangle[0].point;
float d1 = -DotProduct( n, tvec );
float d2 = DotProduct( n, p );
if( fabs( d2 ) < 0.0001 )
return false;
// get intersect point of ray with triangle plane
float frac = d1 / d2;
if( frac <= 0.0f ) return false;
if( frac > m_flRealFraction )
return false; // we have hit something earlier
float invDet = 1.0f / det;
bool force_solid = false;
// calculate u parameter and test bounds
float u = DotProduct( tvec, pvec ) * invDet;
if( u < -BARY_EPSILON || u > ( 1.0f + BARY_EPSILON ))
return false;
// prepare to test v parameter
Vector qvec = CrossProduct( tvec, facet->edge1 );
// calculate v parameter and test bounds
float v = DotProduct( m_vecTraceDirection, qvec ) * invDet;
if( v < -BARY_EPSILON || ( u + v ) > ( 1.0f + BARY_EPSILON ))
return false;
// calculate t (depth)
float depth = DotProduct( facet->edge2, qvec ) * invDet;
if( depth <= 0.001f || depth >= m_flTraceDistance )
return false;
n = n.Normalize();
mstudiotexture_t *ptexture = GetTextureForFacet( facet );
if( ptexture && !FBitSet( ptexture->flags, STUDIO_NF_MASKED ))
force_solid = true;
#ifdef CLIENT_DLL
// FIXME: how to handle trace flags on the client?
#else
if( FBitSet( gpGlobals->trace_flags, FTRACE_IGNORE_ALPHATEST ))
force_solid = true;
#endif
// most surfaces are completely opaque
if( !ptexture || !ptexture->index || force_solid )
{
trace->fraction = m_flRealFraction = frac;
material = GetMaterialForFacet( facet ); // material was hit
if( DotProduct( m_vecTraceDirection, n ) >= 0.0f )
trace->plane.normal = -n;
else trace->plane.normal = n;
return true;
}
// try to avoid double shadows near triangle seams
if( u < -ASLF_EPSILON || u > ( 1.0f + ASLF_EPSILON ) || v < -ASLF_EPSILON || ( u + v ) > ( 1.0f + ASLF_EPSILON ))
return false;
// calculate w parameter
float w = 1.0f - ( u + v );
// calculate st from uvw (barycentric) coordinates
float s = w * facet->triangle[0].st[0] + u * facet->triangle[1].st[0] + v * facet->triangle[2].st[0];
float t = w * facet->triangle[0].st[1] + u * facet->triangle[1].st[1] + v * facet->triangle[2].st[1];
s = s - floor( s );
t = t - floor( t );
int is = s * ptexture->width;
int it = t * ptexture->height;
if( is < 0 ) is = 0;
if( it < 0 ) it = 0;
if( is > ptexture->width - 1 )
is = ptexture->width - 1;
if( it > ptexture->height - 1 )
it = ptexture->height - 1;
byte *pixels = (byte *)GET_TEXTURE_DATA( ptexture->index );
// test pixel
if( pixels && pixels[it * ptexture->width + is] == 0xFF )
return false; // last color in palette is indicated alpha-pixel
trace->fraction = m_flRealFraction = frac;
material = GetMaterialForFacet( facet ); // material was hit
if( DotProduct( m_vecTraceDirection, n ) >= 0.0f )
trace->plane.normal = -n;
else trace->plane.normal = n;
return true;
}
void TraceMesh :: ClipToLinks( areanode_t *node )
{
link_t *l, *next;
mfacet_t *facet;
// touch linked edicts
for( l = node->solid_edicts.next; l != &node->solid_edicts; l = next )
{
next = l->next;
facet = FACET_FROM_AREA( l );
if( !BoundsIntersect( m_vecAbsMins, m_vecAbsMaxs, facet->mins, facet->maxs ))
continue;
// might intersect, so do an exact clip
if( !m_flRealFraction ) return;
if( bIsTestPosition )
TestBoxInFacet( facet );
else if( bIsTraceLine )
ClipRayToFacet( facet );
else ClipBoxToFacet( facet );
}
// recurse down both sides
if( node->axis == -1 ) return;
if( m_vecAbsMaxs[node->axis] > node->dist )
ClipToLinks( node->children[0] );
if( m_vecAbsMins[node->axis] < node->dist )
ClipToLinks( node->children[1] );
}
bool TraceMesh :: DoTrace( void )
{
if( !mesh || !BoundsIntersect( mesh->mins, mesh->maxs, m_vecAbsMins, m_vecAbsMaxs ))
return false; // invalid mesh or no intersection
checkcount = 0;
if( areanodes )
{
ClipToLinks( areanodes );
}
else
{
mfacet_t *facet = mesh->facets;
for( int i = 0; i < mesh->numfacets; i++, facet++ )
{
if( bIsTestPosition )
TestBoxInFacet( facet );
else if( bIsTraceLine )
ClipRayToFacet( facet );
else ClipBoxToFacet( facet );
if( !m_flRealFraction )
break;
}
}
// ALERT( at_aiconsole, "total %i checks for %s\n", checkcount, areanodes ? "tree" : "brute force" );
trace->plane.normal = m_transform.VectorIRotate( trace->plane.normal ).Normalize();
trace->fraction = bound( 0.0f, trace->fraction, 1.0f );
if( trace->fraction == 1.0f ) trace->endpos = m_vecSrcEnd;
else VectorLerp( m_vecSrcStart, trace->fraction, m_vecSrcEnd, trace->endpos );
trace->plane.dist = DotProduct( trace->endpos, trace->plane.normal );
return (trace->fraction != 1.0f);
}