/*
================
idRenderWorldLocal::ParseInterAreaPortals
================
*/
void idRenderWorldLocal::ReadBinaryAreaPortals( idFile* file )
{
file->ReadBig( numPortalAreas );
file->ReadBig( numInterAreaPortals );
portalAreas = ( portalArea_t* )R_ClearedStaticAlloc( numPortalAreas * sizeof( portalAreas[0] ) );
areaScreenRect = ( idScreenRect* ) R_ClearedStaticAlloc( numPortalAreas * sizeof( idScreenRect ) );
// set the doubly linked lists
SetupAreaRefs();
doublePortals = ( doublePortal_t* )R_ClearedStaticAlloc( numInterAreaPortals * sizeof( doublePortals [0] ) );
for( int i = 0; i < numInterAreaPortals; i++ )
{
int numPoints, a1, a2;
idWinding* w;
portal_t* p;
file->ReadBig( numPoints );
file->ReadBig( a1 );
file->ReadBig( a2 );
w = new( TAG_RENDER_WINDING ) idWinding( numPoints );
w->SetNumPoints( numPoints );
for( int j = 0; j < numPoints; j++ )
{
file->ReadBig( ( *w )[ j ][ 0 ] );
file->ReadBig( ( *w )[ j ][ 1 ] );
file->ReadBig( ( *w )[ j ][ 2 ] );
// no texture coordinates
( *w )[ j ][ 3 ] = 0;
( *w )[ j ][ 4 ] = 0;
}
// add the portal to a1
p = ( portal_t* )R_ClearedStaticAlloc( sizeof( *p ) );
p->intoArea = a2;
p->doublePortal = &doublePortals[i];
p->w = w;
p->w->GetPlane( p->plane );
p->next = portalAreas[a1].portals;
portalAreas[a1].portals = p;
doublePortals[i].portals[0] = p;
// reverse it for a2
p = ( portal_t* )R_ClearedStaticAlloc( sizeof( *p ) );
p->intoArea = a1;
p->doublePortal = &doublePortals[i];
p->w = w->Reverse();
p->w->GetPlane( p->plane );
p->next = portalAreas[a2].portals;
portalAreas[a2].portals = p;
doublePortals[i].portals[1] = p;
}
}
/*
=================
idRenderWorldLocal::ClearWorld
Sets up for a single area world
=================
*/
void idRenderWorldLocal::ClearWorld() {
numPortalAreas = 1;
portalAreas = (portalArea_t *)R_ClearedStaticAlloc( sizeof( portalAreas[0] ) );
areaScreenRect = (idScreenRect *) R_ClearedStaticAlloc( sizeof( idScreenRect ) );
SetupAreaRefs();
// even though we only have a single area, create a node
// that has both children pointing at it so we don't need to
//
areaNodes = (areaNode_t *)R_ClearedStaticAlloc( sizeof( areaNodes[0] ) );
areaNodes[0].plane[3] = 1;
areaNodes[0].children[0] = -1;
areaNodes[0].children[1] = -1;
}
/*
================
idRenderWorldLocal::ReadBinaryNodes
================
*/
void idRenderWorldLocal::ReadBinaryNodes( idFile* file )
{
file->ReadBig( numAreaNodes );
areaNodes = ( areaNode_t* )R_ClearedStaticAlloc( numAreaNodes * sizeof( areaNodes[0] ) );
for( int i = 0; i < numAreaNodes; i++ )
{
areaNode_t* node = &areaNodes[ i ];
file->ReadBig( node->plane[ 0 ] );
file->ReadBig( node->plane[ 1 ] );
file->ReadBig( node->plane[ 2 ] );
file->ReadBig( node->plane[ 3 ] );
file->ReadBig( node->children[ 0 ] );
file->ReadBig( node->children[ 1 ] );
}
}
/*
================
idRenderWorldLocal::ParseNodes
================
*/
void idRenderWorldLocal::ParseNodes( idLexer* src, idFile* fileOut )
{
src->ExpectTokenString( "{" );
numAreaNodes = src->ParseInt();
if( numAreaNodes < 0 )
{
src->Error( "R_ParseNodes: bad numAreaNodes" );
}
areaNodes = ( areaNode_t* )R_ClearedStaticAlloc( numAreaNodes * sizeof( areaNodes[0] ) );
if( fileOut != NULL )
{
// write out the type so the binary reader knows what to instantiate
fileOut->WriteString( "nodes" );
}
if( fileOut != NULL )
{
fileOut->WriteBig( numAreaNodes );
}
for( int i = 0; i < numAreaNodes; i++ )
{
areaNode_t* node;
node = &areaNodes[i];
src->Parse1DMatrix( 4, node->plane.ToFloatPtr() );
node->children[0] = src->ParseInt();
node->children[1] = src->ParseInt();
if( fileOut != NULL )
{
fileOut->WriteBig( node->plane[ 0 ] );
fileOut->WriteBig( node->plane[ 1 ] );
fileOut->WriteBig( node->plane[ 2 ] );
fileOut->WriteBig( node->plane[ 3 ] );
fileOut->WriteBig( node->children[ 0 ] );
fileOut->WriteBig( node->children[ 1 ] );
}
}
src->ExpectTokenString( "}" );
}
/*
================
idRenderWorldLocal::ParseNodes
================
*/
void idRenderWorldLocal::ParseNodes( idLexer *src ) {
int i;
src->ExpectTokenString( "{" );
numAreaNodes = src->ParseInt();
if ( numAreaNodes < 0 ) {
src->Error( "R_ParseNodes: bad numAreaNodes" );
}
areaNodes = (areaNode_t *)R_ClearedStaticAlloc( numAreaNodes * sizeof( areaNodes[0] ) );
for ( i = 0 ; i < numAreaNodes ; i++ ) {
areaNode_t *node;
node = &areaNodes[i];
src->Parse1DMatrix( 4, node->plane.ToFloatPtr() );
node->children[0] = src->ParseInt();
node->children[1] = src->ParseInt();
}
src->ExpectTokenString( "}" );
}
/*
================
idRenderWorldLocal::ParseInterAreaPortals
================
*/
void idRenderWorldLocal::ParseInterAreaPortals( idLexer* src, idFile* fileOut )
{
src->ExpectTokenString( "{" );
numPortalAreas = src->ParseInt();
if( numPortalAreas < 0 )
{
src->Error( "R_ParseInterAreaPortals: bad numPortalAreas" );
return;
}
if( fileOut != NULL )
{
// write out the type so the binary reader knows what to instantiate
fileOut->WriteString( "interAreaPortals" );
}
portalAreas = ( portalArea_t* )R_ClearedStaticAlloc( numPortalAreas * sizeof( portalAreas[0] ) );
areaScreenRect = ( idScreenRect* ) R_ClearedStaticAlloc( numPortalAreas * sizeof( idScreenRect ) );
// set the doubly linked lists
SetupAreaRefs();
numInterAreaPortals = src->ParseInt();
if( numInterAreaPortals < 0 )
{
src->Error( "R_ParseInterAreaPortals: bad numInterAreaPortals" );
return;
}
if( fileOut != NULL )
{
fileOut->WriteBig( numPortalAreas );
fileOut->WriteBig( numInterAreaPortals );
}
doublePortals = ( doublePortal_t* )R_ClearedStaticAlloc( numInterAreaPortals *
sizeof( doublePortals [0] ) );
for( int i = 0; i < numInterAreaPortals; i++ )
{
int numPoints, a1, a2;
idWinding* w;
portal_t* p;
numPoints = src->ParseInt();
a1 = src->ParseInt();
a2 = src->ParseInt();
if( fileOut != NULL )
{
fileOut->WriteBig( numPoints );
fileOut->WriteBig( a1 );
fileOut->WriteBig( a2 );
}
w = new( TAG_RENDER_WINDING ) idWinding( numPoints );
w->SetNumPoints( numPoints );
for( int j = 0; j < numPoints; j++ )
{
src->Parse1DMatrix( 3, ( *w )[j].ToFloatPtr() );
if( fileOut != NULL )
{
fileOut->WriteBig( ( *w )[j].x );
fileOut->WriteBig( ( *w )[j].y );
fileOut->WriteBig( ( *w )[j].z );
}
// no texture coordinates
( *w )[j][3] = 0;
( *w )[j][4] = 0;
}
// add the portal to a1
p = ( portal_t* )R_ClearedStaticAlloc( sizeof( *p ) );
p->intoArea = a2;
p->doublePortal = &doublePortals[i];
p->w = w;
p->w->GetPlane( p->plane );
p->next = portalAreas[a1].portals;
portalAreas[a1].portals = p;
doublePortals[i].portals[0] = p;
// reverse it for a2
p = ( portal_t* )R_ClearedStaticAlloc( sizeof( *p ) );
p->intoArea = a1;
p->doublePortal = &doublePortals[i];
p->w = w->Reverse();
p->w->GetPlane( p->plane );
p->next = portalAreas[a2].portals;
portalAreas[a2].portals = p;
doublePortals[i].portals[1] = p;
}
src->ExpectTokenString( "}" );
}
/*
====================
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();
}
}
/*
========================
idRenderModelMD5::LoadBinaryModel
========================
*/
bool idRenderModelMD5::LoadBinaryModel( idFile* file, const ID_TIME_T sourceTimeStamp )
{
if( !idRenderModelStatic::LoadBinaryModel( file, sourceTimeStamp ) )
{
return false;
}
unsigned int magic = 0;
file->ReadBig( magic );
if( magic != MD5B_MAGIC )
{
return false;
}
int tempNum;
file->ReadBig( tempNum );
joints.SetNum( tempNum );
for( int i = 0; i < joints.Num(); i++ )
{
file->ReadString( joints[i].name );
int offset;
file->ReadBig( offset );
if( offset >= 0 )
{
joints[i].parent = joints.Ptr() + offset;
}
else
{
joints[i].parent = NULL;
}
}
file->ReadBig( tempNum );
defaultPose.SetNum( tempNum );
for( int i = 0; i < defaultPose.Num(); i++ )
{
file->ReadBig( defaultPose[i].q.x );
file->ReadBig( defaultPose[i].q.y );
file->ReadBig( defaultPose[i].q.z );
file->ReadBig( defaultPose[i].q.w );
file->ReadVec3( defaultPose[i].t );
}
file->ReadBig( tempNum );
invertedDefaultPose.SetNum( tempNum );
for( int i = 0; i < invertedDefaultPose.Num(); i++ )
{
file->ReadBigArray( invertedDefaultPose[ i ].ToFloatPtr(), JOINTMAT_TYPESIZE );
}
SIMD_INIT_LAST_JOINT( invertedDefaultPose.Ptr(), joints.Num() );
file->ReadBig( tempNum );
meshes.SetNum( tempNum );
for( int i = 0; i < meshes.Num(); i++ )
{
idStr materialName;
file->ReadString( materialName );
if( materialName.IsEmpty() )
{
meshes[i].shader = NULL;
}
else
{
meshes[i].shader = declManager->FindMaterial( materialName );
}
file->ReadBig( meshes[i].numVerts );
file->ReadBig( meshes[i].numTris );
file->ReadBig( meshes[i].numMeshJoints );
meshes[i].meshJoints = ( byte* ) Mem_Alloc( meshes[i].numMeshJoints * sizeof( meshes[i].meshJoints[0] ), TAG_MODEL );
file->ReadBigArray( meshes[i].meshJoints, meshes[i].numMeshJoints );
file->ReadBig( meshes[i].maxJointVertDist );
meshes[i].deformInfo = ( deformInfo_t* )R_ClearedStaticAlloc( sizeof( deformInfo_t ) );
deformInfo_t& deform = *meshes[i].deformInfo;
file->ReadBig( deform.numSourceVerts );
file->ReadBig( deform.numOutputVerts );
file->ReadBig( deform.numIndexes );
file->ReadBig( deform.numMirroredVerts );
file->ReadBig( deform.numDupVerts );
file->ReadBig( deform.numSilEdges );
srfTriangles_t tri;
memset( &tri, 0, sizeof( srfTriangles_t ) );
if( deform.numOutputVerts > 0 )
{
R_AllocStaticTriSurfVerts( &tri, deform.numOutputVerts );
deform.verts = tri.verts;
file->ReadBigArray( deform.verts, deform.numOutputVerts );
}
if( deform.numIndexes > 0 )
{
R_AllocStaticTriSurfIndexes( &tri, deform.numIndexes );
R_AllocStaticTriSurfSilIndexes( &tri, deform.numIndexes );
deform.indexes = tri.indexes;
deform.silIndexes = tri.silIndexes;
file->ReadBigArray( deform.indexes, deform.numIndexes );
file->ReadBigArray( deform.silIndexes, deform.numIndexes );
}
if( deform.numMirroredVerts > 0 )
{
R_AllocStaticTriSurfMirroredVerts( &tri, deform.numMirroredVerts );
deform.mirroredVerts = tri.mirroredVerts;
file->ReadBigArray( deform.mirroredVerts, deform.numMirroredVerts );
}
if( deform.numDupVerts > 0 )
{
R_AllocStaticTriSurfDupVerts( &tri, deform.numDupVerts );
deform.dupVerts = tri.dupVerts;
file->ReadBigArray( deform.dupVerts, deform.numDupVerts * 2 );
}
if( deform.numSilEdges > 0 )
{
R_AllocStaticTriSurfSilEdges( &tri, deform.numSilEdges );
deform.silEdges = tri.silEdges;
assert( deform.silEdges != NULL );
for( int j = 0; j < deform.numSilEdges; j++ )
{
file->ReadBig( deform.silEdges[j].p1 );
file->ReadBig( deform.silEdges[j].p2 );
file->ReadBig( deform.silEdges[j].v1 );
file->ReadBig( deform.silEdges[j].v2 );
}
}
idShadowVertSkinned* shadowVerts = ( idShadowVertSkinned* ) Mem_Alloc( ALIGN( deform.numOutputVerts * 2 * sizeof( idShadowVertSkinned ), 16 ), TAG_MODEL );
idShadowVertSkinned::CreateShadowCache( shadowVerts, deform.verts, deform.numOutputVerts );
deform.staticAmbientCache = vertexCache.AllocStaticVertex( deform.verts, ALIGN( deform.numOutputVerts * sizeof( idDrawVert ), VERTEX_CACHE_ALIGN ) );
deform.staticIndexCache = vertexCache.AllocStaticIndex( deform.indexes, ALIGN( deform.numIndexes * sizeof( triIndex_t ), INDEX_CACHE_ALIGN ) );
deform.staticShadowCache = vertexCache.AllocStaticVertex( shadowVerts, ALIGN( deform.numOutputVerts * 2 * sizeof( idShadowVertSkinned ), VERTEX_CACHE_ALIGN ) );
Mem_Free( shadowVerts );
file->ReadBig( meshes[i].surfaceNum );
}
return true;
}
/*
================
idRenderWorldLocal::ParseInterAreaPortals
================
*/
void idRenderWorldLocal::ParseInterAreaPortals( idLexer *src ) {
int i, j;
src->ExpectTokenString( "{" );
numPortalAreas = src->ParseInt();
if ( numPortalAreas < 0 ) {
src->Error( "R_ParseInterAreaPortals: bad numPortalAreas" );
return;
}
portalAreas = (portalArea_t *)R_ClearedStaticAlloc( numPortalAreas * sizeof( portalAreas[0] ) );
areaScreenRect = (idScreenRect *) R_ClearedStaticAlloc( numPortalAreas * sizeof( idScreenRect ) );
// set the doubly linked lists
SetupAreaRefs();
numInterAreaPortals = src->ParseInt();
if ( numInterAreaPortals < 0 ) {
src->Error( "R_ParseInterAreaPortals: bad numInterAreaPortals" );
return;
}
doublePortals = (doublePortal_t *)R_ClearedStaticAlloc( numInterAreaPortals *
sizeof( doublePortals [0] ) );
for ( i = 0 ; i < numInterAreaPortals ; i++ ) {
int numPoints, a1, a2;
idWinding *w;
portal_t *p;
numPoints = src->ParseInt();
a1 = src->ParseInt();
a2 = src->ParseInt();
w = new idWinding( numPoints );
w->SetNumPoints( numPoints );
for ( j = 0 ; j < numPoints ; j++ ) {
src->Parse1DMatrix( 3, (*w)[j].ToFloatPtr() );
// no texture coordinates
(*w)[j][3] = 0;
(*w)[j][4] = 0;
}
// add the portal to a1
p = (portal_t *)R_ClearedStaticAlloc( sizeof( *p ) );
p->intoArea = a2;
p->doublePortal = &doublePortals[i];
p->w = w;
p->w->GetPlane( p->plane );
p->next = portalAreas[a1].portals;
portalAreas[a1].portals = p;
doublePortals[i].portals[0] = p;
// reverse it for a2
p = (portal_t *)R_ClearedStaticAlloc( sizeof( *p ) );
p->intoArea = a1;
p->doublePortal = &doublePortals[i];
p->w = w->Reverse();
p->w->GetPlane( p->plane );
p->next = portalAreas[a2].portals;
portalAreas[a2].portals = p;
doublePortals[i].portals[1] = p;
}
src->ExpectTokenString( "}" );
}
/*
======================
CreateStaticInteraction
Called by idRenderWorldLocal::GenerateAllInteractions
======================
*/
void idInteraction::CreateStaticInteraction() {
// note that it is a static interaction
staticInteraction = true;
const idRenderModel *model = entityDef->parms.hModel;
if ( model == NULL || model->NumSurfaces() <= 0 || model->IsDynamicModel() != DM_STATIC ) {
MakeEmpty();
return;
}
const idBounds bounds = model->Bounds( &entityDef->parms );
// if it doesn't contact the light frustum, none of the surfaces will
if ( R_CullModelBoundsToLight( lightDef, bounds, entityDef->modelRenderMatrix ) ) {
MakeEmpty();
return;
}
//
// create slots for each of the model's surfaces
//
numSurfaces = model->NumSurfaces();
surfaces = (surfaceInteraction_t *)R_ClearedStaticAlloc( sizeof( *surfaces ) * numSurfaces );
bool interactionGenerated = false;
// check each surface in the model
for ( int c = 0 ; c < model->NumSurfaces() ; c++ ) {
const modelSurface_t * surf = model->Surface( c );
const srfTriangles_t * tri = surf->geometry;
if ( tri == NULL ) {
continue;
}
// determine the shader for this surface, possibly by skinning
// Note that this will be wrong if customSkin/customShader are
// changed after map load time without invalidating the interaction!
const idMaterial * const shader = R_RemapShaderBySkin( surf->shader,
entityDef->parms.customSkin, entityDef->parms.customShader );
if ( shader == NULL ) {
continue;
}
// try to cull each surface
if ( R_CullModelBoundsToLight( lightDef, tri->bounds, entityDef->modelRenderMatrix ) ) {
continue;
}
surfaceInteraction_t *sint = &surfaces[c];
// generate a set of indexes for the lit surfaces, culling away triangles that are
// not at least partially inside the light
if ( shader->ReceivesLighting() ) {
srfTriangles_t * lightTris = R_CreateInteractionLightTris( entityDef, tri, lightDef, shader );
if ( lightTris != NULL ) {
// make a static index cache
sint->numLightTrisIndexes = lightTris->numIndexes;
sint->lightTrisIndexCache = vertexCache.AllocStaticIndex( lightTris->indexes, ALIGN( lightTris->numIndexes * sizeof( lightTris->indexes[0] ), INDEX_CACHE_ALIGN ) );
interactionGenerated = true;
R_FreeStaticTriSurf( lightTris );
}
}
// 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_skipPrelightShadows.GetBool() ) {
srfTriangles_t * shadowTris = R_CreateInteractionShadowVolume( entityDef, tri, lightDef );
if ( shadowTris != NULL ) {
// make a static index cache
sint->shadowIndexCache = vertexCache.AllocStaticIndex( shadowTris->indexes, ALIGN( shadowTris->numIndexes * sizeof( shadowTris->indexes[0] ), INDEX_CACHE_ALIGN ) );
sint->numShadowIndexes = shadowTris->numIndexes;
#if defined( KEEP_INTERACTION_CPU_DATA )
sint->shadowIndexes = shadowTris->indexes;
shadowTris->indexes = NULL;
#endif
if ( shader->Coverage() != MC_OPAQUE ) {
// 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->numShadowIndexesNoCaps = shadowTris->numIndexes;
} else {
sint->numShadowIndexesNoCaps = shadowTris->numShadowIndexesNoCaps;
}
R_FreeStaticTriSurf( shadowTris );
}
interactionGenerated = true;
}
}
}
// if none of the surfaces generated anything, don't even bother checking?
if ( !interactionGenerated ) {
MakeEmpty();
}
}
