mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-26 06:11:26 +00:00
736ec20d4d
Don't include the lazy precompiled.h everywhere, only what's required for the compilation unit. platform.h needs to be included instead to provide all essential defines and types. All includes use the relative path to the neo or the game specific root. Move all idlib related includes from idlib/Lib.h to precompiled.h. precompiled.h still exists for the MFC stuff in tools/. Add some missing header guards.
1310 lines
39 KiB
C++
1310 lines
39 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code 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.
|
|
|
|
Doom 3 Source Code 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.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "sys/platform.h"
|
|
#include "renderer/tr_local.h"
|
|
#include "renderer/RenderWorld_local.h"
|
|
#include "renderer/VertexCache.h"
|
|
|
|
#include "renderer/Interaction.h"
|
|
|
|
/*
|
|
===========================================================================
|
|
|
|
idInteraction implementation
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
// FIXME: use private allocator for srfCullInfo_t
|
|
|
|
/*
|
|
================
|
|
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 ) {
|
|
idVec3 localLightOrigin;
|
|
|
|
if ( cullInfo.facing != NULL ) {
|
|
return;
|
|
}
|
|
|
|
R_GlobalPointToLocal( ent->modelMatrix, light->globalLightOrigin, localLightOrigin );
|
|
|
|
int numFaces = tri->numIndexes / 3;
|
|
|
|
if ( !tri->facePlanes || !tri->facePlanesCalculated ) {
|
|
R_DeriveFacePlanes( const_cast<srfTriangles_t *>(tri) );
|
|
}
|
|
|
|
cullInfo.facing = (byte *) R_StaticAlloc( ( numFaces + 1 ) * sizeof( cullInfo.facing[0] ) );
|
|
|
|
// calculate back face culling
|
|
float *planeSide = (float *) _alloca16( numFaces * sizeof( float ) );
|
|
|
|
// exact geometric cull against face
|
|
SIMDProcessor->Dot( planeSide, localLightOrigin, tri->facePlanes, numFaces );
|
|
SIMDProcessor->CmpGE( cullInfo.facing, planeSide, 0.0f, numFaces );
|
|
|
|
cullInfo.facing[ numFaces ] = 1; // for dangling edges to reference
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
R_CalcInteractionCullBits
|
|
|
|
We want to cull a little on the sloppy side, because the pre-clipping
|
|
of geometry to the lights in dmap will give many cases that are right
|
|
at the border we throw things out on the border, because if any one
|
|
vertex is clearly inside, the entire triangle will be accepted.
|
|
=====================
|
|
*/
|
|
void R_CalcInteractionCullBits( const idRenderEntityLocal *ent, const srfTriangles_t *tri, const idRenderLightLocal *light, srfCullInfo_t &cullInfo ) {
|
|
int i, frontBits;
|
|
|
|
if ( cullInfo.cullBits != NULL ) {
|
|
return;
|
|
}
|
|
|
|
frontBits = 0;
|
|
|
|
// cull the triangle surface bounding box
|
|
for ( i = 0; i < 6; i++ ) {
|
|
|
|
R_GlobalPlaneToLocal( ent->modelMatrix, -light->frustum[i], cullInfo.localClipPlanes[i] );
|
|
|
|
// get front bits for the whole surface
|
|
if ( tri->bounds.PlaneDistance( cullInfo.localClipPlanes[i] ) >= LIGHT_CLIP_EPSILON ) {
|
|
frontBits |= 1<<i;
|
|
}
|
|
}
|
|
|
|
// if the surface is completely inside the light frustum
|
|
if ( frontBits == ( ( 1 << 6 ) - 1 ) ) {
|
|
cullInfo.cullBits = LIGHT_CULL_ALL_FRONT;
|
|
return;
|
|
}
|
|
|
|
cullInfo.cullBits = (byte *) R_StaticAlloc( tri->numVerts * sizeof( cullInfo.cullBits[0] ) );
|
|
SIMDProcessor->Memset( cullInfo.cullBits, 0, tri->numVerts * sizeof( cullInfo.cullBits[0] ) );
|
|
|
|
float *planeSide = (float *) _alloca16( tri->numVerts * sizeof( float ) );
|
|
|
|
for ( i = 0; i < 6; i++ ) {
|
|
// if completely infront of this clipping plane
|
|
if ( frontBits & ( 1 << i ) ) {
|
|
continue;
|
|
}
|
|
SIMDProcessor->Dot( planeSide, cullInfo.localClipPlanes[i], tri->verts, tri->numVerts );
|
|
SIMDProcessor->CmpLT( cullInfo.cullBits, i, planeSide, LIGHT_CLIP_EPSILON, tri->numVerts );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_FreeInteractionCullInfo
|
|
================
|
|
*/
|
|
void R_FreeInteractionCullInfo( srfCullInfo_t &cullInfo ) {
|
|
if ( cullInfo.facing != NULL ) {
|
|
R_StaticFree( cullInfo.facing );
|
|
cullInfo.facing = NULL;
|
|
}
|
|
if ( cullInfo.cullBits != NULL ) {
|
|
if ( cullInfo.cullBits != LIGHT_CULL_ALL_FRONT ) {
|
|
R_StaticFree( cullInfo.cullBits );
|
|
}
|
|
cullInfo.cullBits = NULL;
|
|
}
|
|
}
|
|
|
|
#define MAX_CLIPPED_POINTS 20
|
|
typedef struct {
|
|
int numVerts;
|
|
idVec3 verts[MAX_CLIPPED_POINTS];
|
|
} clipTri_t;
|
|
|
|
/*
|
|
=============
|
|
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;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_ClipTriangleToLight
|
|
|
|
Returns false if nothing is left after clipping
|
|
===================
|
|
*/
|
|
static bool R_ClipTriangleToLight( const idVec3 &a, const idVec3 &b, const idVec3 &c, int planeBits, const idPlane frustum[6] ) {
|
|
int i;
|
|
clipTri_t pingPong[2];
|
|
int p;
|
|
|
|
pingPong[0].numVerts = 3;
|
|
pingPong[0].verts[0] = a;
|
|
pingPong[0].verts[1] = b;
|
|
pingPong[0].verts[2] = c;
|
|
|
|
p = 0;
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
if ( planeBits & ( 1 << i ) ) {
|
|
p = R_ChopWinding( pingPong, p, frustum[i] );
|
|
if ( pingPong[p].numVerts < 1 ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
R_CreateLightTris
|
|
|
|
The resulting surface will be a subset of the original triangles,
|
|
it will never clip triangles, but it may cull on a per-triangle basis.
|
|
====================
|
|
*/
|
|
static srfTriangles_t *R_CreateLightTris( const idRenderEntityLocal *ent,
|
|
const srfTriangles_t *tri, const idRenderLightLocal *light,
|
|
const idMaterial *shader, srfCullInfo_t &cullInfo ) {
|
|
int i;
|
|
int numIndexes;
|
|
glIndex_t *indexes;
|
|
srfTriangles_t *newTri;
|
|
int c_backfaced;
|
|
int c_distance;
|
|
idBounds bounds;
|
|
bool includeBackFaces;
|
|
int faceNum;
|
|
|
|
tr.pc.c_createLightTris++;
|
|
c_backfaced = 0;
|
|
c_distance = 0;
|
|
|
|
numIndexes = 0;
|
|
indexes = NULL;
|
|
|
|
// it is debatable if non-shadowing lights should light back faces. we aren't at the moment
|
|
if ( r_lightAllBackFaces.GetBool() || light->lightShader->LightEffectsBackSides()
|
|
|| shader->ReceivesLightingOnBackSides()
|
|
|| ent->parms.noSelfShadow || ent->parms.noShadow ) {
|
|
includeBackFaces = true;
|
|
} else {
|
|
includeBackFaces = false;
|
|
}
|
|
|
|
// allocate a new surface for the lit triangles
|
|
newTri = R_AllocStaticTriSurf();
|
|
|
|
// save a reference to the original surface
|
|
newTri->ambientSurface = const_cast<srfTriangles_t *>(tri);
|
|
|
|
// the light surface references the verts of the ambient surface
|
|
newTri->numVerts = tri->numVerts;
|
|
R_ReferenceStaticTriSurfVerts( newTri, tri );
|
|
|
|
// calculate cull information
|
|
if ( !includeBackFaces ) {
|
|
R_CalcInteractionFacing( ent, tri, light, cullInfo );
|
|
}
|
|
R_CalcInteractionCullBits( ent, tri, light, cullInfo );
|
|
|
|
// if the surface is completely inside the light frustum
|
|
if ( cullInfo.cullBits == LIGHT_CULL_ALL_FRONT ) {
|
|
|
|
// if we aren't self shadowing, let back facing triangles get
|
|
// through so the smooth shaded bump maps light all the way around
|
|
if ( includeBackFaces ) {
|
|
|
|
// the whole surface is lit so the light surface just references the indexes of the ambient surface
|
|
R_ReferenceStaticTriSurfIndexes( newTri, tri );
|
|
numIndexes = tri->numIndexes;
|
|
bounds = tri->bounds;
|
|
|
|
} else {
|
|
|
|
// the light tris indexes are going to be a subset of the original indexes so we generally
|
|
// allocate too much memory here but we decrease the memory block when the number of indexes is known
|
|
R_AllocStaticTriSurfIndexes( newTri, tri->numIndexes );
|
|
|
|
// back face cull the individual triangles
|
|
indexes = newTri->indexes;
|
|
const byte *facing = cullInfo.facing;
|
|
for ( faceNum = i = 0; i < tri->numIndexes; i += 3, faceNum++ ) {
|
|
if ( !facing[ faceNum ] ) {
|
|
c_backfaced++;
|
|
continue;
|
|
}
|
|
indexes[numIndexes+0] = tri->indexes[i+0];
|
|
indexes[numIndexes+1] = tri->indexes[i+1];
|
|
indexes[numIndexes+2] = tri->indexes[i+2];
|
|
numIndexes += 3;
|
|
}
|
|
|
|
// get bounds for the surface
|
|
SIMDProcessor->MinMax( bounds[0], bounds[1], tri->verts, indexes, numIndexes );
|
|
|
|
// decrease the size of the memory block to the size of the number of used indexes
|
|
R_ResizeStaticTriSurfIndexes( newTri, numIndexes );
|
|
}
|
|
|
|
} else {
|
|
|
|
// the light tris indexes are going to be a subset of the original indexes so we generally
|
|
// allocate too much memory here but we decrease the memory block when the number of indexes is known
|
|
R_AllocStaticTriSurfIndexes( newTri, tri->numIndexes );
|
|
|
|
// cull individual triangles
|
|
indexes = newTri->indexes;
|
|
const byte *facing = cullInfo.facing;
|
|
const byte *cullBits = cullInfo.cullBits;
|
|
for ( faceNum = i = 0; i < tri->numIndexes; i += 3, faceNum++ ) {
|
|
int i1, i2, i3;
|
|
|
|
// if we aren't self shadowing, let back facing triangles get
|
|
// through so the smooth shaded bump maps light all the way around
|
|
if ( !includeBackFaces ) {
|
|
// back face cull
|
|
if ( !facing[ faceNum ] ) {
|
|
c_backfaced++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
i1 = tri->indexes[i+0];
|
|
i2 = tri->indexes[i+1];
|
|
i3 = tri->indexes[i+2];
|
|
|
|
// fast cull outside the frustum
|
|
// if all three points are off one plane side, it definately isn't visible
|
|
if ( cullBits[i1] & cullBits[i2] & cullBits[i3] ) {
|
|
c_distance++;
|
|
continue;
|
|
}
|
|
|
|
if ( r_usePreciseTriangleInteractions.GetBool() ) {
|
|
// do a precise clipped cull if none of the points is completely inside the frustum
|
|
// note that we do not actually use the clipped triangle, which would have Z fighting issues.
|
|
if ( cullBits[i1] && cullBits[i2] && cullBits[i3] ) {
|
|
int cull = cullBits[i1] | cullBits[i2] | cullBits[i3];
|
|
if ( !R_ClipTriangleToLight( tri->verts[i1].xyz, tri->verts[i2].xyz, tri->verts[i3].xyz, cull, cullInfo.localClipPlanes ) ) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// add to the list
|
|
indexes[numIndexes+0] = i1;
|
|
indexes[numIndexes+1] = i2;
|
|
indexes[numIndexes+2] = i3;
|
|
numIndexes += 3;
|
|
}
|
|
|
|
// get bounds for the surface
|
|
SIMDProcessor->MinMax( bounds[0], bounds[1], tri->verts, indexes, numIndexes );
|
|
|
|
// decrease the size of the memory block to the size of the number of used indexes
|
|
R_ResizeStaticTriSurfIndexes( newTri, numIndexes );
|
|
}
|
|
|
|
if ( !numIndexes ) {
|
|
R_ReallyFreeStaticTriSurf( newTri );
|
|
return NULL;
|
|
}
|
|
|
|
newTri->numIndexes = numIndexes;
|
|
|
|
newTri->bounds = bounds;
|
|
|
|
return newTri;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idInteraction::idInteraction
|
|
===============
|
|
*/
|
|
idInteraction::idInteraction( void ) {
|
|
numSurfaces = 0;
|
|
surfaces = NULL;
|
|
entityDef = NULL;
|
|
lightDef = NULL;
|
|
lightNext = NULL;
|
|
lightPrev = NULL;
|
|
entityNext = NULL;
|
|
entityPrev = NULL;
|
|
dynamicModelFrameCount = 0;
|
|
frustumState = FRUSTUM_UNINITIALIZED;
|
|
frustumAreas = NULL;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idInteraction::AllocAndLink
|
|
===============
|
|
*/
|
|
idInteraction *idInteraction::AllocAndLink( idRenderEntityLocal *edef, idRenderLightLocal *ldef ) {
|
|
if ( !edef || !ldef ) {
|
|
common->Error( "idInteraction::AllocAndLink: NULL parm" );
|
|
}
|
|
|
|
idRenderWorldLocal *renderWorld = edef->world;
|
|
|
|
idInteraction *interaction = renderWorld->interactionAllocator.Alloc();
|
|
|
|
// link and initialize
|
|
interaction->dynamicModelFrameCount = 0;
|
|
|
|
interaction->lightDef = ldef;
|
|
interaction->entityDef = edef;
|
|
|
|
interaction->numSurfaces = -1; // not checked yet
|
|
interaction->surfaces = NULL;
|
|
|
|
interaction->frustumState = idInteraction::FRUSTUM_UNINITIALIZED;
|
|
interaction->frustumAreas = NULL;
|
|
|
|
// link at the start of the entity's list
|
|
interaction->lightNext = ldef->firstInteraction;
|
|
interaction->lightPrev = NULL;
|
|
ldef->firstInteraction = interaction;
|
|
if ( interaction->lightNext != NULL ) {
|
|
interaction->lightNext->lightPrev = interaction;
|
|
} else {
|
|
ldef->lastInteraction = interaction;
|
|
}
|
|
|
|
// link at the start of the light's list
|
|
interaction->entityNext = edef->firstInteraction;
|
|
interaction->entityPrev = NULL;
|
|
edef->firstInteraction = interaction;
|
|
if ( interaction->entityNext != NULL ) {
|
|
interaction->entityNext->entityPrev = interaction;
|
|
} else {
|
|
edef->lastInteraction = interaction;
|
|
}
|
|
|
|
// update the interaction table
|
|
if ( renderWorld->interactionTable ) {
|
|
int index = ldef->index * renderWorld->interactionTableWidth + edef->index;
|
|
if ( renderWorld->interactionTable[index] != NULL ) {
|
|
common->Error( "idInteraction::AllocAndLink: non NULL table entry" );
|
|
}
|
|
renderWorld->interactionTable[ index ] = interaction;
|
|
}
|
|
|
|
return interaction;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idInteraction::FreeSurfaces
|
|
|
|
Frees the surfaces, but leaves the interaction linked in, so it
|
|
will be regenerated automatically
|
|
===============
|
|
*/
|
|
void idInteraction::FreeSurfaces( void ) {
|
|
if ( this->surfaces ) {
|
|
for ( int i = 0 ; i < this->numSurfaces ; i++ ) {
|
|
surfaceInteraction_t *sint = &this->surfaces[i];
|
|
|
|
if ( sint->lightTris ) {
|
|
if ( sint->lightTris != LIGHT_TRIS_DEFERRED ) {
|
|
R_FreeStaticTriSurf( sint->lightTris );
|
|
}
|
|
sint->lightTris = NULL;
|
|
}
|
|
if ( sint->shadowTris ) {
|
|
// if it doesn't have an entityDef, it is part of a prelight
|
|
// model, not a generated interaction
|
|
if ( this->entityDef ) {
|
|
R_FreeStaticTriSurf( sint->shadowTris );
|
|
sint->shadowTris = NULL;
|
|
}
|
|
}
|
|
R_FreeInteractionCullInfo( sint->cullInfo );
|
|
}
|
|
|
|
R_StaticFree( this->surfaces );
|
|
this->surfaces = NULL;
|
|
}
|
|
this->numSurfaces = -1;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idInteraction::Unlink
|
|
===============
|
|
*/
|
|
void idInteraction::Unlink( void ) {
|
|
|
|
// unlink from the entity's list
|
|
if ( this->entityPrev ) {
|
|
this->entityPrev->entityNext = this->entityNext;
|
|
} else {
|
|
this->entityDef->firstInteraction = this->entityNext;
|
|
}
|
|
if ( this->entityNext ) {
|
|
this->entityNext->entityPrev = this->entityPrev;
|
|
} else {
|
|
this->entityDef->lastInteraction = this->entityPrev;
|
|
}
|
|
this->entityNext = this->entityPrev = NULL;
|
|
|
|
// unlink from the light's list
|
|
if ( this->lightPrev ) {
|
|
this->lightPrev->lightNext = this->lightNext;
|
|
} else {
|
|
this->lightDef->firstInteraction = this->lightNext;
|
|
}
|
|
if ( this->lightNext ) {
|
|
this->lightNext->lightPrev = this->lightPrev;
|
|
} else {
|
|
this->lightDef->lastInteraction = this->lightPrev;
|
|
}
|
|
this->lightNext = this->lightPrev = NULL;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idInteraction::UnlinkAndFree
|
|
|
|
Removes links and puts it back on the free list.
|
|
===============
|
|
*/
|
|
void idInteraction::UnlinkAndFree( void ) {
|
|
|
|
// clear the table pointer
|
|
idRenderWorldLocal *renderWorld = this->lightDef->world;
|
|
if ( renderWorld->interactionTable ) {
|
|
int index = this->lightDef->index * renderWorld->interactionTableWidth + this->entityDef->index;
|
|
if ( renderWorld->interactionTable[index] != this ) {
|
|
common->Error( "idInteraction::UnlinkAndFree: interactionTable wasn't set" );
|
|
}
|
|
renderWorld->interactionTable[index] = NULL;
|
|
}
|
|
|
|
Unlink();
|
|
|
|
FreeSurfaces();
|
|
|
|
// free the interaction area references
|
|
areaNumRef_t *area, *nextArea;
|
|
for ( area = frustumAreas; area; area = nextArea ) {
|
|
nextArea = area->next;
|
|
renderWorld->areaNumRefAllocator.Free( area );
|
|
}
|
|
|
|
// put it back on the free list
|
|
renderWorld->interactionAllocator.Free( this );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idInteraction::MakeEmpty
|
|
|
|
Makes the interaction empty and links it at the end of the entity's and light's interaction lists.
|
|
===============
|
|
*/
|
|
void idInteraction::MakeEmpty( void ) {
|
|
|
|
// an empty interaction has no surfaces
|
|
numSurfaces = 0;
|
|
|
|
Unlink();
|
|
|
|
// relink at the end of the entity's list
|
|
this->entityNext = NULL;
|
|
this->entityPrev = this->entityDef->lastInteraction;
|
|
this->entityDef->lastInteraction = this;
|
|
if ( this->entityPrev ) {
|
|
this->entityPrev->entityNext = this;
|
|
} else {
|
|
this->entityDef->firstInteraction = this;
|
|
}
|
|
|
|
// relink at the end of the light's list
|
|
this->lightNext = NULL;
|
|
this->lightPrev = this->lightDef->lastInteraction;
|
|
this->lightDef->lastInteraction = this;
|
|
if ( this->lightPrev ) {
|
|
this->lightPrev->lightNext = this;
|
|
} else {
|
|
this->lightDef->firstInteraction = this;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idInteraction::HasShadows
|
|
===============
|
|
*/
|
|
ID_INLINE bool idInteraction::HasShadows( void ) const {
|
|
return ( !lightDef->parms.noShadows && !entityDef->parms.noShadow && lightDef->lightShader->LightCastsShadows() );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idInteraction::MemoryUsed
|
|
|
|
Counts up the memory used by all the surfaceInteractions, which
|
|
will be used to determine when we need to start purging old interactions.
|
|
===============
|
|
*/
|
|
int idInteraction::MemoryUsed( void ) {
|
|
int total = 0;
|
|
|
|
for ( int i = 0 ; i < numSurfaces ; i++ ) {
|
|
surfaceInteraction_t *inter = &surfaces[i];
|
|
|
|
total += R_TriSurfMemory( inter->lightTris );
|
|
total += R_TriSurfMemory( inter->shadowTris );
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idInteraction::CalcInteractionScissorRectangle
|
|
==================
|
|
*/
|
|
idScreenRect idInteraction::CalcInteractionScissorRectangle( const idFrustum &viewFrustum ) {
|
|
idBounds projectionBounds;
|
|
idScreenRect portalRect;
|
|
idScreenRect scissorRect;
|
|
|
|
if ( r_useInteractionScissors.GetInteger() == 0 ) {
|
|
return lightDef->viewLight->scissorRect;
|
|
}
|
|
|
|
if ( r_useInteractionScissors.GetInteger() < 0 ) {
|
|
// this is the code from Cass at nvidia, it is more precise, but slower
|
|
return R_CalcIntersectionScissor( lightDef, entityDef, tr.viewDef );
|
|
}
|
|
|
|
// the following is Mr.E's code
|
|
|
|
// frustum must be initialized and valid
|
|
if ( frustumState == idInteraction::FRUSTUM_UNINITIALIZED || frustumState == idInteraction::FRUSTUM_INVALID ) {
|
|
return lightDef->viewLight->scissorRect;
|
|
}
|
|
|
|
// calculate scissors for the portals through which the interaction is visible
|
|
if ( r_useInteractionScissors.GetInteger() > 1 ) {
|
|
areaNumRef_t *area;
|
|
|
|
if ( frustumState == idInteraction::FRUSTUM_VALID ) {
|
|
// retrieve all the areas the interaction frustum touches
|
|
for ( areaReference_t *ref = entityDef->entityRefs; ref; ref = ref->ownerNext ) {
|
|
area = entityDef->world->areaNumRefAllocator.Alloc();
|
|
area->areaNum = ref->area->areaNum;
|
|
area->next = frustumAreas;
|
|
frustumAreas = area;
|
|
}
|
|
frustumAreas = tr.viewDef->renderWorld->FloodFrustumAreas( frustum, frustumAreas );
|
|
frustumState = idInteraction::FRUSTUM_VALIDAREAS;
|
|
}
|
|
|
|
portalRect.Clear();
|
|
for ( area = frustumAreas; area; area = area->next ) {
|
|
portalRect.Union( entityDef->world->GetAreaScreenRect( area->areaNum ) );
|
|
}
|
|
portalRect.Intersect( lightDef->viewLight->scissorRect );
|
|
} else {
|
|
portalRect = lightDef->viewLight->scissorRect;
|
|
}
|
|
|
|
// early out if the interaction is not visible through any portals
|
|
if ( portalRect.IsEmpty() ) {
|
|
return portalRect;
|
|
}
|
|
|
|
// calculate bounds of the interaction frustum projected into the view frustum
|
|
if ( lightDef->parms.pointLight ) {
|
|
viewFrustum.ClippedProjectionBounds( frustum, idBox( lightDef->parms.origin, lightDef->parms.lightRadius, lightDef->parms.axis ), projectionBounds );
|
|
} else {
|
|
viewFrustum.ClippedProjectionBounds( frustum, idBox( lightDef->frustumTris->bounds ), projectionBounds );
|
|
}
|
|
|
|
if ( projectionBounds.IsCleared() ) {
|
|
return portalRect;
|
|
}
|
|
|
|
// derive a scissor rectangle from the projection bounds
|
|
scissorRect = R_ScreenRectFromViewFrustumBounds( projectionBounds );
|
|
|
|
// intersect with the portal crossing scissor rectangle
|
|
scissorRect.Intersect( portalRect );
|
|
|
|
if ( r_showInteractionScissors.GetInteger() > 0 ) {
|
|
R_ShowColoredScreenRect( scissorRect, lightDef->index );
|
|
}
|
|
|
|
return scissorRect;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idInteraction::CullInteractionByViewFrustum
|
|
===================
|
|
*/
|
|
bool idInteraction::CullInteractionByViewFrustum( const idFrustum &viewFrustum ) {
|
|
|
|
if ( !r_useInteractionCulling.GetBool() ) {
|
|
return false;
|
|
}
|
|
|
|
if ( frustumState == idInteraction::FRUSTUM_INVALID ) {
|
|
return false;
|
|
}
|
|
|
|
if ( frustumState == idInteraction::FRUSTUM_UNINITIALIZED ) {
|
|
|
|
frustum.FromProjection( idBox( entityDef->referenceBounds, entityDef->parms.origin, entityDef->parms.axis ), lightDef->globalLightOrigin, MAX_WORLD_SIZE );
|
|
|
|
if ( !frustum.IsValid() ) {
|
|
frustumState = idInteraction::FRUSTUM_INVALID;
|
|
return false;
|
|
}
|
|
|
|
if ( lightDef->parms.pointLight ) {
|
|
frustum.ConstrainToBox( idBox( lightDef->parms.origin, lightDef->parms.lightRadius, lightDef->parms.axis ) );
|
|
} else {
|
|
frustum.ConstrainToBox( idBox( lightDef->frustumTris->bounds ) );
|
|
}
|
|
|
|
frustumState = idInteraction::FRUSTUM_VALID;
|
|
}
|
|
|
|
if ( !viewFrustum.IntersectsFrustum( frustum ) ) {
|
|
return true;
|
|
}
|
|
|
|
if ( r_showInteractionFrustums.GetInteger() ) {
|
|
static idVec4 colors[] = { colorRed, colorGreen, colorBlue, colorYellow, colorMagenta, colorCyan, colorWhite, colorPurple };
|
|
tr.viewDef->renderWorld->DebugFrustum( colors[lightDef->index & 7], frustum, ( r_showInteractionFrustums.GetInteger() > 1 ) );
|
|
if ( r_showInteractionFrustums.GetInteger() > 2 ) {
|
|
tr.viewDef->renderWorld->DebugBox( colorWhite, idBox( entityDef->referenceBounds, entityDef->parms.origin, entityDef->parms.axis ) );
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
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() ) {
|
|
if ( tri->ambientViewCount == tr.viewCount ) {
|
|
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_PotentiallyInsideInfiniteShadow
|
|
|
|
If we know that we are "off to the side" of an infinite shadow volume,
|
|
we can draw it without caps in zpass mode
|
|
======================
|
|
*/
|
|
static bool R_PotentiallyInsideInfiniteShadow( const srfTriangles_t *occluder,
|
|
const idVec3 &localView, const idVec3 &localLight ) {
|
|
idBounds exp;
|
|
|
|
// expand the bounds to account for the near clip plane, because the
|
|
// view could be mathematically outside, but if the near clip plane
|
|
// chops a volume edge, the zpass rendering would fail.
|
|
float znear = r_znear.GetFloat();
|
|
if ( tr.viewDef->renderView.cramZNear ) {
|
|
znear *= 0.25f;
|
|
}
|
|
float stretch = znear * 2; // in theory, should vary with FOV
|
|
exp[0][0] = occluder->bounds[0][0] - stretch;
|
|
exp[0][1] = occluder->bounds[0][1] - stretch;
|
|
exp[0][2] = occluder->bounds[0][2] - stretch;
|
|
exp[1][0] = occluder->bounds[1][0] + stretch;
|
|
exp[1][1] = occluder->bounds[1][1] + stretch;
|
|
exp[1][2] = occluder->bounds[1][2] + stretch;
|
|
|
|
if ( exp.ContainsPoint( localView ) ) {
|
|
return true;
|
|
}
|
|
if ( exp.ContainsPoint( localLight ) ) {
|
|
return true;
|
|
}
|
|
|
|
// if the ray from localLight to localView intersects a face of the
|
|
// expanded bounds, we will be inside the projection
|
|
|
|
idVec3 ray = localView - localLight;
|
|
|
|
// intersect the ray from the view to the light with the near side of the bounds
|
|
for ( int axis = 0; axis < 3; axis++ ) {
|
|
float d, frac;
|
|
idVec3 hit;
|
|
|
|
if ( localLight[axis] < exp[0][axis] ) {
|
|
if ( localView[axis] < exp[0][axis] ) {
|
|
continue;
|
|
}
|
|
d = exp[0][axis] - localLight[axis];
|
|
frac = d / ray[axis];
|
|
hit = localLight + frac * ray;
|
|
hit[axis] = exp[0][axis];
|
|
} else if ( localLight[axis] > exp[1][axis] ) {
|
|
if ( localView[axis] > exp[1][axis] ) {
|
|
continue;
|
|
}
|
|
d = exp[1][axis] - localLight[axis];
|
|
frac = d / ray[axis];
|
|
hit = localLight + frac * ray;
|
|
hit[axis] = exp[1][axis];
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
if ( exp.ContainsPoint( hit ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// the view is definitely not inside the projected shadow
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idInteraction::AddActiveInteraction
|
|
|
|
Create and add any necessary light and shadow triangles
|
|
|
|
If the model doesn't have any surfaces that need interactions
|
|
with this type of light, it can be skipped, but we might need to
|
|
instantiate the dynamic model to find out
|
|
==================
|
|
*/
|
|
void idInteraction::AddActiveInteraction( void ) {
|
|
viewLight_t * vLight;
|
|
viewEntity_t * vEntity;
|
|
idScreenRect shadowScissor;
|
|
idScreenRect lightScissor;
|
|
idVec3 localLightOrigin;
|
|
idVec3 localViewOrigin;
|
|
|
|
vLight = lightDef->viewLight;
|
|
vEntity = entityDef->viewEntity;
|
|
|
|
// do not waste time culling the interaction frustum if there will be no shadows
|
|
if ( !HasShadows() ) {
|
|
|
|
// use the entity scissor rectangle
|
|
shadowScissor = vEntity->scissorRect;
|
|
|
|
// culling does not seem to be worth it for static world models
|
|
} else if ( entityDef->parms.hModel->IsStaticWorldModel() ) {
|
|
|
|
// use the light scissor rectangle
|
|
shadowScissor = vLight->scissorRect;
|
|
|
|
} else {
|
|
|
|
// try to cull the interaction
|
|
// this will also cull the case where the light origin is inside the
|
|
// view frustum and the entity bounds are outside the view frustum
|
|
if ( CullInteractionByViewFrustum( tr.viewDef->viewFrustum ) ) {
|
|
return;
|
|
}
|
|
|
|
// calculate the shadow scissor rectangle
|
|
shadowScissor = CalcInteractionScissorRectangle( tr.viewDef->viewFrustum );
|
|
}
|
|
|
|
// get out before making the dynamic model if the shadow scissor rectangle is empty
|
|
if ( shadowScissor.IsEmpty() ) {
|
|
return;
|
|
}
|
|
|
|
// We will need the dynamic surface created to make interactions, even if the
|
|
// model itself wasn't visible. This just returns a cached value after it
|
|
// has been generated once in the view.
|
|
idRenderModel *model = R_EntityDefDynamicModel( entityDef );
|
|
if ( model == NULL || model->NumSurfaces() <= 0 ) {
|
|
return;
|
|
}
|
|
|
|
// the dynamic model may have changed since we built the surface list
|
|
if ( !IsDeferred() && entityDef->dynamicModelFrameCount != dynamicModelFrameCount ) {
|
|
FreeSurfaces();
|
|
}
|
|
dynamicModelFrameCount = entityDef->dynamicModelFrameCount;
|
|
|
|
// actually create the interaction if needed, building light and shadow surfaces as needed
|
|
if ( IsDeferred() ) {
|
|
CreateInteraction( model );
|
|
}
|
|
|
|
R_GlobalPointToLocal( vEntity->modelMatrix, lightDef->globalLightOrigin, localLightOrigin );
|
|
R_GlobalPointToLocal( vEntity->modelMatrix, tr.viewDef->renderView.vieworg, localViewOrigin );
|
|
|
|
// calculate the scissor as the intersection of the light and model rects
|
|
// this is used for light triangles, but not for shadow triangles
|
|
lightScissor = vLight->scissorRect;
|
|
lightScissor.Intersect( vEntity->scissorRect );
|
|
|
|
bool lightScissorsEmpty = lightScissor.IsEmpty();
|
|
|
|
// for each surface of this entity / light interaction
|
|
for ( int i = 0; i < numSurfaces; i++ ) {
|
|
surfaceInteraction_t *sint = &surfaces[i];
|
|
|
|
// see if the base surface is visible, we may still need to add shadows even if empty
|
|
if ( !lightScissorsEmpty && sint->ambientTris && sint->ambientTris->ambientViewCount == tr.viewCount ) {
|
|
|
|
// make sure we have created this interaction, which may have been deferred
|
|
// on a previous use that only needed the shadow
|
|
if ( sint->lightTris == LIGHT_TRIS_DEFERRED ) {
|
|
sint->lightTris = R_CreateLightTris( vEntity->entityDef, sint->ambientTris, vLight->lightDef, sint->shader, sint->cullInfo );
|
|
R_FreeInteractionCullInfo( sint->cullInfo );
|
|
}
|
|
|
|
srfTriangles_t *lightTris = sint->lightTris;
|
|
|
|
if ( lightTris ) {
|
|
|
|
// try to cull before adding
|
|
// FIXME: this may not be worthwhile. We have already done culling on the ambient,
|
|
// but individual surfaces may still be cropped somewhat more
|
|
if ( !R_CullLocalBox( lightTris->bounds, vEntity->modelMatrix, 5, tr.viewDef->frustum ) ) {
|
|
|
|
// make sure the original surface has its ambient cache created
|
|
srfTriangles_t *tri = sint->ambientTris;
|
|
if ( !tri->ambientCache ) {
|
|
if ( !R_CreateAmbientCache( tri, sint->shader->ReceivesLighting() ) ) {
|
|
// skip if we were out of vertex memory
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// reference the original surface's ambient cache
|
|
lightTris->ambientCache = tri->ambientCache;
|
|
|
|
// touch the ambient surface so it won't get purged
|
|
vertexCache.Touch( lightTris->ambientCache );
|
|
|
|
// regenerate the lighting cache (for non-vertex program cards) if it has been purged
|
|
if ( !lightTris->lightingCache ) {
|
|
if ( !R_CreateLightingCache( entityDef, lightDef, lightTris ) ) {
|
|
// skip if we are out of vertex memory
|
|
continue;
|
|
}
|
|
}
|
|
// touch the light surface so it won't get purged
|
|
// (vertex program cards won't have a light cache at all)
|
|
if ( lightTris->lightingCache ) {
|
|
vertexCache.Touch( lightTris->lightingCache );
|
|
}
|
|
|
|
if ( !lightTris->indexCache && r_useIndexBuffers.GetBool() ) {
|
|
vertexCache.Alloc( lightTris->indexes, lightTris->numIndexes * sizeof( lightTris->indexes[0] ), &lightTris->indexCache, true );
|
|
}
|
|
if ( lightTris->indexCache ) {
|
|
vertexCache.Touch( lightTris->indexCache );
|
|
}
|
|
|
|
// add the surface to the light list
|
|
|
|
const idMaterial *shader = sint->shader;
|
|
R_GlobalShaderOverride( &shader );
|
|
|
|
// there will only be localSurfaces if the light casts shadows and
|
|
// there are surfaces with NOSELFSHADOW
|
|
if ( sint->shader->Coverage() == MC_TRANSLUCENT ) {
|
|
R_LinkLightSurf( &vLight->translucentInteractions, lightTris,
|
|
vEntity, lightDef, shader, lightScissor, false );
|
|
} else if ( !lightDef->parms.noShadows && sint->shader->TestMaterialFlag(MF_NOSELFSHADOW) ) {
|
|
R_LinkLightSurf( &vLight->localInteractions, lightTris,
|
|
vEntity, lightDef, shader, lightScissor, false );
|
|
} else {
|
|
R_LinkLightSurf( &vLight->globalInteractions, lightTris,
|
|
vEntity, lightDef, shader, lightScissor, false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
srfTriangles_t *shadowTris = sint->shadowTris;
|
|
|
|
// the shadows will always have to be added, unless we can tell they
|
|
// are from a surface in an unconnected area
|
|
if ( shadowTris ) {
|
|
|
|
// check for view specific shadow suppression (player shadows, etc)
|
|
if ( !r_skipSuppress.GetBool() ) {
|
|
if ( entityDef->parms.suppressShadowInViewID &&
|
|
entityDef->parms.suppressShadowInViewID == tr.viewDef->renderView.viewID ) {
|
|
continue;
|
|
}
|
|
if ( entityDef->parms.suppressShadowInLightID &&
|
|
entityDef->parms.suppressShadowInLightID == lightDef->parms.lightId ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// cull static shadows that have a non-empty bounds
|
|
// dynamic shadows that use the turboshadow code will not have valid
|
|
// bounds, because the perspective projection extends them to infinity
|
|
if ( r_useShadowCulling.GetBool() && !shadowTris->bounds.IsCleared() ) {
|
|
if ( R_CullLocalBox( shadowTris->bounds, vEntity->modelMatrix, 5, tr.viewDef->frustum ) ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// copy the shadow vertexes to the vertex cache if they have been purged
|
|
|
|
// if we are using shared shadowVertexes and letting a vertex program fix them up,
|
|
// get the shadowCache from the parent ambient surface
|
|
if ( !shadowTris->shadowVertexes ) {
|
|
// the data may have been purged, so get the latest from the "home position"
|
|
shadowTris->shadowCache = sint->ambientTris->shadowCache;
|
|
}
|
|
|
|
// if we have been purged, re-upload the shadowVertexes
|
|
if ( !shadowTris->shadowCache ) {
|
|
if ( shadowTris->shadowVertexes ) {
|
|
// each interaction has unique vertexes
|
|
R_CreatePrivateShadowCache( shadowTris );
|
|
} else {
|
|
R_CreateVertexProgramShadowCache( sint->ambientTris );
|
|
shadowTris->shadowCache = sint->ambientTris->shadowCache;
|
|
}
|
|
// if we are out of vertex cache space, skip the interaction
|
|
if ( !shadowTris->shadowCache ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// touch the shadow surface so it won't get purged
|
|
vertexCache.Touch( shadowTris->shadowCache );
|
|
|
|
if ( !shadowTris->indexCache && r_useIndexBuffers.GetBool() ) {
|
|
vertexCache.Alloc( shadowTris->indexes, shadowTris->numIndexes * sizeof( shadowTris->indexes[0] ), &shadowTris->indexCache, true );
|
|
vertexCache.Touch( shadowTris->indexCache );
|
|
}
|
|
|
|
// see if we can avoid using the shadow volume caps
|
|
bool inside = R_PotentiallyInsideInfiniteShadow( sint->ambientTris, localViewOrigin, localLightOrigin );
|
|
|
|
if ( sint->shader->TestMaterialFlag( MF_NOSELFSHADOW ) ) {
|
|
R_LinkLightSurf( &vLight->localShadows,
|
|
shadowTris, vEntity, lightDef, NULL, shadowScissor, inside );
|
|
} else {
|
|
R_LinkLightSurf( &vLight->globalShadows,
|
|
shadowTris, vEntity, lightDef, NULL, shadowScissor, inside );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_ShowInteractionMemory_f
|
|
===================
|
|
*/
|
|
void R_ShowInteractionMemory_f( const idCmdArgs &args ) {
|
|
int total = 0;
|
|
int entities = 0;
|
|
int interactions = 0;
|
|
int deferredInteractions = 0;
|
|
int emptyInteractions = 0;
|
|
int lightTris = 0;
|
|
int lightTriVerts = 0;
|
|
int lightTriIndexes = 0;
|
|
int shadowTris = 0;
|
|
int shadowTriVerts = 0;
|
|
int shadowTriIndexes = 0;
|
|
|
|
for ( int i = 0; i < tr.primaryWorld->entityDefs.Num(); i++ ) {
|
|
idRenderEntityLocal *def = tr.primaryWorld->entityDefs[i];
|
|
if ( !def ) {
|
|
continue;
|
|
}
|
|
if ( def->firstInteraction == NULL ) {
|
|
continue;
|
|
}
|
|
entities++;
|
|
|
|
for ( idInteraction *inter = def->firstInteraction; inter != NULL; inter = inter->entityNext ) {
|
|
interactions++;
|
|
total += inter->MemoryUsed();
|
|
|
|
if ( inter->IsDeferred() ) {
|
|
deferredInteractions++;
|
|
continue;
|
|
}
|
|
if ( inter->IsEmpty() ) {
|
|
emptyInteractions++;
|
|
continue;
|
|
}
|
|
|
|
for ( int j = 0; j < inter->numSurfaces; j++ ) {
|
|
surfaceInteraction_t *srf = &inter->surfaces[j];
|
|
|
|
if ( srf->lightTris && srf->lightTris != LIGHT_TRIS_DEFERRED ) {
|
|
lightTris++;
|
|
lightTriVerts += srf->lightTris->numVerts;
|
|
lightTriIndexes += srf->lightTris->numIndexes;
|
|
}
|
|
if ( srf->shadowTris ) {
|
|
shadowTris++;
|
|
shadowTriVerts += srf->shadowTris->numVerts;
|
|
shadowTriIndexes += srf->shadowTris->numIndexes;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
common->Printf( "%i entities with %i total interactions totalling %ik\n", entities, interactions, total / 1024 );
|
|
common->Printf( "%i deferred interactions, %i empty interactions\n", deferredInteractions, emptyInteractions );
|
|
common->Printf( "%5i indexes %5i verts in %5i light tris\n", lightTriIndexes, lightTriVerts, lightTris );
|
|
common->Printf( "%5i indexes %5i verts in %5i shadow tris\n", shadowTriIndexes, shadowTriVerts, shadowTris );
|
|
}
|