/*
===================
Cull
cull points against given shadow frustum.
Return true of all points are outside the frustum.
===================
*/
bool shadowMapFrustum_t::Cull( const idVec3 points[8] ) const {
bool outsidePlane[6];
for (int i = 0; i < numPlanes; i++) {
bool pointsCulled[8] = { true };
const idPlane plane = planes[i];
for (int j = 0; j < 8; j++) {
const float distance = plane.Distance( points[j] );
pointsCulled[j] = distance < 0;
}
outsidePlane[i] = true;
for (int j = 0; j < 8; j++) {
if (!pointsCulled[j]) {
outsidePlane[i] = false;
}
}
}
for (int i = 0; i < numPlanes; i++) {
if (outsidePlane[i])
return true;
}
return false;
}
/*
================
R_CalcInteractionFacing
Determines which triangles of the surface are facing towards the light origin.
The facing array should be allocated with one extra index than
the number of surface triangles, which will be used to handle dangling
edge silhouettes.
================
*/
void R_CalcInteractionFacing( const idRenderEntityLocal *ent, const srfTriangles_t *tri, const idRenderLightLocal *light, srfCullInfo_t &cullInfo ) {
SCOPED_PROFILE_EVENT( "R_CalcInteractionFacing" );
if ( cullInfo.facing != NULL ) {
return;
}
idVec3 localLightOrigin;
R_GlobalPointToLocal( ent->modelMatrix, light->globalLightOrigin, localLightOrigin );
const int numFaces = tri->numIndexes / 3;
cullInfo.facing = (byte *) R_StaticAlloc( ( numFaces + 1 ) * sizeof( cullInfo.facing[0] ), TAG_RENDER_INTERACTION );
// exact geometric cull against face
for ( int i = 0, face = 0; i < tri->numIndexes; i += 3, face++ ) {
const idDrawVert & v0 = tri->verts[tri->indexes[i + 0]];
const idDrawVert & v1 = tri->verts[tri->indexes[i + 1]];
const idDrawVert & v2 = tri->verts[tri->indexes[i + 2]];
const idPlane plane( v0.xyz, v1.xyz, v2.xyz );
const float d = plane.Distance( localLightOrigin );
cullInfo.facing[face] = ( d >= 0.0f );
}
cullInfo.facing[numFaces] = 1; // for dangling edges to reference
}
void R_LocalPlaneToGlobal( const float modelMatrix[16], const idPlane &in, idPlane &out ) {
float offset;
R_LocalVectorToGlobal( modelMatrix, in.Normal(), out.Normal() );
offset = modelMatrix[12] * out[0] + modelMatrix[13] * out[1] + modelMatrix[14] * out[2];
out[3] = in[3] - offset;
}
/*
============
idBrush::FromWinding
============
*/
bool idBrush::FromWinding( const idWinding& w, const idPlane& windingPlane )
{
int i, j, bestAxis;
idPlane plane;
idVec3 normal, axialNormal;
sides.Append( new idBrushSide( windingPlane, -1 ) );
sides.Append( new idBrushSide( -windingPlane, -1 ) );
bestAxis = 0;
for( i = 1; i < 3; i++ )
{
if( idMath::Fabs( windingPlane.Normal()[i] ) > idMath::Fabs( windingPlane.Normal()[bestAxis] ) )
{
bestAxis = i;
}
}
axialNormal = vec3_origin;
if( windingPlane.Normal()[bestAxis] > 0.0f )
{
axialNormal[bestAxis] = 1.0f;
}
else
{
axialNormal[bestAxis] = -1.0f;
}
for( i = 0; i < w.GetNumPoints(); i++ )
{
j = ( i + 1 ) % w.GetNumPoints();
normal = ( w[j].ToVec3() - w[i].ToVec3() ).Cross( axialNormal );
if( normal.Normalize() < 0.5f )
{
continue;
}
plane.SetNormal( normal );
plane.FitThroughPoint( w[j].ToVec3() );
sides.Append( new idBrushSide( plane, -1 ) );
}
if( sides.Num() < 4 )
{
for( i = 0; i < sides.Num(); i++ )
{
delete sides[i];
}
sides.Clear();
return false;
}
sides[0]->winding = w.Copy();
windingsValid = true;
BoundBrush();
return true;
}
/*
============
idAASLocal::EdgeSplitPoint
calculates split point of the edge with the plane
returns true if the split point is between the edge vertices
============
*/
bool idAASLocal::EdgeSplitPoint( idVec3 &split, int edgeNum, const idPlane &plane ) const {
const aasEdge_t *edge;
idVec3 v1, v2;
float d1, d2;
edge = &file->GetEdge( edgeNum );
v1 = file->GetVertex( edge->vertexNum[0] );
v2 = file->GetVertex( edge->vertexNum[1] );
d1 = v1 * plane.Normal() - plane.Dist();
d2 = v2 * plane.Normal() - plane.Dist();
//if ( (d1 < CM_CLIP_EPSILON && d2 < CM_CLIP_EPSILON) || (d1 > -CM_CLIP_EPSILON && d2 > -CM_CLIP_EPSILON) ) {
if( FLOATSIGNBITSET( d1 ) == FLOATSIGNBITSET( d2 ) ) {
return false;
}
split = v1 + ( d1 / ( d1 - d2 ) ) * ( v2 - v1 );
return true;
}
/*
================
idBox::PlaneDistance
================
*/
float idBox::PlaneDistance( const idPlane &plane ) const {
float d1, d2;
d1 = plane.Distance( center );
d2 = idMath::Fabs( extents[0] * plane.Normal()[0] ) +
idMath::Fabs( extents[1] * plane.Normal()[1] ) +
idMath::Fabs( extents[2] * plane.Normal()[2] );
if ( d1 - d2 > 0.0f ) {
return d1 - d2;
}
if ( d1 + d2 < 0.0f ) {
return d1 + d2;
}
return 0.0f;
}
/*
================
idBox::PlaneSide
================
*/
int idBox::PlaneSide( const idPlane &plane, const float epsilon ) const {
float d1, d2;
d1 = plane.Distance( center );
d2 = idMath::Fabs( extents[0] * plane.Normal()[0] ) +
idMath::Fabs( extents[1] * plane.Normal()[1] ) +
idMath::Fabs( extents[2] * plane.Normal()[2] );
if ( d1 - d2 > epsilon ) {
return PLANESIDE_FRONT;
}
if ( d1 + d2 < -epsilon ) {
return PLANESIDE_BACK;
}
return PLANESIDE_CROSS;
}
/*
==================
BrushMostlyOnSide
==================
*/
int BrushMostlyOnSide( uBrush_t *brush, idPlane &plane )
{
int i, j;
idWinding *w;
float d, max = 0;
int side = PSIDE_FRONT;
for( i = 0; i < brush->numsides; i++ )
{
w = brush->sides[i].winding;
if( !w )
{
continue;
}
for( j = 0; j < w->GetNumPoints(); j++ )
{
d = plane.Distance( ( *w ) [j].ToVec3() );
if( d > max )
{
max = d;
side = PSIDE_FRONT;
}
if( -d > max )
{
max = -d;
side = PSIDE_BACK;
}
}
}
return side;
}
/*
=============
R_PlaneForSurface
Returns the plane for the first triangle in the surface
FIXME: check for degenerate triangle?
=============
*/
static void R_PlaneForSurface( const srfTriangles_t *tri, idPlane &plane ) {
idDrawVert *v1, *v2, *v3;
v1 = tri->verts + tri->indexes[0];
v2 = tri->verts + tri->indexes[1];
v3 = tri->verts + tri->indexes[2];
plane.FromPoints( v1->xyz, v2->xyz, v3->xyz );
}
/*
====================
R_LightProjectionMatrix
====================
*/
void R_LightProjectionMatrix( const idVec3 &origin, const idPlane &rearPlane, idVec4 mat[4] ) {
idVec4 lv;
float lg;
// calculate the homogenious light vector
lv.x = origin.x;
lv.y = origin.y;
lv.z = origin.z;
lv.w = 1;
lg = rearPlane.ToVec4() * lv;
// outer product
mat[0][0] = lg -rearPlane[0] * lv[0];
mat[0][1] = -rearPlane[1] * lv[0];
mat[0][2] = -rearPlane[2] * lv[0];
mat[0][3] = -rearPlane[3] * lv[0];
mat[1][0] = -rearPlane[0] * lv[1];
mat[1][1] = lg -rearPlane[1] * lv[1];
mat[1][2] = -rearPlane[2] * lv[1];
mat[1][3] = -rearPlane[3] * lv[1];
mat[2][0] = -rearPlane[0] * lv[2];
mat[2][1] = -rearPlane[1] * lv[2];
mat[2][2] = lg -rearPlane[2] * lv[2];
mat[2][3] = -rearPlane[3] * lv[2];
mat[3][0] = -rearPlane[0] * lv[3];
mat[3][1] = -rearPlane[1] * lv[3];
mat[3][2] = -rearPlane[2] * lv[3];
mat[3][3] = lg -rearPlane[3] * lv[3];
}
/*
================
idBounds::PlaneSide
================
*/
int idBounds::PlaneSide( const idPlane &plane, const float epsilon ) const {
idVec3 center;
float d1, d2;
center = ( b[0] + b[1] ) * 0.5f;
d1 = plane.Distance( center );
d2 = idMath::Fabs( ( b[1][0] - center[0] ) * plane.Normal()[0] ) +
idMath::Fabs( ( b[1][1] - center[1] ) * plane.Normal()[1] ) +
idMath::Fabs( ( b[1][2] - center[2] ) * plane.Normal()[2] );
if ( d1 - d2 > epsilon ) {
return PLANESIDE_FRONT;
}
if ( d1 + d2 < -epsilon ) {
return PLANESIDE_BACK;
}
return PLANESIDE_CROSS;
}
/*
================
idBounds::PlaneDistance
================
*/
float idBounds::PlaneDistance( const idPlane &plane ) const {
idVec3 center;
float d1, d2;
center = ( b[0] + b[1] ) * 0.5f;
d1 = plane.Distance( center );
d2 = idMath::Fabs( ( b[1][0] - center[0] ) * plane.Normal()[0] ) +
idMath::Fabs( ( b[1][1] - center[1] ) * plane.Normal()[1] ) +
idMath::Fabs( ( b[1][2] - center[2] ) * plane.Normal()[2] );
if ( d1 - d2 > 0.0f ) {
return d1 - d2;
}
if ( d1 + d2 < 0.0f ) {
return d1 + d2;
}
return 0.0f;
}
/*
============
idAASBuild::IsLedgeSide_r
============
*/
bool idAASBuild::IsLedgeSide_r( idBrushBSPNode *node, idFixedWinding *w, const idPlane &plane, const idVec3 &normal, const idVec3 &origin, const float radius ) {
int res, i;
idFixedWinding back;
float dist;
if ( !node ) {
return false;
}
while ( node->GetChild(0) && node->GetChild(1) ) {
dist = node->GetPlane().Distance( origin );
if ( dist > radius ) {
res = SIDE_FRONT;
}
else if ( dist < -radius ) {
res = SIDE_BACK;
}
else {
res = w->Split( &back, node->GetPlane(), LEDGE_EPSILON );
}
if ( res == SIDE_FRONT ) {
node = node->GetChild(0);
}
else if ( res == SIDE_BACK ) {
node = node->GetChild(1);
}
else if ( res == SIDE_ON ) {
// continue with the side the winding faces
if ( node->GetPlane().Normal() * normal > 0.0f ) {
node = node->GetChild(0);
}
else {
node = node->GetChild(1);
}
}
else {
if ( IsLedgeSide_r( node->GetChild(1), &back, plane, normal, origin, radius ) ) {
return true;
}
node = node->GetChild(0);
}
}
if ( node->GetContents() & AREACONTENTS_SOLID ) {
return false;
}
for ( i = 0; i < w->GetNumPoints(); i++ ) {
if ( plane.Distance( (*w)[i].ToVec3() ) > 0.0f ) {
return true;
}
}
return false;
}
/*
================
idPlane::PlaneIntersection
================
*/
bool idPlane::PlaneIntersection( const idPlane &plane, idVec3 &start, idVec3 &dir ) const {
double n00, n01, n11, det, invDet, f0, f1;
n00 = Normal().LengthSqr();
n01 = Normal() * plane.Normal();
n11 = plane.Normal().LengthSqr();
det = n00 * n11 - n01 * n01;
if ( idMath::Fabs(det) < 1e-6f ) {
return false;
}
invDet = 1.0f / det;
f0 = ( n01 * plane.d - n11 * d ) * invDet;
f1 = ( n01 * d - n00 * plane.d ) * invDet;
dir = Normal().Cross( plane.Normal() );
start = f0 * Normal() + f1 * plane.Normal();
return true;
}
/*
================
idSphere::PlaneDistance
================
*/
float idSphere::PlaneDistance( const idPlane &plane ) const {
float d;
d = plane.Distance( origin );
if ( d > radius ) {
return d - radius;
}
if ( d < -radius ) {
return d + radius;
}
return 0.0f;
}
/*
================
idSphere::PlaneSide
================
*/
int idSphere::PlaneSide( const idPlane &plane, const float epsilon ) const {
float d;
d = plane.Distance( origin );
if ( d > radius + epsilon ) {
return PLANESIDE_FRONT;
}
if ( d < -radius - epsilon ) {
return PLANESIDE_BACK;
}
return PLANESIDE_CROSS;
}
/*
============
idAASLocal::FloorEdgeSplitPoint
calculates either the closest or furthest point on the floor of the area which also lies on the pathPlane
the point has to be on the front side of the frontPlane to be valid
============
*/
bool idAASLocal::FloorEdgeSplitPoint( idVec3 &bestSplit, int areaNum, const idPlane &pathPlane, const idPlane &frontPlane, bool closest ) const {
int i, j, faceNum, edgeNum;
const aasArea_t *area;
const aasFace_t *face;
idVec3 split;
float dist, bestDist;
if ( closest ) {
bestDist = maxWalkPathDistance;
} else {
bestDist = -0.1f;
}
area = &file->GetArea( areaNum );
for ( i = 0; i < area->numFaces; i++ ) {
faceNum = file->GetFaceIndex( area->firstFace + i );
face = &file->GetFace( abs(faceNum) );
if ( !(face->flags & FACE_FLOOR ) ) {
continue;
}
for ( j = 0; j < face->numEdges; j++ ) {
edgeNum = file->GetEdgeIndex( face->firstEdge + j );
if ( !EdgeSplitPoint( split, abs( edgeNum ), pathPlane ) ) {
continue;
}
dist = frontPlane.Distance( split );
if ( closest ) {
if ( dist >= -0.1f && dist < bestDist ) {
bestDist = dist;
bestSplit = split;
}
} else {
if ( dist > bestDist ) {
bestDist = dist;
bestSplit = split;
}
}
}
}
if ( closest ) {
return ( bestDist < maxWalkPathDistance );
} else {
return ( bestDist > -0.1f );
}
}
/*
=============
R_ChopWinding
Clips a triangle from one buffer to another, setting edge flags
The returned buffer may be the same as inNum if no clipping is done
If entirely clipped away, clipTris[returned].numVerts == 0
I have some worries about edge flag cases when polygons are clipped
multiple times near the epsilon.
=============
*/
static int R_ChopWinding( clipTri_t clipTris[2], int inNum, const idPlane plane ) {
clipTri_t *in, *out;
float dists[MAX_CLIPPED_POINTS];
int sides[MAX_CLIPPED_POINTS];
int counts[3];
float dot;
int i, j;
idVec3 mid;
bool front;
in = &clipTris[inNum];
out = &clipTris[inNum^1];
counts[0] = counts[1] = counts[2] = 0;
// determine sides for each point
front = false;
for ( i = 0; i < in->numVerts; i++ ) {
dot = in->verts[i] * plane.Normal() + plane[3];
dists[i] = dot;
if ( dot < LIGHT_CLIP_EPSILON ) { // slop onto the back
sides[i] = SIDE_BACK;
} else {
sides[i] = SIDE_FRONT;
if ( dot > LIGHT_CLIP_EPSILON ) {
front = true;
}
}
counts[sides[i]]++;
}
// if none in front, it is completely clipped away
if ( !front ) {
in->numVerts = 0;
return inNum;
}
if ( !counts[SIDE_BACK] ) {
return inNum; // inout stays the same
}
// avoid wrapping checks by duplicating first value to end
sides[i] = sides[0];
dists[i] = dists[0];
in->verts[in->numVerts] = in->verts[0];
out->numVerts = 0;
for ( i = 0 ; i < in->numVerts ; i++ ) {
idVec3 &p1 = in->verts[i];
if ( sides[i] == SIDE_FRONT ) {
out->verts[out->numVerts] = p1;
out->numVerts++;
}
if ( sides[i+1] == sides[i] ) {
continue;
}
// generate a split point
idVec3 &p2 = in->verts[i+1];
dot = dists[i] / ( dists[i] - dists[i+1] );
for ( j = 0; j < 3; j++ ) {
mid[j] = p1[j] + dot * ( p2[j] - p1[j] );
}
out->verts[out->numVerts] = mid;
out->numVerts++;
}
return inNum ^ 1;
}
/*
==================
PlaneForTri
==================
*/
void PlaneForTri( const mapTri_t *tri, idPlane &plane ) {
plane.FromPoints( tri->v[0].xyz, tri->v[1].xyz, tri->v[2].xyz );
}
/*
============
idBrush::Split
============
*/
int idBrush::Split( const idPlane& plane, int planeNum, idBrush** front, idBrush** back ) const
{
int res, i, j;
idBrushSide* side, *frontSide, *backSide;
float dist, maxBack, maxFront, *maxBackWinding, *maxFrontWinding;
idWinding* w, *mid;
assert( windingsValid );
if( front )
{
*front = NULL;
}
if( back )
{
*back = NULL;
}
res = bounds.PlaneSide( plane, -BRUSH_EPSILON );
if( res == PLANESIDE_FRONT )
{
if( front )
{
*front = Copy();
}
return res;
}
if( res == PLANESIDE_BACK )
{
if( back )
{
*back = Copy();
}
return res;
}
maxBackWinding = ( float* ) _alloca16( sides.Num() * sizeof( float ) );
maxFrontWinding = ( float* ) _alloca16( sides.Num() * sizeof( float ) );
maxFront = maxBack = 0.0f;
for( i = 0; i < sides.Num(); i++ )
{
side = sides[i];
w = side->winding;
if( !w )
{
continue;
}
maxBackWinding[i] = 10.0f;
maxFrontWinding[i] = -10.0f;
for( j = 0; j < w->GetNumPoints(); j++ )
{
dist = plane.Distance( ( *w )[j].ToVec3() );
if( dist > maxFrontWinding[i] )
{
maxFrontWinding[i] = dist;
}
if( dist < maxBackWinding[i] )
{
maxBackWinding[i] = dist;
}
}
if( maxFrontWinding[i] > maxFront )
{
maxFront = maxFrontWinding[i];
}
if( maxBackWinding[i] < maxBack )
{
maxBack = maxBackWinding[i];
}
}
if( maxFront < BRUSH_EPSILON )
{
if( back )
{
*back = Copy();
}
return PLANESIDE_BACK;
}
if( maxBack > -BRUSH_EPSILON )
{
if( front )
{
*front = Copy();
}
return PLANESIDE_FRONT;
}
mid = new idWinding( plane.Normal(), plane.Dist() );
for( i = 0; i < sides.Num() && mid; i++ )
{
mid = mid->Clip( -sides[i]->plane, BRUSH_EPSILON, false );
}
if( mid )
{
if( mid->IsTiny() )
{
delete mid;
mid = NULL;
}
else if( mid->IsHuge() )
{
// if the winding is huge then the brush is unbounded
common->Warning( "brush %d on entity %d is unbounded"
"( %1.2f %1.2f %1.2f )-( %1.2f %1.2f %1.2f )-( %1.2f %1.2f %1.2f )", primitiveNum, entityNum,
bounds[0][0], bounds[0][1], bounds[0][2], bounds[1][0], bounds[1][1], bounds[1][2],
bounds[1][0] - bounds[0][0], bounds[1][1] - bounds[0][1], bounds[1][2] - bounds[0][2] );
delete mid;
mid = NULL;
}
}
if( !mid )
{
if( maxFront > - maxBack )
{
if( front )
{
*front = Copy();
}
return PLANESIDE_FRONT;
}
else
{
if( back )
{
*back = Copy();
}
return PLANESIDE_BACK;
}
}
if( !front && !back )
{
delete mid;
return PLANESIDE_CROSS;
}
*front = new idBrush();
( *front )->SetContents( contents );
( *front )->SetEntityNum( entityNum );
( *front )->SetPrimitiveNum( primitiveNum );
*back = new idBrush();
( *back )->SetContents( contents );
( *back )->SetEntityNum( entityNum );
( *back )->SetPrimitiveNum( primitiveNum );
for( i = 0; i < sides.Num(); i++ )
{
side = sides[i];
if( !side->winding )
{
continue;
}
// if completely at the front
if( maxBackWinding[i] >= BRUSH_EPSILON )
{
( *front )->sides.Append( side->Copy() );
}
// if completely at the back
else if( maxFrontWinding[i] <= -BRUSH_EPSILON )
{
( *back )->sides.Append( side->Copy() );
}
else
{
// split the side
side->Split( plane, &frontSide, &backSide );
if( frontSide )
{
( *front )->sides.Append( frontSide );
}
else if( maxFrontWinding[i] > -BRUSH_EPSILON )
{
// favor an overconstrained brush
side = side->Copy();
side->winding = side->winding->Clip( idPlane( plane.Normal(), ( plane.Dist() - ( BRUSH_EPSILON + 0.02f ) ) ), 0.01f, true );
assert( side->winding );
( *front )->sides.Append( side );
}
if( backSide )
{
( *back )->sides.Append( backSide );
}
else if( maxBackWinding[i] < BRUSH_EPSILON )
{
// favor an overconstrained brush
side = side->Copy();
side->winding = side->winding->Clip( idPlane( -plane.Normal(), -( plane.Dist() + ( BRUSH_EPSILON + 0.02f ) ) ), 0.01f, true );
assert( side->winding );
( *back )->sides.Append( side );
}
}
}
side = new idBrushSide( -plane, planeNum ^ 1 );
side->winding = mid->Reverse();
side->flags |= SFL_SPLIT;
( *front )->sides.Append( side );
( *front )->windingsValid = true;
( *front )->BoundBrush( this );
side = new idBrushSide( plane, planeNum );
side->winding = mid;
side->flags |= SFL_SPLIT;
( *back )->sides.Append( side );
( *back )->windingsValid = true;
( *back )->BoundBrush( this );
return PLANESIDE_CROSS;
}
/*
================
idCollisionModelManagerLocal::RotatePointThroughPlane
calculates the tangent of half the rotation angle at which the point collides with the plane
================
*/
int idCollisionModelManagerLocal::RotatePointThroughPlane( const cm_traceWork_t *tw, const idVec3 &point, const idPlane &plane,
const float angle, const float minTan, float &tanHalfAngle ) {
double v0, v1, v2, a, b, c, d, sqrtd, q, frac1, frac2;
idVec3 p, normal;
/*
p[0] = point[0] * cos(t) + point[1] * sin(t)
p[1] = point[0] * -sin(t) + point[1] * cos(t)
p[2] = point[2];
normal[0] * (p[0] * cos(t) + p[1] * sin(t)) +
normal[1] * (p[0] * -sin(t) + p[1] * cos(t)) +
normal[2] * p[2] + dist = 0
normal[0] * p[0] * cos(t) + normal[0] * p[1] * sin(t) +
-normal[1] * p[0] * sin(t) + normal[1] * p[1] * cos(t) +
normal[2] * p[2] + dist = 0
v2 * cos(t) + v1 * sin(t) + v0
// rotation about the z-axis
v0 = normal[2] * p[2] + dist
v1 = normal[0] * p[1] - normal[1] * p[0]
v2 = normal[0] * p[0] + normal[1] * p[1]
r = tan(t / 2);
sin(t) = 2*r/(1+r*r);
cos(t) = (1-r*r)/(1+r*r);
v1 * 2 * r / (1 + r*r) + v2 * (1 - r*r) / (1 + r*r) + v0 = 0
(v1 * 2 * r + v2 * (1 - r*r)) / (1 + r*r) = -v0
(v1 * 2 * r + v2 - v2 * r*r) / (1 + r*r) = -v0
v1 * 2 * r + v2 - v2 * r*r = -v0 * (1 + r*r)
v1 * 2 * r + v2 - v2 * r*r = -v0 + -v0 * r*r
(v0 - v2) * r * r + (2 * v1) * r + (v0 + v2) = 0;
*/
tanHalfAngle = tw->maxTan;
// transform rotation axis to z-axis
p = (point - tw->origin) * tw->matrix;
d = plane[3] + plane.Normal() * tw->origin;
normal = plane.Normal() * tw->matrix;
v0 = normal[2] * p[2] + d;
v1 = normal[0] * p[1] - normal[1] * p[0];
v2 = normal[0] * p[0] + normal[1] * p[1];
a = v0 - v2;
b = v1;
c = v0 + v2;
if ( a == 0.0f ) {
if ( b == 0.0f ) {
return false;
}
frac1 = -c / ( 2.0f * b );
frac2 = 1e10; // = tan( idMath::HALF_PI )
}
else {
d = b * b - c * a;
if ( d <= 0.0f ) {
return false;
}
sqrtd = sqrt( d );
if ( b > 0.0f ) {
q = - b + sqrtd;
}
else {
q = - b - sqrtd;
}
frac1 = q / a;
frac2 = c / q;
}
if ( angle < 0.0f ) {
frac1 = -frac1;
frac2 = -frac2;
}
// get smallest tangent for which a collision occurs
if ( frac1 >= minTan && frac1 < tanHalfAngle ) {
tanHalfAngle = frac1;
}
if ( frac2 >= minTan && frac2 < tanHalfAngle ) {
tanHalfAngle = frac2;
}
if ( angle < 0.0f ) {
tanHalfAngle = -tanHalfAngle;
}
return true;
}
/*
============
idBrushBSPNode::Split
============
*/
bool idBrushBSPNode::Split( const idPlane &splitPlane, int splitPlaneNum ) {
int s, i;
idWinding *mid;
idBrushBSPPortal *p, *midPortal, *newPortals[2];
idBrushBSPNode *newNodes[2];
mid = new idWinding( splitPlane.Normal(), splitPlane.Dist() );
for ( p = portals; p && mid; p = p->next[s] ) {
s = (p->nodes[1] == this);
if ( s ) {
mid = mid->Clip( -p->plane, 0.1f, false );
}
else {
mid = mid->Clip( p->plane, 0.1f, false );
}
}
if ( !mid ) {
return false;
}
// allocate two new nodes
for ( i = 0; i < 2; i++ ) {
newNodes[i] = new idBrushBSPNode();
newNodes[i]->flags = flags;
newNodes[i]->contents = contents;
newNodes[i]->parent = this;
}
// split all portals of the node
for ( p = portals; p; p = portals ) {
s = (p->nodes[1] == this);
p->Split( splitPlane, &newPortals[0], &newPortals[1] );
for ( i = 0; i < 2; i++ ) {
if ( newPortals[i] ) {
if ( s ) {
newPortals[i]->AddToNodes( p->nodes[0], newNodes[i] );
}
else {
newPortals[i]->AddToNodes( newNodes[i], p->nodes[1] );
}
}
}
p->RemoveFromNode( p->nodes[0] );
p->RemoveFromNode( p->nodes[1] );
delete p;
}
// add seperating portal
midPortal = new idBrushBSPPortal();
midPortal->plane = splitPlane;
midPortal->planeNum = splitPlaneNum;
midPortal->winding = mid;
midPortal->AddToNodes( newNodes[0], newNodes[1] );
// set new child nodes
children[0] = newNodes[0];
children[1] = newNodes[1];
plane = splitPlane;
return true;
}
/*
================
idCollisionModelManagerLocal::PointFurthestFromPlane
calculates the direction of motion at the initial position, where dir < 0 means the point moves towards the plane
if the point moves away from the plane the tangent of half the rotation angle at which
the point is furthest away from the plane is also calculated
================
*/
int idCollisionModelManagerLocal::PointFurthestFromPlane( const cm_traceWork_t *tw, const idVec3 &point, const idPlane &plane,
const float angle, float &tanHalfAngle, float &dir ) {
double v1, v2, a, b, c, d, sqrtd, q, frac1, frac2;
idVec3 p, normal;
/*
v2 * cos(t) + v1 * sin(t) + v0 = 0;
// rotation about the z-axis
v0 = normal[2] * p[2] + dist
v1 = normal[0] * p[1] - normal[1] * p[0]
v2 = normal[0] * p[0] + normal[1] * p[1]
derivative:
v1 * cos(t) - v2 * sin(t) = 0;
r = tan(t / 2);
sin(t) = 2*r/(1+r*r);
cos(t) = (1-r*r)/(1+r*r);
-v2 * 2 * r / (1 + r*r) + v1 * (1 - r*r)/(1+r*r);
-v2 * 2 * r + v1 * (1 - r*r) / (1 + r*r) = 0;
-v2 * 2 * r + v1 * (1 - r*r) = 0;
(-v1) * r * r + (-2 * v2) * r + (v1) = 0;
*/
tanHalfAngle = 0.0f;
// transform rotation axis to z-axis
p = (point - tw->origin) * tw->matrix;
normal = plane.Normal() * tw->matrix;
v1 = normal[0] * p[1] - normal[1] * p[0];
v2 = normal[0] * p[0] + normal[1] * p[1];
// the point will always start at the front of the plane, therefore v0 + v2 > 0 is always true
if ( angle < 0.0f ) {
dir = -v1;
}
else {
dir = v1;
}
// negative direction means the point moves towards the plane at the initial position
if ( dir <= 0.0f ) {
return true;
}
a = -v1;
b = -v2;
c = v1;
if ( a == 0.0f ) {
if ( b == 0.0f ) {
return false;
}
frac1 = -c / ( 2.0f * b );
frac2 = 1e10; // = tan( idMath::HALF_PI )
}
else {
d = b * b - c * a;
if ( d <= 0.0f ) {
return false;
}
sqrtd = sqrt( d );
if ( b > 0.0f ) {
q = - b + sqrtd;
}
else {
q = - b - sqrtd;
}
frac1 = q / a;
frac2 = c / q;
}
if ( angle < 0.0f ) {
frac1 = -frac1;
frac2 = -frac2;
}
if ( frac1 < 0.0f && frac2 < 0.0f ) {
return false;
}
if ( frac1 > frac2 ) {
tanHalfAngle = frac1;
}
else {
tanHalfAngle = frac2;
}
if ( angle < 0.0f ) {
tanHalfAngle = -tanHalfAngle;
}
return true;
}
/*
=================
idSurface::Split
=================
*/
int idSurface::Split( const idPlane &plane, const float epsilon, idSurface **front, idSurface **back, int *frontOnPlaneEdges, int *backOnPlaneEdges ) const {
float * dists;
float f;
byte * sides;
int counts[3];
int * edgeSplitVertex;
int numEdgeSplitVertexes;
int * vertexRemap[2];
int vertexIndexNum[2][2];
int * vertexCopyIndex[2];
int * indexPtr[2];
int indexNum[2];
int * index;
int * onPlaneEdges[2];
int numOnPlaneEdges[2];
int maxOnPlaneEdges;
int i;
idSurface * surface[2];
idDrawVert v;
dists = (float *) _alloca( verts.Num() * sizeof( float ) );
sides = (byte *) _alloca( verts.Num() * sizeof( byte ) );
counts[0] = counts[1] = counts[2] = 0;
// determine side for each vertex
for ( i = 0; i < verts.Num(); i++ ) {
dists[i] = f = plane.Distance( verts[i].xyz );
if ( f > epsilon ) {
sides[i] = SIDE_FRONT;
} else if ( f < -epsilon ) {
sides[i] = SIDE_BACK;
} else {
sides[i] = SIDE_ON;
}
counts[sides[i]]++;
}
*front = *back = NULL;
// if coplanar, put on the front side if the normals match
if ( !counts[SIDE_FRONT] && !counts[SIDE_BACK] ) {
f = ( verts[indexes[1]].xyz - verts[indexes[0]].xyz ).Cross( verts[indexes[0]].xyz - verts[indexes[2]].xyz ) * plane.Normal();
if ( FLOATSIGNBITSET( f ) ) {
*back = new idSurface( *this );
return SIDE_BACK;
} else {
*front = new idSurface( *this );
return SIDE_FRONT;
}
}
// if nothing at the front of the clipping plane
if ( !counts[SIDE_FRONT] ) {
*back = new idSurface( *this );
return SIDE_BACK;
}
// if nothing at the back of the clipping plane
if ( !counts[SIDE_BACK] ) {
*front = new idSurface( *this );
return SIDE_FRONT;
}
// allocate front and back surface
*front = surface[0] = new idSurface();
*back = surface[1] = new idSurface();
edgeSplitVertex = (int *) _alloca( edges.Num() * sizeof( int ) );
numEdgeSplitVertexes = 0;
maxOnPlaneEdges = 4 * counts[SIDE_ON];
counts[SIDE_FRONT] = counts[SIDE_BACK] = counts[SIDE_ON] = 0;
// split edges
for ( i = 0; i < edges.Num(); i++ ) {
int v0 = edges[i].verts[0];
int v1 = edges[i].verts[1];
int sidesOr = ( sides[v0] | sides[v1] );
// if both vertexes are on the same side or one is on the clipping plane
if ( !( sides[v0] ^ sides[v1] ) || ( sidesOr & SIDE_ON ) ) {
edgeSplitVertex[i] = -1;
counts[sidesOr & SIDE_BACK]++;
counts[SIDE_ON] += ( sidesOr & SIDE_ON ) >> 1;
} else {
/*
=================
idRenderModelDecal::CreateDecal
=================
*/
void idRenderModelDecal::CreateDecal( const idRenderModel *model, const decalProjectionParms_t &localParms ) {
int maxVerts = 0;
for ( int surfNum = 0; surfNum < model->NumSurfaces(); surfNum++ ) {
const modelSurface_t *surf = model->Surface( surfNum );
if ( surf->geometry != NULL && surf->shader != NULL ) {
maxVerts = Max( maxVerts, surf->geometry->numVerts );
}
}
idTempArray< byte > cullBits( ALIGN( maxVerts, 4 ) );
// check all model surfaces
for ( int surfNum = 0; surfNum < model->NumSurfaces(); surfNum++ ) {
const modelSurface_t *surf = model->Surface( surfNum );
// if no geometry or no shader
if ( surf->geometry == NULL || surf->shader == NULL ) {
continue;
}
// decals and overlays use the same rules
if ( !localParms.force && !surf->shader->AllowOverlays() ) {
continue;
}
srfTriangles_t *tri = surf->geometry;
// if the triangle bounds do not overlap with the projection bounds
if ( !localParms.projectionBounds.IntersectsBounds( tri->bounds ) ) {
continue;
}
// decals don't work on animated models
assert( tri->staticModelWithJoints == NULL );
// catagorize all points by the planes
R_DecalPointCullStatic( cullBits.Ptr(), localParms.boundingPlanes, tri->verts, tri->numVerts );
// start streaming the indexes
idODSStreamedArray< triIndex_t, 256, SBT_QUAD, 3 > indexesODS( tri->indexes, tri->numIndexes );
// find triangles inside the projection volume
for ( int i = 0; i < tri->numIndexes; ) {
const int nextNumIndexes = indexesODS.FetchNextBatch() - 3;
for ( ; i <= nextNumIndexes; i += 3 ) {
const int i0 = indexesODS[i + 0];
const int i1 = indexesODS[i + 1];
const int i2 = indexesODS[i + 2];
// skip triangles completely off one side
if ( cullBits[i0] & cullBits[i1] & cullBits[i2] ) {
continue;
}
const idDrawVert * verts[3] = {
&tri->verts[i0],
&tri->verts[i1],
&tri->verts[i2]
};
// skip back facing triangles
const idPlane plane( verts[0]->xyz, verts[1]->xyz, verts[2]->xyz );
if ( plane.Normal() * localParms.boundingPlanes[NUM_DECAL_BOUNDING_PLANES - 2].Normal() < -0.1f ) {
continue;
}
// create a winding with texture coordinates for the triangle
idFixedWinding fw;
fw.SetNumPoints( 3 );
if ( localParms.parallel ) {
for ( int j = 0; j < 3; j++ ) {
fw[j] = verts[j]->xyz;
fw[j].s = localParms.textureAxis[0].Distance( verts[j]->xyz );
fw[j].t = localParms.textureAxis[1].Distance( verts[j]->xyz );
}
} else {
for ( int j = 0; j < 3; j++ ) {
const idVec3 dir = verts[j]->xyz - localParms.projectionOrigin;
float scale;
localParms.boundingPlanes[NUM_DECAL_BOUNDING_PLANES - 1].RayIntersection( verts[j]->xyz, dir, scale );
const idVec3 intersection = verts[j]->xyz + scale * dir;
fw[j] = verts[j]->xyz;
fw[j].s = localParms.textureAxis[0].Distance( intersection );
fw[j].t = localParms.textureAxis[1].Distance( intersection );
}
}
const int orBits = cullBits[i0] | cullBits[i1] | cullBits[i2];
// clip the exact surface triangle to the projection volume
for ( int j = 0; j < NUM_DECAL_BOUNDING_PLANES; j++ ) {
if ( ( orBits & ( 1 << j ) ) != 0 ) {
if ( !fw.ClipInPlace( -localParms.boundingPlanes[j] ) ) {
break;
}
}
}
// if there is a part of the triangle between the bounding planes then clip
// the triangle based on depth and add decals for the depth faded parts
if ( fw.GetNumPoints() != 0 ) {
idFixedWinding back;
if ( fw.Split( &back, localParms.fadePlanes[0], 0.1f ) == SIDE_CROSS ) {
CreateDecalFromWinding( back, localParms.material, localParms.fadePlanes, localParms.fadeDepth, localParms.startTime );
}
if ( fw.Split( &back, localParms.fadePlanes[1], 0.1f ) == SIDE_CROSS ) {
CreateDecalFromWinding( back, localParms.material, localParms.fadePlanes, localParms.fadeDepth, localParms.startTime );
}
CreateDecalFromWinding( fw, localParms.material, localParms.fadePlanes, localParms.fadeDepth, localParms.startTime );
}
}
}
}
}
/*
=============
R_ChopWinding
Clips a triangle from one buffer to another, setting edge flags
The returned buffer may be the same as inNum if no clipping is done
If entirely clipped away, clipTris[returned].numVerts == 0
I have some worries about edge flag cases when polygons are clipped
multiple times near the epsilon.
=============
*/
static int R_ChopWinding( clipTri_t clipTris[2], int inNum, const idPlane &plane ) {
clipTri_t *in, *out;
float dists[MAX_CLIPPED_POINTS];
int sides[MAX_CLIPPED_POINTS];
int counts[3];
float dot;
int i, j;
idVec3 *p1, *p2;
idVec3 mid;
in = &clipTris[inNum];
out = &clipTris[inNum^1];
counts[0] = counts[1] = counts[2] = 0;
// determine sides for each point
for ( i = 0 ; i < in->numVerts ; i++ ) {
dot = plane.Distance( in->verts[i] );
dists[i] = dot;
if ( dot < -LIGHT_CLIP_EPSILON ) {
sides[i] = SIDE_BACK;
} else if ( dot > LIGHT_CLIP_EPSILON ) {
sides[i] = SIDE_FRONT;
} else {
sides[i] = SIDE_ON;
}
counts[sides[i]]++;
}
// if none in front, it is completely clipped away
if ( !counts[SIDE_FRONT] ) {
in->numVerts = 0;
return inNum;
}
if ( !counts[SIDE_BACK] ) {
return inNum; // inout stays the same
}
// avoid wrapping checks by duplicating first value to end
sides[i] = sides[0];
dists[i] = dists[0];
in->verts[in->numVerts] = in->verts[0];
in->edgeFlags[in->numVerts] = in->edgeFlags[0];
out->numVerts = 0;
for ( i = 0 ; i < in->numVerts ; i++ ) {
p1 = &in->verts[i];
if ( sides[i] != SIDE_BACK ) {
out->verts[out->numVerts] = *p1;
if ( sides[i] == SIDE_ON && sides[i+1] == SIDE_BACK ) {
out->edgeFlags[out->numVerts] = 1;
} else {
out->edgeFlags[out->numVerts] = in->edgeFlags[i];
}
out->numVerts++;
}
if ( (sides[i] == SIDE_FRONT && sides[i+1] == SIDE_BACK)
|| (sides[i] == SIDE_BACK && sides[i+1] == SIDE_FRONT) ) {
// generate a split point
p2 = &in->verts[i+1];
dot = dists[i] / (dists[i]-dists[i+1]);
for ( j=0 ; j<3 ; j++ ) {
mid[j] = (*p1)[j] + dot*((*p2)[j]-(*p1)[j]);
}
out->verts[out->numVerts] = mid;
// set the edge flag
if ( sides[i+1] != SIDE_FRONT ) {
out->edgeFlags[out->numVerts] = 1;
} else {
out->edgeFlags[out->numVerts] = in->edgeFlags[i];
}
out->numVerts++;
}
}
return inNum ^ 1;
}
/*
============
idAASLocal::FloorEdgeSplitPoint
calculates either the closest or furthest point on the floor of the area which also lies on the pathPlane
the point has to be on the front side of the frontPlane to be valid
============
*/
bool idAASLocal::FloorEdgeSplitPoint( idVec3 &bestSplit, int areaNum, const idPlane &pathPlane, const idPlane &frontPlane, bool closest ) const {
int i, j, faceNum, edgeNum;
const aasArea_t *area;
const aasFace_t *face;
idVec3 split;
float dist, bestDist;
const aasEdge_t *edge;
idVec3 v1, v2;
float d1, d2;
area = &file->GetArea( areaNum );
if ( closest ) {
bestDist = maxWalkPathDistance;
for ( i = area->numFaces-1; i >= 0; i-- ) {
faceNum = file->GetFaceIndex( area->firstFace + i );
face = &file->GetFace( abs(faceNum) );
if ( !(face->flags & FACE_FLOOR ) ) {
continue;
}
for ( j = face->numEdges-1; j >= 0; j-- ) {
edgeNum = file->GetEdgeIndex( face->firstEdge + j );
edge = &file->GetEdge( abs( edgeNum ) );
v1 = file->GetVertex( edge->vertexNum[0] );
v2 = file->GetVertex( edge->vertexNum[1] );
d1 = v1 * pathPlane.Normal() - pathPlane.Dist();
d2 = v2 * pathPlane.Normal() - pathPlane.Dist();
//if ( (d1 < CM_CLIP_EPSILON && d2 < CM_CLIP_EPSILON) || (d1 > -CM_CLIP_EPSILON && d2 > -CM_CLIP_EPSILON) ) {
if ( FLOATSIGNBITSET( d1 ) == FLOATSIGNBITSET( d2 ) ) {
continue;
}
split = v1 + (d1 / (d1 - d2)) * (v2 - v1);
dist = frontPlane.Distance( split );
if ( dist >= -0.1f && dist < bestDist ) {
bestDist = dist;
bestSplit = split;
}
}
}
return ( bestDist < maxWalkPathDistance );
} else {
bestDist = -0.1f;
for ( i = area->numFaces-1; i >= 0; i-- ) {
faceNum = file->GetFaceIndex( area->firstFace + i );
face = &file->GetFace( abs(faceNum) );
if ( !(face->flags & FACE_FLOOR ) ) {
continue;
}
for ( j = face->numEdges-1; j >= 0; j-- ) {
edgeNum = file->GetEdgeIndex( face->firstEdge + j );
edge = &file->GetEdge( abs( edgeNum ) );
v1 = file->GetVertex( edge->vertexNum[0] );
v2 = file->GetVertex( edge->vertexNum[1] );
d1 = v1 * pathPlane.Normal() - pathPlane.Dist();
d2 = v2 * pathPlane.Normal() - pathPlane.Dist();
//if ( (d1 < CM_CLIP_EPSILON && d2 < CM_CLIP_EPSILON) || (d1 > -CM_CLIP_EPSILON && d2 > -CM_CLIP_EPSILON) ) {
if ( FLOATSIGNBITSET( d1 ) == FLOATSIGNBITSET( d2 ) ) {
continue;
}
split = v1 + (d1 / (d1 - d2)) * (v2 - v1);
dist = frontPlane.Distance( split );
if ( dist > bestDist ) {
bestDist = dist;
bestSplit = split;
}
}
}
return ( bestDist > -0.1f );
}
}
