/*
=================
R_RadiusCullLocalBox
A fast, conservative center-to-corner culling test
Returns true if the box is outside the given global frustum, (positive sides are out)
=================
*/
bool R_RadiusCullLocalBox( const idBounds &bounds, const float modelMatrix[16], int numPlanes, const idPlane *planes ) {
int i;
float d;
idVec3 worldOrigin;
float worldRadius;
const idPlane *frust;
if ( r_useCulling.GetInteger() == 0 ) {
return false;
}
// transform the surface bounds into world space
idVec3 localOrigin = ( bounds[0] + bounds[1] ) * 0.5;
R_LocalPointToGlobal( modelMatrix, localOrigin, worldOrigin );
worldRadius = (bounds[0] - localOrigin).Length(); // FIXME: won't be correct for scaled objects
for ( i = 0 ; i < numPlanes ; i++ ) {
frust = planes + i;
d = frust->Distance( worldOrigin );
if ( d > worldRadius ) {
return true; // culled
}
}
return false; // no culled
}
/*
========================
R_MirrorViewBySurface
========================
*/
static viewDef_t *R_MirrorViewBySurface( drawSurf_t *drawSurf ) {
viewDef_t *parms;
orientation_t surface, camera;
idPlane originalPlane, plane;
// copy the viewport size from the original
parms = (viewDef_t *)R_FrameAlloc( sizeof( *parms ) );
*parms = *tr.viewDef;
parms->renderView.viewID = 0; // clear to allow player bodies to show up, and suppress view weapons
parms->isSubview = true;
parms->isMirror = true;
// create plane axis for the portal we are seeing
R_PlaneForSurface( drawSurf->geo, originalPlane );
R_LocalPlaneToGlobal( drawSurf->space->modelMatrix, originalPlane, plane );
surface.origin = plane.Normal() * -plane[3];
surface.axis[0] = plane.Normal();
surface.axis[0].NormalVectors( surface.axis[1], surface.axis[2] );
surface.axis[2] = -surface.axis[2];
camera.origin = surface.origin;
camera.axis[0] = -surface.axis[0];
camera.axis[1] = surface.axis[1];
camera.axis[2] = surface.axis[2];
// set the mirrored origin and axis
R_MirrorPoint( tr.viewDef->renderView.vieworg, &surface, &camera, parms->renderView.vieworg );
R_MirrorVector( tr.viewDef->renderView.viewaxis[0], &surface, &camera, parms->renderView.viewaxis[0] );
R_MirrorVector( tr.viewDef->renderView.viewaxis[1], &surface, &camera, parms->renderView.viewaxis[1] );
R_MirrorVector( tr.viewDef->renderView.viewaxis[2], &surface, &camera, parms->renderView.viewaxis[2] );
// make the view origin 16 units away from the center of the surface
idVec3 viewOrigin = ( drawSurf->geo->bounds[0] + drawSurf->geo->bounds[1] ) * 0.5;
viewOrigin += ( originalPlane.Normal() * 16 );
R_LocalPointToGlobal( drawSurf->space->modelMatrix, viewOrigin, parms->initialViewAreaOrigin );
// set the mirror clip plane
parms->numClipPlanes = 1;
parms->clipPlanes[0] = -camera.axis[0];
parms->clipPlanes[0][3] = -( camera.origin * parms->clipPlanes[0].Normal() );
return parms;
}
/*
=================
R_CornerCullLocalBox
Tests all corners against the frustum.
Can still generate a few false positives when the box is outside a corner.
Returns true if the box is outside the given global frustum, (positive sides are out)
=================
*/
bool R_CornerCullLocalBox( const idBounds &bounds, const float modelMatrix[16], int numPlanes, const idPlane *planes ) {
int i, j;
idVec3 transformed[8];
float dists[8];
idVec3 v;
const idPlane *frust;
// we can disable box culling for experimental timing purposes
if ( r_useCulling.GetInteger() < 2 ) {
return false;
}
// transform into world space
for ( i = 0 ; i < 8 ; i++ ) {
v[0] = bounds[i&1][0];
v[1] = bounds[(i>>1)&1][1];
v[2] = bounds[(i>>2)&1][2];
R_LocalPointToGlobal( modelMatrix, v, transformed[i] );
}
// check against frustum planes
for ( i = 0 ; i < numPlanes ; i++ ) {
frust = planes + i;
for ( j = 0 ; j < 8 ; j++ ) {
dists[j] = frust->Distance( transformed[j] );
if ( dists[j] < 0 ) {
break;
}
}
if ( j == 8 ) {
// all points were behind one of the planes
tr.pc.c_box_cull_out++;
return true;
}
}
tr.pc.c_box_cull_in++;
return false; // not culled
}
/*
===================
idRenderWorldLocal::ScreenRectForWinding
===================
*/
idScreenRect idRenderWorldLocal::ScreenRectFromWinding( const idWinding *w, viewEntity_t *space ) {
idScreenRect r;
int i;
idVec3 v;
idVec3 ndc;
float windowX, windowY;
r.Clear();
for ( i = 0 ; i < w->GetNumPoints() ; i++ ) {
R_LocalPointToGlobal( space->modelMatrix, (*w)[i].ToVec3(), v );
R_GlobalToNormalizedDeviceCoordinates( v, ndc );
windowX = 0.5f * ( 1.0f + ndc[0] ) * ( tr.viewDef->viewport.x2 - tr.viewDef->viewport.x1 );
windowY = 0.5f * ( 1.0f + ndc[1] ) * ( tr.viewDef->viewport.y2 - tr.viewDef->viewport.y1 );
r.AddPoint( windowX, windowY );
}
r.Expand();
return r;
}
/*
===================
idRenderWorldLocal::ScreenRectForWinding
===================
*/
idScreenRect idRenderWorldLocal::ScreenRectFromWinding( const idWinding * w, const viewEntity_t * space ) {
const float viewWidth = (float) tr.viewDef->viewport.x2 - (float) tr.viewDef->viewport.x1;
const float viewHeight = (float) tr.viewDef->viewport.y2 - (float) tr.viewDef->viewport.y1;
idScreenRect r;
r.Clear();
for ( int i = 0; i < w->GetNumPoints(); i++ ) {
idVec3 v;
idVec3 ndc;
R_LocalPointToGlobal( space->modelMatrix, (*w)[i].ToVec3(), v );
R_GlobalToNormalizedDeviceCoordinates( v, ndc );
float windowX = ( ndc[0] * 0.5f + 0.5f ) * viewWidth;
float windowY = ( ndc[1] * 0.5f + 0.5f ) * viewHeight;
r.AddPoint( windowX, windowY );
}
r.Expand();
return r;
}
/*
=========================
R_PreciseCullSurface
Check the surface for visibility on a per-triangle basis
for cases when it is going to be VERY expensive to draw (subviews)
If not culled, also returns the bounding box of the surface in
Normalized Device Coordinates, so it can be used to crop the scissor rect.
OPTIMIZE: we could also take exact portal passing into consideration
=========================
*/
bool R_PreciseCullSurface( const drawSurf_t *drawSurf, idBounds &ndcBounds ) {
const srfTriangles_t *tri;
int numTriangles;
idPlane clip, eye;
int i, j;
unsigned int pointOr;
unsigned int pointAnd;
idVec3 localView;
idFixedWinding w;
tri = drawSurf->geo;
pointOr = 0;
pointAnd = (unsigned int)~0;
// get an exact bounds of the triangles for scissor cropping
ndcBounds.Clear();
for ( i = 0; i < tri->numVerts; i++ ) {
int j;
unsigned int pointFlags;
R_TransformModelToClip( tri->verts[i].xyz, drawSurf->space->modelViewMatrix,
tr.viewDef->projectionMatrix, eye, clip );
pointFlags = 0;
for ( j = 0; j < 3; j++ ) {
if ( clip[j] >= clip[3] ) {
pointFlags |= (1 << (j*2));
} else if ( clip[j] <= -clip[3] ) {
pointFlags |= ( 1 << (j*2+1));
}
}
pointAnd &= pointFlags;
pointOr |= pointFlags;
}
// trivially reject
if ( pointAnd ) {
return true;
}
// backface and frustum cull
numTriangles = tri->numIndexes / 3;
R_GlobalPointToLocal( drawSurf->space->modelMatrix, tr.viewDef->renderView.vieworg, localView );
for ( i = 0; i < tri->numIndexes; i += 3 ) {
idVec3 dir, normal;
float dot;
idVec3 d1, d2;
const idVec3 &v1 = tri->verts[tri->indexes[i]].xyz;
const idVec3 &v2 = tri->verts[tri->indexes[i+1]].xyz;
const idVec3 &v3 = tri->verts[tri->indexes[i+2]].xyz;
// this is a hack, because R_GlobalPointToLocal doesn't work with the non-normalized
// axis that we get from the gui view transform. It doesn't hurt anything, because
// we know that all gui generated surfaces are front facing
if ( tr.guiRecursionLevel == 0 ) {
// we don't care that it isn't normalized,
// all we want is the sign
d1 = v2 - v1;
d2 = v3 - v1;
normal = d2.Cross( d1 );
dir = v1 - localView;
dot = normal * dir;
if ( dot >= 0.0f ) {
return true;
}
}
// now find the exact screen bounds of the clipped triangle
w.SetNumPoints( 3 );
R_LocalPointToGlobal( drawSurf->space->modelMatrix, v1, w[0].ToVec3() );
R_LocalPointToGlobal( drawSurf->space->modelMatrix, v2, w[1].ToVec3() );
R_LocalPointToGlobal( drawSurf->space->modelMatrix, v3, w[2].ToVec3() );
w[0].s = w[0].t = w[1].s = w[1].t = w[2].s = w[2].t = 0.0f;
for ( j = 0; j < 4; j++ ) {
if ( !w.ClipInPlace( -tr.viewDef->frustum[j], 0.1f ) ) {
break;
}
}
for ( j = 0; j < w.GetNumPoints(); j++ ) {
idVec3 screen;
R_GlobalToNormalizedDeviceCoordinates( w[j].ToVec3(), screen );
ndcBounds.AddPoint( screen );
}
}
// if we don't enclose any area, return
if ( ndcBounds.IsCleared() ) {
return true;
}
return false;
}
/*
====================
idInteraction::CreateInteraction
Called when a entityDef and a lightDef are both present in a
portalArea, and might be visible. Performs cull checking before doing the expensive
computations.
References tr.viewCount so lighting surfaces will only be created if the ambient surface is visible,
otherwise it will be marked as deferred.
The results of this are cached and valid until the light or entity change.
====================
*/
void idInteraction::CreateInteraction( const idRenderModel *model ) {
const idMaterial * lightShader = lightDef->lightShader;
const idMaterial* shader;
bool interactionGenerated;
idBounds bounds;
tr.pc.c_createInteractions++;
bounds = model->Bounds( &entityDef->parms );
// if it doesn't contact the light frustum, none of the surfaces will
if ( R_CullLocalBox( bounds, entityDef->modelMatrix, 6, lightDef->frustum ) ) {
MakeEmpty();
return;
}
// ---> sikk - Ambient light culling (entities)
#ifndef _SIKKBC
if ( lightDef->parms.ambient && !model->IsStaticWorldModel() ) {
idVec3 center, org;
center = ( entityDef->parms.bounds[0] + entityDef->parms.bounds[1] ) * 0.5;
R_LocalPointToGlobal( entityDef->modelMatrix, center, org );
// center = center + entityDef->parms.origin;
org = entityDef->parms.ambLightUseCenter ? org : entityDef->parms.origin;
if ( lightDef->world->PointInArea( org ) != lightDef->areaNum ) {
MakeEmpty();
return;
}
}
#endif _SIKKBC
// <--- sikk - Ambient light culling
// use the turbo shadow path
shadowGen_t shadowGen = SG_DYNAMIC;
// really large models, like outside terrain meshes, should use
// the more exactly culled static shadow path instead of the turbo shadow path.
// FIXME: this is a HACK, we should probably have a material flag.
if ( bounds[1][0] - bounds[0][0] > 3000 ) {
shadowGen = SG_STATIC;
}
//
// create slots for each of the model's surfaces
//
numSurfaces = model->NumSurfaces();
surfaces = (surfaceInteraction_t *)R_ClearedStaticAlloc( sizeof( *surfaces ) * numSurfaces );
interactionGenerated = false;
// check each surface in the model
for ( int c = 0 ; c < model->NumSurfaces() ; c++ ) {
const modelSurface_t *surf;
srfTriangles_t *tri;
surf = model->Surface( c );
tri = surf->geometry;
if ( !tri ) {
continue;
}
// determine the shader for this surface, possibly by skinning
shader = surf->shader;
shader = R_RemapShaderBySkin( shader, entityDef->parms.customSkin, entityDef->parms.customShader );
if ( !shader ) {
continue;
}
// try to cull each surface
if ( R_CullLocalBox( tri->bounds, entityDef->modelMatrix, 6, lightDef->frustum ) ) {
continue;
}
// ---> sikk - Ambient light culling (world surfaces)
#ifndef _SIKKBC
if ( lightDef->parms.ambient && model->IsStaticWorldModel() ) {
idStr temp = model->Name(); // the rendermodel name for static world is the areaNum
temp.StripLeadingOnce( "_area" ); // strip _area so we just have the number
if ( atoi( temp.c_str() ) != lightDef->areaNum ) {
continue;
}
}
#endif _SIKKBC
// <--- sikk - Ambient light culling
surfaceInteraction_t *sint = &surfaces[c];
sint->shader = shader;
// save the ambient tri pointer so we can reject lightTri interactions
// when the ambient surface isn't in view, and we can get shared vertex
// and shadow data from the source surface
sint->ambientTris = tri;
// "invisible ink" lights and shaders
if ( shader->Spectrum() != lightShader->Spectrum() ) {
continue;
}
// generate a lighted surface and add it
if ( shader->ReceivesLighting() || lightShader->IsFogLight() ) { // sikk - fogLight fix: added "|| lightShader->IsFogLight()" - ambient surfaces are now fogged
if ( tri->ambientViewCount == tr.viewCount && !lightShader->IsFogLight()) { // sikk - fogLight fix: "&& !lightShader->IsFogLight()" - this keeps lit surfaces from fogging twice (or at least being created twice...I think)
sint->lightTris = R_CreateLightTris( entityDef, tri, lightDef, shader, sint->cullInfo );
} else {
// this will be calculated when sint->ambientTris is actually in view
sint->lightTris = LIGHT_TRIS_DEFERRED;
}
interactionGenerated = true;
}
// if the interaction has shadows and this surface casts a shadow
if ( HasShadows() && shader->SurfaceCastsShadow() && tri->silEdges != NULL ) {
// if the light has an optimized shadow volume, don't create shadows for any models that are part of the base areas
if ( lightDef->parms.prelightModel == NULL || !model->IsStaticWorldModel() || !r_useOptimizedShadows.GetBool() ) {
// this is the only place during gameplay (outside the utilities) that R_CreateShadowVolume() is called
sint->shadowTris = R_CreateShadowVolume( entityDef, tri, lightDef, shadowGen, sint->cullInfo );
if ( sint->shadowTris ) {
if ( shader->Coverage() != MC_OPAQUE || ( !r_skipSuppress.GetBool() && entityDef->parms.suppressSurfaceInViewID ) ) {
// if any surface is a shadow-casting perforated or translucent surface, or the
// base surface is suppressed in the view (world weapon shadows) we can't use
// the external shadow optimizations because we can see through some of the faces
sint->shadowTris->numShadowIndexesNoCaps = sint->shadowTris->numIndexes;
sint->shadowTris->numShadowIndexesNoFrontCaps = sint->shadowTris->numIndexes;
}
}
interactionGenerated = true;
}
}
// free the cull information when it's no longer needed
if ( sint->lightTris != LIGHT_TRIS_DEFERRED ) {
R_FreeInteractionCullInfo( sint->cullInfo );
}
}
// if none of the surfaces generated anything, don't even bother checking?
if ( !interactionGenerated ) {
MakeEmpty();
}
}
/*
==================
R_WobbleskyTexGen
==================
*/
void R_WobbleskyTexGen( drawSurf_t *surf, const idVec3 &viewOrg )
{
idVec3 localViewOrigin;
const int *parms = surf->material->GetTexGenRegisters();
float wobbleDegrees = surf->shaderRegisters[parms[0]];
float wobbleSpeed = surf->shaderRegisters[parms[1]];
float rotateSpeed = surf->shaderRegisters[parms[2]];
wobbleDegrees = wobbleDegrees * idMath::PI / 180;
wobbleSpeed = wobbleSpeed * 2 * idMath::PI / 60;
rotateSpeed = rotateSpeed * 2 * idMath::PI / 60;
// very ad-hoc "wobble" transform
float transform[16];
float a = tr.viewDef->floatTime * wobbleSpeed;
float s = sin( a ) * sin( wobbleDegrees );
float c = cos( a ) * sin( wobbleDegrees );
float z = cos( wobbleDegrees );
idVec3 axis[3];
axis[2][0] = c;
axis[2][1] = s;
axis[2][2] = z;
axis[1][0] = -sin( a * 2 ) * sin( wobbleDegrees );
axis[1][2] = -s * sin( wobbleDegrees );
axis[1][1] = sqrt( 1.0f - ( axis[1][0] * axis[1][0] + axis[1][2] * axis[1][2] ) );
// make the second vector exactly perpendicular to the first
axis[1] -= ( axis[2] * axis[1] ) * axis[2];
axis[1].Normalize();
// construct the third with a cross
axis[0].Cross( axis[1], axis[2] );
// add the rotate
s = sin( rotateSpeed * tr.viewDef->floatTime );
c = cos( rotateSpeed * tr.viewDef->floatTime );
transform[0] = axis[0][0] * c + axis[1][0] * s;
transform[4] = axis[0][1] * c + axis[1][1] * s;
transform[8] = axis[0][2] * c + axis[1][2] * s;
transform[1] = axis[1][0] * c - axis[0][0] * s;
transform[5] = axis[1][1] * c - axis[0][1] * s;
transform[9] = axis[1][2] * c - axis[0][2] * s;
transform[2] = axis[2][0];
transform[6] = axis[2][1];
transform[10] = axis[2][2];
transform[3] = transform[7] = transform[11] = 0.0f;
transform[12] = transform[13] = transform[14] = 0.0f;
R_GlobalPointToLocal( surf->space->modelMatrix, viewOrg, localViewOrigin );
int numVerts = surf->geo->numVerts;
int size = numVerts * sizeof( idVec3 );
idVec3 *texCoords = ( idVec3 * ) _alloca16( size );
const idDrawVert *verts = surf->geo->verts;
for( int i = 0; i < numVerts; i++ )
{
idVec3 v;
v[0] = verts[i].xyz[0] - localViewOrigin[0];
v[1] = verts[i].xyz[1] - localViewOrigin[1];
v[2] = verts[i].xyz[2] - localViewOrigin[2];
R_LocalPointToGlobal( transform, v, texCoords[i] );
}
surf->dynamicTexCoords = vertexCache.AllocFrameTemp( texCoords, size );
}
/*
========================
R_MirrorViewBySurface
========================
*/
static viewDef_t* R_MirrorViewBySurface( const drawSurf_t* drawSurf )
{
// copy the viewport size from the original
viewDef_t* parms = ( viewDef_t* )R_FrameAlloc( sizeof( *parms ) );
*parms = *tr.viewDef;
parms->renderView.viewID = 0; // clear to allow player bodies to show up, and suppress view weapons
parms->isSubview = true;
parms->isMirror = true;
parms->isObliqueProjection = false;
// create plane axis for the portal we are seeing
idPlane originalPlane, plane;
R_PlaneForSurface( drawSurf->frontEndGeo, originalPlane );
R_LocalPlaneToGlobal( drawSurf->space->modelMatrix, originalPlane, plane );
orientation_t surface;
surface.origin = plane.Normal() * -plane[3];
surface.axis[0] = plane.Normal();
surface.axis[0].NormalVectors( surface.axis[1], surface.axis[2] );
surface.axis[2] = -surface.axis[2];
orientation_t camera;
camera.origin = surface.origin;
camera.axis[0] = -surface.axis[0];
camera.axis[1] = surface.axis[1];
camera.axis[2] = surface.axis[2];
// set the mirrored origin and axis
R_MirrorPoint( tr.viewDef->renderView.vieworg, &surface, &camera, parms->renderView.vieworg );
R_MirrorVector( tr.viewDef->renderView.viewaxis[0], &surface, &camera, parms->renderView.viewaxis[0] );
R_MirrorVector( tr.viewDef->renderView.viewaxis[1], &surface, &camera, parms->renderView.viewaxis[1] );
R_MirrorVector( tr.viewDef->renderView.viewaxis[2], &surface, &camera, parms->renderView.viewaxis[2] );
// make the view origin 16 units away from the center of the surface
const idVec3 center = (drawSurf->frontEndGeo->bounds[0] + drawSurf->frontEndGeo->bounds[1]) * 0.5f;
const idVec3 viewOrigin = center + (originalPlane.Normal() * 16.0f);
R_LocalPointToGlobal(drawSurf->space->modelMatrix, viewOrigin, parms->initialViewAreaOrigin);
// set the mirror clip plane
parms->numClipPlanes = 1;
parms->clipPlanes[0] = -camera.axis[0];
parms->clipPlanes[0][3] = -( camera.origin * parms->clipPlanes[0].Normal() );
if (r_waterReflectFix.GetBool() && !parms->is2Dgui && drawSurf->material->GetSurfaceType() == SURFTYPE_MIRROR)
{
parms->isObliqueProjection = true;
float dist = parms->clipPlanes[0].Dist();
float viewdist = parms->renderView.vieworg * parms->clipPlanes[0].Normal();
float fDist = -dist + viewdist;
static const float fudge = 2.f; //fudge avoids depth precision artifacts when performing oblique projection
if (fDist > fudge || fDist < -fudge)
{
if (fDist < 0.f)
fDist += fudge;
else
fDist -= fudge;
}
parms->clipPlanes[0][3] = fDist;
R_SetupViewMatrix(parms);
R_SetupProjectionMatrix(parms);
R_ObliqueProjection(parms);
}
return parms;
}
/*
=========================
R_PreciseCullSurface
Check the surface for visibility on a per-triangle basis
for cases when it is going to be VERY expensive to draw (subviews)
If not culled, also returns the bounding box of the surface in
Normalized Device Coordinates, so it can be used to crop the scissor rect.
OPTIMIZE: we could also take exact portal passing into consideration
=========================
*/
bool R_PreciseCullSurface( const drawSurf_t* drawSurf, idBounds& ndcBounds )
{
const srfTriangles_t* tri = drawSurf->frontEndGeo;
unsigned int pointOr = 0;
unsigned int pointAnd = ( unsigned int )~0;
// get an exact bounds of the triangles for scissor cropping
ndcBounds.Clear();
const idJointMat* joints = ( tri->staticModelWithJoints != NULL && r_useGPUSkinning.GetBool() ) ? tri->staticModelWithJoints->jointsInverted : NULL;
for( int i = 0; i < tri->numVerts; i++ )
{
const idVec3 vXYZ = idDrawVert::GetSkinnedDrawVertPosition( tri->verts[i], joints );
idPlane eye, clip;
R_TransformModelToClip( vXYZ, drawSurf->space->modelViewMatrix, tr.viewDef->projectionMatrix, eye, clip );
unsigned int pointFlags = 0;
for( int j = 0; j < 3; j++ )
{
if( clip[j] >= clip[3] )
{
pointFlags |= ( 1 << ( j * 2 + 0 ) );
}
else if( clip[j] <= -clip[3] ) // FIXME: the D3D near clip plane is at zero instead of -1
{
pointFlags |= ( 1 << ( j * 2 + 1 ) );
}
}
pointAnd &= pointFlags;
pointOr |= pointFlags;
}
// trivially reject
if( pointAnd != 0 )
{
return true;
}
// backface and frustum cull
idVec3 localViewOrigin;
R_GlobalPointToLocal( drawSurf->space->modelMatrix, tr.viewDef->renderView.vieworg, localViewOrigin );
for( int i = 0; i < tri->numIndexes; i += 3 )
{
const idVec3 v1 = idDrawVert::GetSkinnedDrawVertPosition( tri->verts[ tri->indexes[ i + 0 ] ], joints );
const idVec3 v2 = idDrawVert::GetSkinnedDrawVertPosition( tri->verts[ tri->indexes[ i + 1 ] ], joints );
const idVec3 v3 = idDrawVert::GetSkinnedDrawVertPosition( tri->verts[ tri->indexes[ i + 2 ] ], joints );
// this is a hack, because R_GlobalPointToLocal doesn't work with the non-normalized
// axis that we get from the gui view transform. It doesn't hurt anything, because
// we know that all gui generated surfaces are front facing
if( tr.guiRecursionLevel == 0 )
{
// we don't care that it isn't normalized,
// all we want is the sign
const idVec3 d1 = v2 - v1;
const idVec3 d2 = v3 - v1;
const idVec3 normal = d2.Cross( d1 );
const idVec3 dir = v1 - localViewOrigin;
const float dot = normal * dir;
if( dot >= 0.0f )
{
return true;
}
}
// now find the exact screen bounds of the clipped triangle
idFixedWinding w;
w.SetNumPoints( 3 );
R_LocalPointToGlobal( drawSurf->space->modelMatrix, v1, w[0].ToVec3() );
R_LocalPointToGlobal( drawSurf->space->modelMatrix, v2, w[1].ToVec3() );
R_LocalPointToGlobal( drawSurf->space->modelMatrix, v3, w[2].ToVec3() );
w[0].s = w[0].t = w[1].s = w[1].t = w[2].s = w[2].t = 0.0f;
for( int j = 0; j < 4; j++ )
{
if( !w.ClipInPlace( -tr.viewDef->frustums[FRUSTUM_PRIMARY][j], 0.1f ) )
{
break;
}
}
for( int j = 0; j < w.GetNumPoints(); j++ )
{
idVec3 screen;
R_GlobalToNormalizedDeviceCoordinates( w[j].ToVec3(), screen );
ndcBounds.AddPoint( screen );
}
}
// if we don't enclose any area, return
if( ndcBounds.IsCleared() )
{
return true;
}
return false;
}