/*
==================
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);
if (!lightTris->indexCache) {
vertexCache.Alloc(lightTris->indexes, lightTris->numIndexes * sizeof(lightTris->indexes[0]), &lightTris->indexCache, true);
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 ) {
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 );
}
}
}
}
/*
====================
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();
}
}
/*
======================
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();
}
}
