mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-12-14 23:01:26 +00:00
724ab1727c
r_skipDepthCapture is now called r_enableDepthCapture, and instead of being a bool it's now an int with -1 meaning "enable if soft particles are used"
1662 lines
52 KiB
C++
1662 lines
52 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 "idlib/math/Interpolate.h"
|
|
#include "framework/Game.h"
|
|
#include "renderer/VertexCache.h"
|
|
#include "renderer/RenderWorld_local.h"
|
|
#include "ui/Window.h"
|
|
|
|
#include "renderer/tr_local.h"
|
|
|
|
#include "Model_local.h"
|
|
|
|
|
|
static const float CHECK_BOUNDS_EPSILON = 1.0f;
|
|
|
|
/*
|
|
===========================================================================================
|
|
|
|
VERTEX CACHE GENERATORS
|
|
|
|
===========================================================================================
|
|
*/
|
|
|
|
/*
|
|
==================
|
|
R_CreateAmbientCache
|
|
|
|
Create it if needed
|
|
==================
|
|
*/
|
|
bool R_CreateAmbientCache( srfTriangles_t *tri, bool needsLighting ) {
|
|
if ( tri->ambientCache ) {
|
|
return true;
|
|
}
|
|
// we are going to use it for drawing, so make sure we have the tangents and normals
|
|
if ( needsLighting && !tri->tangentsCalculated ) {
|
|
R_DeriveTangents( tri );
|
|
}
|
|
|
|
vertexCache.Alloc( tri->verts, tri->numVerts * sizeof( tri->verts[0] ), &tri->ambientCache );
|
|
if ( !tri->ambientCache ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
R_CreateLightingCache
|
|
|
|
Returns false if the cache couldn't be allocated, in which case the surface should be skipped.
|
|
==================
|
|
*/
|
|
bool R_CreateLightingCache( const idRenderEntityLocal *ent, const idRenderLightLocal *light, srfTriangles_t *tri ) {
|
|
idVec3 localLightOrigin;
|
|
|
|
// fogs and blends don't need light vectors
|
|
if ( light->lightShader->IsFogLight() || light->lightShader->IsBlendLight() ) {
|
|
return true;
|
|
}
|
|
|
|
// not needed if we have vertex programs
|
|
if ( tr.backEndRendererHasVertexPrograms ) {
|
|
return true;
|
|
}
|
|
|
|
R_GlobalPointToLocal( ent->modelMatrix, light->globalLightOrigin, localLightOrigin );
|
|
|
|
int size = tri->ambientSurface->numVerts * sizeof( lightingCache_t );
|
|
lightingCache_t *cache = (lightingCache_t *)_alloca16( size );
|
|
|
|
#if 1
|
|
|
|
SIMDProcessor->CreateTextureSpaceLightVectors( &cache[0].localLightVector, localLightOrigin,
|
|
tri->ambientSurface->verts, tri->ambientSurface->numVerts, tri->indexes, tri->numIndexes );
|
|
|
|
#else
|
|
|
|
bool *used = (bool *)_alloca16( tri->ambientSurface->numVerts * sizeof( used[0] ) );
|
|
memset( used, 0, tri->ambientSurface->numVerts * sizeof( used[0] ) );
|
|
|
|
// because the interaction may be a very small subset of the full surface,
|
|
// it makes sense to only deal with the verts used
|
|
for ( int j = 0; j < tri->numIndexes; j++ ) {
|
|
int i = tri->indexes[j];
|
|
if ( used[i] ) {
|
|
continue;
|
|
}
|
|
used[i] = true;
|
|
|
|
idVec3 lightDir;
|
|
const idDrawVert *v;
|
|
|
|
v = &tri->ambientSurface->verts[i];
|
|
|
|
lightDir = localLightOrigin - v->xyz;
|
|
|
|
cache[i].localLightVector[0] = lightDir * v->tangents[0];
|
|
cache[i].localLightVector[1] = lightDir * v->tangents[1];
|
|
cache[i].localLightVector[2] = lightDir * v->normal;
|
|
}
|
|
|
|
#endif
|
|
|
|
vertexCache.Alloc( cache, size, &tri->lightingCache );
|
|
if ( !tri->lightingCache ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
R_CreatePrivateShadowCache
|
|
|
|
This is used only for a specific light
|
|
==================
|
|
*/
|
|
void R_CreatePrivateShadowCache( srfTriangles_t *tri ) {
|
|
if ( !tri->shadowVertexes ) {
|
|
return;
|
|
}
|
|
|
|
vertexCache.Alloc( tri->shadowVertexes, tri->numVerts * sizeof( *tri->shadowVertexes ), &tri->shadowCache );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
R_CreateVertexProgramShadowCache
|
|
|
|
This is constant for any number of lights, the vertex program
|
|
takes care of projecting the verts to infinity.
|
|
==================
|
|
*/
|
|
void R_CreateVertexProgramShadowCache( srfTriangles_t *tri ) {
|
|
if ( tri->verts == NULL ) {
|
|
return;
|
|
}
|
|
|
|
shadowCache_t *temp = (shadowCache_t *)_alloca16( tri->numVerts * 2 * sizeof( shadowCache_t ) );
|
|
|
|
#if 1
|
|
|
|
SIMDProcessor->CreateVertexProgramShadowCache( &temp->xyz, tri->verts, tri->numVerts );
|
|
|
|
#else
|
|
|
|
int numVerts = tri->numVerts;
|
|
const idDrawVert *verts = tri->verts;
|
|
for ( int i = 0; i < numVerts; i++ ) {
|
|
const float *v = verts[i].xyz.ToFloatPtr();
|
|
temp[i*2+0].xyz[0] = v[0];
|
|
temp[i*2+1].xyz[0] = v[0];
|
|
temp[i*2+0].xyz[1] = v[1];
|
|
temp[i*2+1].xyz[1] = v[1];
|
|
temp[i*2+0].xyz[2] = v[2];
|
|
temp[i*2+1].xyz[2] = v[2];
|
|
temp[i*2+0].xyz[3] = 1.0f; // on the model surface
|
|
temp[i*2+1].xyz[3] = 0.0f; // will be projected to infinity
|
|
}
|
|
|
|
#endif
|
|
|
|
vertexCache.Alloc( temp, tri->numVerts * 2 * sizeof( shadowCache_t ), &tri->shadowCache );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
R_SkyboxTexGen
|
|
==================
|
|
*/
|
|
void R_SkyboxTexGen( drawSurf_t *surf, const idVec3 &viewOrg ) {
|
|
int i;
|
|
idVec3 localViewOrigin;
|
|
|
|
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 ( i = 0; i < numVerts; i++ ) {
|
|
texCoords[i][0] = verts[i].xyz[0] - localViewOrigin[0];
|
|
texCoords[i][1] = verts[i].xyz[1] - localViewOrigin[1];
|
|
texCoords[i][2] = verts[i].xyz[2] - localViewOrigin[2];
|
|
}
|
|
|
|
surf->dynamicTexCoords = vertexCache.AllocFrameTemp( texCoords, size );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
R_WobbleskyTexGen
|
|
==================
|
|
*/
|
|
void R_WobbleskyTexGen( drawSurf_t *surf, const idVec3 &viewOrg ) {
|
|
int i;
|
|
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 ( 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_SpecularTexGen
|
|
|
|
Calculates the specular coordinates for cards without vertex programs.
|
|
=================
|
|
*/
|
|
static void R_SpecularTexGen( drawSurf_t *surf, const idVec3 &globalLightOrigin, const idVec3 &viewOrg ) {
|
|
const srfTriangles_t *tri;
|
|
idVec3 localLightOrigin;
|
|
idVec3 localViewOrigin;
|
|
|
|
R_GlobalPointToLocal( surf->space->modelMatrix, globalLightOrigin, localLightOrigin );
|
|
R_GlobalPointToLocal( surf->space->modelMatrix, viewOrg, localViewOrigin );
|
|
|
|
tri = surf->geo;
|
|
|
|
// FIXME: change to 3 component?
|
|
int size = tri->numVerts * sizeof( idVec4 );
|
|
idVec4 *texCoords = (idVec4 *) _alloca16( size );
|
|
|
|
#if 1
|
|
|
|
SIMDProcessor->CreateSpecularTextureCoords( texCoords, localLightOrigin, localViewOrigin,
|
|
tri->verts, tri->numVerts, tri->indexes, tri->numIndexes );
|
|
|
|
#else
|
|
|
|
bool *used = (bool *)_alloca16( tri->numVerts * sizeof( used[0] ) );
|
|
memset( used, 0, tri->numVerts * sizeof( used[0] ) );
|
|
|
|
// because the interaction may be a very small subset of the full surface,
|
|
// it makes sense to only deal with the verts used
|
|
for ( int j = 0; j < tri->numIndexes; j++ ) {
|
|
int i = tri->indexes[j];
|
|
if ( used[i] ) {
|
|
continue;
|
|
}
|
|
used[i] = true;
|
|
|
|
float ilength;
|
|
|
|
const idDrawVert *v = &tri->verts[i];
|
|
|
|
idVec3 lightDir = localLightOrigin - v->xyz;
|
|
idVec3 viewDir = localViewOrigin - v->xyz;
|
|
|
|
ilength = idMath::RSqrt( lightDir * lightDir );
|
|
lightDir[0] *= ilength;
|
|
lightDir[1] *= ilength;
|
|
lightDir[2] *= ilength;
|
|
|
|
ilength = idMath::RSqrt( viewDir * viewDir );
|
|
viewDir[0] *= ilength;
|
|
viewDir[1] *= ilength;
|
|
viewDir[2] *= ilength;
|
|
|
|
lightDir += viewDir;
|
|
|
|
texCoords[i][0] = lightDir * v->tangents[0];
|
|
texCoords[i][1] = lightDir * v->tangents[1];
|
|
texCoords[i][2] = lightDir * v->normal;
|
|
texCoords[i][3] = 1;
|
|
}
|
|
|
|
#endif
|
|
|
|
surf->dynamicTexCoords = vertexCache.AllocFrameTemp( texCoords, size );
|
|
}
|
|
|
|
|
|
//=======================================================================================================
|
|
|
|
/*
|
|
=============
|
|
R_SetEntityDefViewEntity
|
|
|
|
If the entityDef isn't already on the viewEntity list, create
|
|
a viewEntity and add it to the list with an empty scissor rect.
|
|
|
|
This does not instantiate dynamic models for the entity yet.
|
|
=============
|
|
*/
|
|
viewEntity_t *R_SetEntityDefViewEntity( idRenderEntityLocal *def ) {
|
|
viewEntity_t *vModel;
|
|
|
|
if ( def->viewCount == tr.viewCount ) {
|
|
return def->viewEntity;
|
|
}
|
|
def->viewCount = tr.viewCount;
|
|
|
|
// set the model and modelview matricies
|
|
vModel = (viewEntity_t *)R_ClearedFrameAlloc( sizeof( *vModel ) );
|
|
vModel->entityDef = def;
|
|
|
|
// the scissorRect will be expanded as the model bounds is accepted into visible portal chains
|
|
vModel->scissorRect.Clear();
|
|
|
|
// copy the model and weapon depth hack for back-end use
|
|
vModel->modelDepthHack = def->parms.modelDepthHack;
|
|
vModel->weaponDepthHack = def->parms.weaponDepthHack;
|
|
|
|
R_AxisToModelMatrix( def->parms.axis, def->parms.origin, vModel->modelMatrix );
|
|
|
|
// we may not have a viewDef if we are just creating shadows at entity creation time
|
|
if ( tr.viewDef ) {
|
|
myGlMultMatrix( vModel->modelMatrix, tr.viewDef->worldSpace.modelViewMatrix, vModel->modelViewMatrix );
|
|
|
|
vModel->next = tr.viewDef->viewEntitys;
|
|
tr.viewDef->viewEntitys = vModel;
|
|
}
|
|
|
|
def->viewEntity = vModel;
|
|
|
|
return vModel;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
R_TestPointInViewLight
|
|
====================
|
|
*/
|
|
static const float INSIDE_LIGHT_FRUSTUM_SLOP = 32;
|
|
// this needs to be greater than the dist from origin to corner of near clip plane
|
|
static bool R_TestPointInViewLight( const idVec3 &org, const idRenderLightLocal *light ) {
|
|
int i;
|
|
idVec3 local;
|
|
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
float d = light->frustum[i].Distance( org );
|
|
if ( d > INSIDE_LIGHT_FRUSTUM_SLOP ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_PointInFrustum
|
|
|
|
Assumes positive sides face outward
|
|
===================
|
|
*/
|
|
static bool R_PointInFrustum( idVec3 &p, idPlane *planes, int numPlanes ) {
|
|
for ( int i = 0 ; i < numPlanes ; i++ ) {
|
|
float d = planes[i].Distance( p );
|
|
if ( d > 0 ) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
R_SetLightDefViewLight
|
|
|
|
If the lightDef isn't already on the viewLight list, create
|
|
a viewLight and add it to the list with an empty scissor rect.
|
|
=============
|
|
*/
|
|
viewLight_t *R_SetLightDefViewLight( idRenderLightLocal *light ) {
|
|
viewLight_t *vLight;
|
|
|
|
if ( light->viewCount == tr.viewCount ) {
|
|
return light->viewLight;
|
|
}
|
|
light->viewCount = tr.viewCount;
|
|
|
|
// add to the view light chain
|
|
vLight = (viewLight_t *)R_ClearedFrameAlloc( sizeof( *vLight ) );
|
|
vLight->lightDef = light;
|
|
|
|
// the scissorRect will be expanded as the light bounds is accepted into visible portal chains
|
|
vLight->scissorRect.Clear();
|
|
|
|
// calculate the shadow cap optimization states
|
|
vLight->viewInsideLight = R_TestPointInViewLight( tr.viewDef->renderView.vieworg, light );
|
|
if ( !vLight->viewInsideLight ) {
|
|
vLight->viewSeesShadowPlaneBits = 0;
|
|
for ( int i = 0 ; i < light->numShadowFrustums ; i++ ) {
|
|
float d = light->shadowFrustums[i].planes[5].Distance( tr.viewDef->renderView.vieworg );
|
|
if ( d < INSIDE_LIGHT_FRUSTUM_SLOP ) {
|
|
vLight->viewSeesShadowPlaneBits|= 1 << i;
|
|
}
|
|
}
|
|
} else {
|
|
// this should not be referenced in this case
|
|
vLight->viewSeesShadowPlaneBits = 63;
|
|
}
|
|
|
|
// see if the light center is in view, which will allow us to cull invisible shadows
|
|
vLight->viewSeesGlobalLightOrigin = R_PointInFrustum( light->globalLightOrigin, tr.viewDef->frustum, 4 );
|
|
|
|
// copy data used by backend
|
|
vLight->globalLightOrigin = light->globalLightOrigin;
|
|
vLight->lightProject[0] = light->lightProject[0];
|
|
vLight->lightProject[1] = light->lightProject[1];
|
|
vLight->lightProject[2] = light->lightProject[2];
|
|
vLight->lightProject[3] = light->lightProject[3];
|
|
vLight->fogPlane = light->frustum[5];
|
|
vLight->frustumTris = light->frustumTris;
|
|
vLight->falloffImage = light->falloffImage;
|
|
vLight->lightShader = light->lightShader;
|
|
vLight->shaderRegisters = NULL; // allocated and evaluated in R_AddLightSurfaces
|
|
|
|
// link the view light
|
|
vLight->next = tr.viewDef->viewLights;
|
|
tr.viewDef->viewLights = vLight;
|
|
|
|
light->viewLight = vLight;
|
|
|
|
return vLight;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderWorldLocal::CreateLightDefInteractions
|
|
|
|
When a lightDef is determined to effect the view (contact the frustum and non-0 light), it will check to
|
|
make sure that it has interactions for all the entityDefs that it might possibly contact.
|
|
|
|
This does not guarantee that all possible interactions for this light are generated, only that
|
|
the ones that may effect the current view are generated. so it does need to be called every view.
|
|
|
|
This does not cause entityDefs to create dynamic models, all work is done on the referenceBounds.
|
|
|
|
All entities that have non-empty interactions with viewLights will
|
|
have viewEntities made for them and be put on the viewEntity list,
|
|
even if their surfaces aren't visible, because they may need to cast shadows.
|
|
|
|
Interactions are usually removed when a entityDef or lightDef is modified, unless the change
|
|
is known to not effect them, so there is no danger of getting a stale interaction, we just need to
|
|
check that needed ones are created.
|
|
|
|
An interaction can be at several levels:
|
|
|
|
Don't interact (but share an area) (numSurfaces = 0)
|
|
Entity reference bounds touches light frustum, but surfaces haven't been generated (numSurfaces = -1)
|
|
Shadow surfaces have been generated, but light surfaces have not. The shadow surface may still be empty due to bounds being conservative.
|
|
Both shadow and light surfaces have been generated. Either or both surfaces may still be empty due to conservative bounds.
|
|
|
|
=================
|
|
*/
|
|
void idRenderWorldLocal::CreateLightDefInteractions( idRenderLightLocal *ldef ) {
|
|
areaReference_t *eref;
|
|
areaReference_t *lref;
|
|
idRenderEntityLocal *edef;
|
|
portalArea_t *area;
|
|
idInteraction *inter;
|
|
|
|
for ( lref = ldef->references ; lref ; lref = lref->ownerNext ) {
|
|
area = lref->area;
|
|
|
|
// check all the models in this area
|
|
for ( eref = area->entityRefs.areaNext ; eref != &area->entityRefs ; eref = eref->areaNext ) {
|
|
edef = eref->entity;
|
|
|
|
// if the entity doesn't have any light-interacting surfaces, we could skip this,
|
|
// but we don't want to instantiate dynamic models yet, so we can't check that on
|
|
// most things
|
|
|
|
// if the entity isn't viewed
|
|
if ( tr.viewDef && edef->viewCount != tr.viewCount ) {
|
|
// if the light doesn't cast shadows, skip
|
|
if ( !ldef->lightShader->LightCastsShadows() ) {
|
|
continue;
|
|
}
|
|
// if we are suppressing its shadow in this view, skip
|
|
if ( !r_skipSuppress.GetBool() ) {
|
|
if ( edef->parms.suppressShadowInViewID && edef->parms.suppressShadowInViewID == tr.viewDef->renderView.viewID ) {
|
|
continue;
|
|
}
|
|
if ( edef->parms.suppressShadowInLightID && edef->parms.suppressShadowInLightID == ldef->parms.lightId ) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// some big outdoor meshes are flagged to not create any dynamic interactions
|
|
// when the level designer knows that nearby moving lights shouldn't actually hit them
|
|
if ( edef->parms.noDynamicInteractions && edef->world->generateAllInteractionsCalled ) {
|
|
continue;
|
|
}
|
|
|
|
// if any of the edef's interaction match this light, we don't
|
|
// need to consider it.
|
|
if ( r_useInteractionTable.GetBool() && this->interactionTable ) {
|
|
// allocating these tables may take several megs on big maps, but it saves 3% to 5% of
|
|
// the CPU time. The table is updated at interaction::AllocAndLink() and interaction::UnlinkAndFree()
|
|
int index = ldef->index * this->interactionTableWidth + edef->index;
|
|
inter = this->interactionTable[ index ];
|
|
if ( inter ) {
|
|
// if this entity wasn't in view already, the scissor rect will be empty,
|
|
// so it will only be used for shadow casting
|
|
if ( !inter->IsEmpty() ) {
|
|
R_SetEntityDefViewEntity( edef );
|
|
}
|
|
continue;
|
|
}
|
|
} else {
|
|
// scan the doubly linked lists, which may have several dozen entries
|
|
|
|
// we could check either model refs or light refs for matches, but it is
|
|
// assumed that there will be less lights in an area than models
|
|
// so the entity chains should be somewhat shorter (they tend to be fairly close).
|
|
for ( inter = edef->firstInteraction; inter != NULL; inter = inter->entityNext ) {
|
|
if ( inter->lightDef == ldef ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if we already have an interaction, we don't need to do anything
|
|
if ( inter != NULL ) {
|
|
// if this entity wasn't in view already, the scissor rect will be empty,
|
|
// so it will only be used for shadow casting
|
|
if ( !inter->IsEmpty() ) {
|
|
R_SetEntityDefViewEntity( edef );
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// create a new interaction, but don't do any work other than bbox to frustum culling
|
|
//
|
|
idInteraction *inter = idInteraction::AllocAndLink( edef, ldef );
|
|
|
|
// do a check of the entity reference bounds against the light frustum,
|
|
// trying to avoid creating a viewEntity if it hasn't been already
|
|
float modelMatrix[16];
|
|
float *m;
|
|
|
|
if ( edef->viewCount == tr.viewCount ) {
|
|
m = edef->viewEntity->modelMatrix;
|
|
} else {
|
|
R_AxisToModelMatrix( edef->parms.axis, edef->parms.origin, modelMatrix );
|
|
m = modelMatrix;
|
|
}
|
|
|
|
if ( R_CullLocalBox( edef->referenceBounds, m, 6, ldef->frustum ) ) {
|
|
inter->MakeEmpty();
|
|
continue;
|
|
}
|
|
|
|
// we will do a more precise per-surface check when we are checking the entity
|
|
|
|
// if this entity wasn't in view already, the scissor rect will be empty,
|
|
// so it will only be used for shadow casting
|
|
R_SetEntityDefViewEntity( edef );
|
|
}
|
|
}
|
|
}
|
|
|
|
//===============================================================================================================
|
|
|
|
/*
|
|
=================
|
|
R_LinkLightSurf
|
|
=================
|
|
*/
|
|
void R_LinkLightSurf( const drawSurf_t **link, const srfTriangles_t *tri, const viewEntity_t *space,
|
|
const idRenderLightLocal *light, const idMaterial *shader, const idScreenRect &scissor, bool viewInsideShadow ) {
|
|
drawSurf_t *drawSurf;
|
|
|
|
if ( !space ) {
|
|
space = &tr.viewDef->worldSpace;
|
|
}
|
|
|
|
drawSurf = (drawSurf_t *)R_FrameAlloc( sizeof( *drawSurf ) );
|
|
|
|
drawSurf->geo = tri;
|
|
drawSurf->space = space;
|
|
drawSurf->material = shader;
|
|
drawSurf->scissorRect = scissor;
|
|
drawSurf->dsFlags = 0;
|
|
drawSurf->particle_radius = 0.0f; // #3878
|
|
|
|
if ( viewInsideShadow ) {
|
|
drawSurf->dsFlags |= DSF_VIEW_INSIDE_SHADOW;
|
|
}
|
|
|
|
if ( !shader ) {
|
|
// shadows won't have a shader
|
|
drawSurf->shaderRegisters = NULL;
|
|
} else {
|
|
// process the shader expressions for conditionals / color / texcoords
|
|
const float *constRegs = shader->ConstantRegisters();
|
|
if ( constRegs ) {
|
|
// this shader has only constants for parameters
|
|
drawSurf->shaderRegisters = constRegs;
|
|
} else {
|
|
// FIXME: share with the ambient surface?
|
|
float *regs = (float *)R_FrameAlloc( shader->GetNumRegisters() * sizeof( float ) );
|
|
drawSurf->shaderRegisters = regs;
|
|
shader->EvaluateRegisters( regs, space->entityDef->parms.shaderParms, tr.viewDef, space->entityDef->parms.referenceSound );
|
|
}
|
|
|
|
// calculate the specular coordinates if we aren't using vertex programs
|
|
if ( !tr.backEndRendererHasVertexPrograms && !r_skipSpecular.GetBool() ) {
|
|
R_SpecularTexGen( drawSurf, light->globalLightOrigin, tr.viewDef->renderView.vieworg );
|
|
// if we failed to allocate space for the specular calculations, drop the surface
|
|
if ( !drawSurf->dynamicTexCoords ) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// actually link it in
|
|
drawSurf->nextOnLight = *link;
|
|
*link = drawSurf;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_ClippedLightScissorRectangle
|
|
======================
|
|
*/
|
|
idScreenRect R_ClippedLightScissorRectangle( viewLight_t *vLight ) {
|
|
int i, j;
|
|
const idRenderLightLocal *light = vLight->lightDef;
|
|
idScreenRect r;
|
|
idFixedWinding w;
|
|
|
|
r.Clear();
|
|
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
const idWinding *ow = light->frustumWindings[i];
|
|
|
|
// projected lights may have one of the frustums degenerated
|
|
if ( !ow ) {
|
|
continue;
|
|
}
|
|
|
|
// the light frustum planes face out from the light,
|
|
// so the planes that have the view origin on the negative
|
|
// side will be the "back" faces of the light, which must have
|
|
// some fragment inside the portalStack to be visible
|
|
if ( light->frustum[i].Distance( tr.viewDef->renderView.vieworg ) >= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
w = *ow;
|
|
|
|
// now check the winding against each of the frustum planes
|
|
for ( j = 0; j < 5; j++ ) {
|
|
if ( !w.ClipInPlace( -tr.viewDef->frustum[j] ) ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// project these points to the screen and add to bounds
|
|
for ( j = 0; j < w.GetNumPoints(); j++ ) {
|
|
idPlane eye, clip;
|
|
idVec3 ndc;
|
|
|
|
R_TransformModelToClip( w[j].ToVec3(), tr.viewDef->worldSpace.modelViewMatrix, tr.viewDef->projectionMatrix, eye, clip );
|
|
|
|
if ( clip[3] <= 0.01f ) {
|
|
clip[3] = 0.01f;
|
|
}
|
|
|
|
R_TransformClipToDevice( clip, tr.viewDef, ndc );
|
|
|
|
float windowX = 0.5f * ( 1.0f + ndc[0] ) * ( tr.viewDef->viewport.x2 - tr.viewDef->viewport.x1 );
|
|
float windowY = 0.5f * ( 1.0f + ndc[1] ) * ( tr.viewDef->viewport.y2 - tr.viewDef->viewport.y1 );
|
|
|
|
if ( windowX > tr.viewDef->scissor.x2 ) {
|
|
windowX = tr.viewDef->scissor.x2;
|
|
} else if ( windowX < tr.viewDef->scissor.x1 ) {
|
|
windowX = tr.viewDef->scissor.x1;
|
|
}
|
|
if ( windowY > tr.viewDef->scissor.y2 ) {
|
|
windowY = tr.viewDef->scissor.y2;
|
|
} else if ( windowY < tr.viewDef->scissor.y1 ) {
|
|
windowY = tr.viewDef->scissor.y1;
|
|
}
|
|
|
|
r.AddPoint( windowX, windowY );
|
|
}
|
|
}
|
|
|
|
// add the fudge boundary
|
|
r.Expand();
|
|
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
R_CalcLightScissorRectangle
|
|
|
|
The light screen bounds will be used to crop the scissor rect during
|
|
stencil clears and interaction drawing
|
|
==================
|
|
*/
|
|
int c_clippedLight, c_unclippedLight;
|
|
|
|
idScreenRect R_CalcLightScissorRectangle( viewLight_t *vLight ) {
|
|
idScreenRect r;
|
|
srfTriangles_t *tri;
|
|
idPlane eye, clip;
|
|
idVec3 ndc;
|
|
|
|
if ( vLight->lightDef->parms.pointLight ) {
|
|
idBounds bounds;
|
|
idRenderLightLocal *lightDef = vLight->lightDef;
|
|
tr.viewDef->viewFrustum.ProjectionBounds( idBox( lightDef->parms.origin, lightDef->parms.lightRadius, lightDef->parms.axis ), bounds );
|
|
return R_ScreenRectFromViewFrustumBounds( bounds );
|
|
}
|
|
|
|
if ( r_useClippedLightScissors.GetInteger() == 2 ) {
|
|
return R_ClippedLightScissorRectangle( vLight );
|
|
}
|
|
|
|
r.Clear();
|
|
|
|
tri = vLight->lightDef->frustumTris;
|
|
for ( int i = 0 ; i < tri->numVerts ; i++ ) {
|
|
R_TransformModelToClip( tri->verts[i].xyz, tr.viewDef->worldSpace.modelViewMatrix,
|
|
tr.viewDef->projectionMatrix, eye, clip );
|
|
|
|
// if it is near clipped, clip the winding polygons to the view frustum
|
|
if ( clip[3] <= 1 ) {
|
|
c_clippedLight++;
|
|
if ( r_useClippedLightScissors.GetInteger() ) {
|
|
return R_ClippedLightScissorRectangle( vLight );
|
|
} else {
|
|
r.x1 = r.y1 = 0;
|
|
r.x2 = ( tr.viewDef->viewport.x2 - tr.viewDef->viewport.x1 ) - 1;
|
|
r.y2 = ( tr.viewDef->viewport.y2 - tr.viewDef->viewport.y1 ) - 1;
|
|
return r;
|
|
}
|
|
}
|
|
|
|
R_TransformClipToDevice( clip, tr.viewDef, ndc );
|
|
|
|
float windowX = 0.5f * ( 1.0f + ndc[0] ) * ( tr.viewDef->viewport.x2 - tr.viewDef->viewport.x1 );
|
|
float windowY = 0.5f * ( 1.0f + ndc[1] ) * ( tr.viewDef->viewport.y2 - tr.viewDef->viewport.y1 );
|
|
|
|
if ( windowX > tr.viewDef->scissor.x2 ) {
|
|
windowX = tr.viewDef->scissor.x2;
|
|
} else if ( windowX < tr.viewDef->scissor.x1 ) {
|
|
windowX = tr.viewDef->scissor.x1;
|
|
}
|
|
if ( windowY > tr.viewDef->scissor.y2 ) {
|
|
windowY = tr.viewDef->scissor.y2;
|
|
} else if ( windowY < tr.viewDef->scissor.y1 ) {
|
|
windowY = tr.viewDef->scissor.y1;
|
|
}
|
|
|
|
r.AddPoint( windowX, windowY );
|
|
}
|
|
|
|
// add the fudge boundary
|
|
r.Expand();
|
|
|
|
c_unclippedLight++;
|
|
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_AddLightSurfaces
|
|
|
|
Calc the light shader values, removing any light from the viewLight list
|
|
if it is determined to not have any visible effect due to being flashed off or turned off.
|
|
|
|
Adds entities to the viewEntity list if they are needed for shadow casting.
|
|
|
|
Add any precomputed shadow volumes.
|
|
|
|
Removes lights from the viewLights list if they are completely
|
|
turned off, or completely off screen.
|
|
|
|
Create any new interactions needed between the viewLights
|
|
and the viewEntitys due to game movement
|
|
=================
|
|
*/
|
|
void R_AddLightSurfaces( void ) {
|
|
viewLight_t *vLight;
|
|
idRenderLightLocal *light;
|
|
viewLight_t **ptr;
|
|
|
|
// go through each visible light, possibly removing some from the list
|
|
ptr = &tr.viewDef->viewLights;
|
|
while ( *ptr ) {
|
|
vLight = *ptr;
|
|
light = vLight->lightDef;
|
|
|
|
const idMaterial *lightShader = light->lightShader;
|
|
if ( !lightShader ) {
|
|
common->Error( "R_AddLightSurfaces: NULL lightShader" );
|
|
}
|
|
|
|
// see if we are suppressing the light in this view
|
|
if ( !r_skipSuppress.GetBool() ) {
|
|
if ( light->parms.suppressLightInViewID
|
|
&& light->parms.suppressLightInViewID == tr.viewDef->renderView.viewID ) {
|
|
*ptr = vLight->next;
|
|
light->viewCount = -1;
|
|
continue;
|
|
}
|
|
if ( light->parms.allowLightInViewID
|
|
&& light->parms.allowLightInViewID != tr.viewDef->renderView.viewID ) {
|
|
*ptr = vLight->next;
|
|
light->viewCount = -1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// evaluate the light shader registers
|
|
float *lightRegs =(float *)R_FrameAlloc( lightShader->GetNumRegisters() * sizeof( float ) );
|
|
vLight->shaderRegisters = lightRegs;
|
|
lightShader->EvaluateRegisters( lightRegs, light->parms.shaderParms, tr.viewDef, light->parms.referenceSound );
|
|
|
|
// if this is a purely additive light and no stage in the light shader evaluates
|
|
// to a positive light value, we can completely skip the light
|
|
if ( !lightShader->IsFogLight() && !lightShader->IsBlendLight() ) {
|
|
int lightStageNum;
|
|
for ( lightStageNum = 0 ; lightStageNum < lightShader->GetNumStages() ; lightStageNum++ ) {
|
|
const shaderStage_t *lightStage = lightShader->GetStage( lightStageNum );
|
|
|
|
// ignore stages that fail the condition
|
|
if ( !lightRegs[ lightStage->conditionRegister ] ) {
|
|
continue;
|
|
}
|
|
|
|
const int *registers = lightStage->color.registers;
|
|
|
|
// snap tiny values to zero to avoid lights showing up with the wrong color
|
|
if ( lightRegs[ registers[0] ] < 0.001f ) {
|
|
lightRegs[ registers[0] ] = 0.0f;
|
|
}
|
|
if ( lightRegs[ registers[1] ] < 0.001f ) {
|
|
lightRegs[ registers[1] ] = 0.0f;
|
|
}
|
|
if ( lightRegs[ registers[2] ] < 0.001f ) {
|
|
lightRegs[ registers[2] ] = 0.0f;
|
|
}
|
|
|
|
// FIXME: when using the following values the light shows up bright red when using nvidia drivers/hardware
|
|
// this seems to have been fixed ?
|
|
//lightRegs[ registers[0] ] = 1.5143074e-005f;
|
|
//lightRegs[ registers[1] ] = 1.5483369e-005f;
|
|
//lightRegs[ registers[2] ] = 1.7014690e-005f;
|
|
|
|
if ( lightRegs[ registers[0] ] > 0.0f ||
|
|
lightRegs[ registers[1] ] > 0.0f ||
|
|
lightRegs[ registers[2] ] > 0.0f ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( lightStageNum == lightShader->GetNumStages() ) {
|
|
// we went through all the stages and didn't find one that adds anything
|
|
// remove the light from the viewLights list, and change its frame marker
|
|
// so interaction generation doesn't think the light is visible and
|
|
// create a shadow for it
|
|
*ptr = vLight->next;
|
|
light->viewCount = -1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( r_useLightScissors.GetBool() ) {
|
|
// calculate the screen area covered by the light frustum
|
|
// which will be used to crop the stencil cull
|
|
idScreenRect scissorRect = R_CalcLightScissorRectangle( vLight );
|
|
// intersect with the portal crossing scissor rectangle
|
|
vLight->scissorRect.Intersect( scissorRect );
|
|
|
|
if ( r_showLightScissors.GetBool() ) {
|
|
R_ShowColoredScreenRect( vLight->scissorRect, light->index );
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
// this never happens, because CullLightByPortals() does a more precise job
|
|
if ( vLight->scissorRect.IsEmpty() ) {
|
|
// this light doesn't touch anything on screen, so remove it from the list
|
|
*ptr = vLight->next;
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
// this one stays on the list
|
|
ptr = &vLight->next;
|
|
|
|
// if we are doing a soft-shadow novelty test, regenerate the light with
|
|
// a random offset every time
|
|
if ( r_lightSourceRadius.GetFloat() != 0.0f ) {
|
|
for ( int i = 0 ; i < 3 ; i++ ) {
|
|
light->globalLightOrigin[i] += r_lightSourceRadius.GetFloat() * ( -1 + 2 * (rand()&0xfff)/(float)0xfff );
|
|
}
|
|
}
|
|
|
|
// create interactions with all entities the light may touch, and add viewEntities
|
|
// that may cast shadows, even if they aren't directly visible. Any real work
|
|
// will be deferred until we walk through the viewEntities
|
|
tr.viewDef->renderWorld->CreateLightDefInteractions( light );
|
|
tr.pc.c_viewLights++;
|
|
|
|
// fog lights will need to draw the light frustum triangles, so make sure they
|
|
// are in the vertex cache
|
|
if ( lightShader->IsFogLight() ) {
|
|
if ( !light->frustumTris->ambientCache ) {
|
|
if ( !R_CreateAmbientCache( light->frustumTris, false ) ) {
|
|
// skip if we are out of vertex memory
|
|
continue;
|
|
}
|
|
}
|
|
// touch the surface so it won't get purged
|
|
vertexCache.Touch( light->frustumTris->ambientCache );
|
|
}
|
|
|
|
// add the prelight shadows for the static world geometry
|
|
if ( light->parms.prelightModel && r_useOptimizedShadows.GetBool() ) {
|
|
|
|
if ( !light->parms.prelightModel->NumSurfaces() ) {
|
|
common->Error( "no surfs in prelight model '%s'", light->parms.prelightModel->Name() );
|
|
}
|
|
|
|
srfTriangles_t *tri = light->parms.prelightModel->Surface( 0 )->geometry;
|
|
if ( !tri->shadowVertexes ) {
|
|
common->Error( "R_AddLightSurfaces: prelight model '%s' without shadowVertexes", light->parms.prelightModel->Name() );
|
|
}
|
|
|
|
// these shadows will all have valid bounds, and can be culled normally
|
|
if ( r_useShadowCulling.GetBool() ) {
|
|
if ( R_CullLocalBox( tri->bounds, tr.viewDef->worldSpace.modelMatrix, 5, tr.viewDef->frustum ) ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// if we have been purged, re-upload the shadowVertexes
|
|
if ( !tri->shadowCache ) {
|
|
R_CreatePrivateShadowCache( tri );
|
|
if ( !tri->shadowCache ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// touch the shadow surface so it won't get purged
|
|
vertexCache.Touch( tri->shadowCache );
|
|
|
|
if ( !tri->indexCache && r_useIndexBuffers.GetBool() ) {
|
|
vertexCache.Alloc( tri->indexes, tri->numIndexes * sizeof( tri->indexes[0] ), &tri->indexCache, true );
|
|
}
|
|
if ( tri->indexCache ) {
|
|
vertexCache.Touch( tri->indexCache );
|
|
}
|
|
|
|
R_LinkLightSurf( &vLight->globalShadows, tri, NULL, light, NULL, vLight->scissorRect, true /* FIXME? */ );
|
|
}
|
|
}
|
|
}
|
|
|
|
//===============================================================================================================
|
|
|
|
/*
|
|
==================
|
|
R_IssueEntityDefCallback
|
|
==================
|
|
*/
|
|
bool R_IssueEntityDefCallback( idRenderEntityLocal *def ) {
|
|
bool update;
|
|
idBounds oldBounds;
|
|
const bool checkBounds = r_checkBounds.GetBool();
|
|
|
|
if ( checkBounds ) {
|
|
oldBounds = def->referenceBounds;
|
|
}
|
|
|
|
def->archived = false; // will need to be written to the demo file
|
|
tr.pc.c_entityDefCallbacks++;
|
|
if ( tr.viewDef ) {
|
|
update = def->parms.callback( &def->parms, &tr.viewDef->renderView );
|
|
} else {
|
|
update = def->parms.callback( &def->parms, NULL );
|
|
}
|
|
|
|
if ( !def->parms.hModel ) {
|
|
common->Error( "R_IssueEntityDefCallback: dynamic entity callback didn't set model" );
|
|
return false;
|
|
}
|
|
|
|
if ( checkBounds ) {
|
|
if ( oldBounds[0][0] > def->referenceBounds[0][0] + CHECK_BOUNDS_EPSILON ||
|
|
oldBounds[0][1] > def->referenceBounds[0][1] + CHECK_BOUNDS_EPSILON ||
|
|
oldBounds[0][2] > def->referenceBounds[0][2] + CHECK_BOUNDS_EPSILON ||
|
|
oldBounds[1][0] < def->referenceBounds[1][0] - CHECK_BOUNDS_EPSILON ||
|
|
oldBounds[1][1] < def->referenceBounds[1][1] - CHECK_BOUNDS_EPSILON ||
|
|
oldBounds[1][2] < def->referenceBounds[1][2] - CHECK_BOUNDS_EPSILON ) {
|
|
common->Printf( "entity %i callback extended reference bounds\n", def->index );
|
|
}
|
|
}
|
|
|
|
return update;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_EntityDefDynamicModel
|
|
|
|
Issues a deferred entity callback if necessary.
|
|
If the model isn't dynamic, it returns the original.
|
|
Returns the cached dynamic model if present, otherwise creates
|
|
it and any necessary overlays
|
|
===================
|
|
*/
|
|
idRenderModel *R_EntityDefDynamicModel( idRenderEntityLocal *def ) {
|
|
bool callbackUpdate;
|
|
|
|
// allow deferred entities to construct themselves
|
|
if ( def->parms.callback ) {
|
|
callbackUpdate = R_IssueEntityDefCallback( def );
|
|
} else {
|
|
callbackUpdate = false;
|
|
}
|
|
|
|
idRenderModel *model = def->parms.hModel;
|
|
|
|
if ( !model ) {
|
|
common->Error( "R_EntityDefDynamicModel: NULL model" );
|
|
}
|
|
|
|
if ( model->IsDynamicModel() == DM_STATIC ) {
|
|
def->dynamicModel = NULL;
|
|
def->dynamicModelFrameCount = 0;
|
|
return model;
|
|
}
|
|
|
|
// continously animating models (particle systems, etc) will have their snapshot updated every single view
|
|
if ( callbackUpdate || ( model->IsDynamicModel() == DM_CONTINUOUS && def->dynamicModelFrameCount != tr.frameCount ) ) {
|
|
R_ClearEntityDefDynamicModel( def );
|
|
}
|
|
|
|
// if we don't have a snapshot of the dynamic model, generate it now
|
|
if ( !def->dynamicModel ) {
|
|
|
|
// instantiate the snapshot of the dynamic model, possibly reusing memory from the cached snapshot
|
|
def->cachedDynamicModel = model->InstantiateDynamicModel( &def->parms, tr.viewDef, def->cachedDynamicModel );
|
|
|
|
if ( def->cachedDynamicModel ) {
|
|
|
|
// add any overlays to the snapshot of the dynamic model
|
|
if ( def->overlay && !r_skipOverlays.GetBool() ) {
|
|
def->overlay->AddOverlaySurfacesToModel( def->cachedDynamicModel );
|
|
} else {
|
|
idRenderModelOverlay::RemoveOverlaySurfacesFromModel( def->cachedDynamicModel );
|
|
}
|
|
|
|
if ( r_checkBounds.GetBool() ) {
|
|
idBounds b = def->cachedDynamicModel->Bounds();
|
|
if ( b[0][0] < def->referenceBounds[0][0] - CHECK_BOUNDS_EPSILON ||
|
|
b[0][1] < def->referenceBounds[0][1] - CHECK_BOUNDS_EPSILON ||
|
|
b[0][2] < def->referenceBounds[0][2] - CHECK_BOUNDS_EPSILON ||
|
|
b[1][0] > def->referenceBounds[1][0] + CHECK_BOUNDS_EPSILON ||
|
|
b[1][1] > def->referenceBounds[1][1] + CHECK_BOUNDS_EPSILON ||
|
|
b[1][2] > def->referenceBounds[1][2] + CHECK_BOUNDS_EPSILON ) {
|
|
common->Printf( "entity %i dynamic model exceeded reference bounds\n", def->index );
|
|
}
|
|
}
|
|
}
|
|
|
|
def->dynamicModel = def->cachedDynamicModel;
|
|
def->dynamicModelFrameCount = tr.frameCount;
|
|
}
|
|
|
|
// set model depth hack value
|
|
if ( def->dynamicModel && model->DepthHack() != 0.0f && tr.viewDef ) {
|
|
idPlane eye, clip;
|
|
idVec3 ndc;
|
|
R_TransformModelToClip( def->parms.origin, tr.viewDef->worldSpace.modelViewMatrix, tr.viewDef->projectionMatrix, eye, clip );
|
|
R_TransformClipToDevice( clip, tr.viewDef, ndc );
|
|
def->parms.modelDepthHack = model->DepthHack() * ( 1.0f - ndc.z );
|
|
}
|
|
|
|
// FIXME: if any of the surfaces have deforms, create a frame-temporary model with references to the
|
|
// undeformed surfaces. This would allow deforms to be light interacting.
|
|
|
|
return def->dynamicModel;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_AddDrawSurf
|
|
=================
|
|
*/
|
|
void R_AddDrawSurf( const srfTriangles_t *tri, const viewEntity_t *space, const renderEntity_t *renderEntity,
|
|
const idMaterial *shader, const idScreenRect &scissor, const float soft_particle_radius )
|
|
{
|
|
drawSurf_t *drawSurf;
|
|
const float *shaderParms;
|
|
static float refRegs[MAX_EXPRESSION_REGISTERS]; // don't put on stack, or VC++ will do a page touch
|
|
float generatedShaderParms[MAX_ENTITY_SHADER_PARMS];
|
|
|
|
drawSurf = (drawSurf_t *)R_FrameAlloc( sizeof( *drawSurf ) );
|
|
drawSurf->geo = tri;
|
|
drawSurf->space = space;
|
|
drawSurf->material = shader;
|
|
drawSurf->scissorRect = scissor;
|
|
drawSurf->sort = shader->GetSort() + tr.sortOffset;
|
|
|
|
if ( soft_particle_radius != -1.0f ) // #3878
|
|
{
|
|
drawSurf->dsFlags = DSF_SOFT_PARTICLE;
|
|
drawSurf->particle_radius = soft_particle_radius;
|
|
}
|
|
else
|
|
{
|
|
drawSurf->dsFlags = 0;
|
|
drawSurf->particle_radius = 0.0f;
|
|
}
|
|
|
|
// bumping this offset each time causes surfaces with equal sort orders to still
|
|
// deterministically draw in the order they are added
|
|
tr.sortOffset += 0.000001f;
|
|
|
|
// if it doesn't fit, resize the list
|
|
if ( tr.viewDef->numDrawSurfs == tr.viewDef->maxDrawSurfs ) {
|
|
drawSurf_t **old = tr.viewDef->drawSurfs;
|
|
int count;
|
|
|
|
if ( tr.viewDef->maxDrawSurfs == 0 ) {
|
|
tr.viewDef->maxDrawSurfs = INITIAL_DRAWSURFS;
|
|
count = 0;
|
|
} else {
|
|
count = tr.viewDef->maxDrawSurfs * sizeof( tr.viewDef->drawSurfs[0] );
|
|
tr.viewDef->maxDrawSurfs *= 2;
|
|
}
|
|
tr.viewDef->drawSurfs = (drawSurf_t **)R_FrameAlloc( tr.viewDef->maxDrawSurfs * sizeof( tr.viewDef->drawSurfs[0] ) );
|
|
if(count > 0)
|
|
memcpy( tr.viewDef->drawSurfs, old, count );
|
|
}
|
|
tr.viewDef->drawSurfs[tr.viewDef->numDrawSurfs] = drawSurf;
|
|
tr.viewDef->numDrawSurfs++;
|
|
|
|
// process the shader expressions for conditionals / color / texcoords
|
|
const float *constRegs = shader->ConstantRegisters();
|
|
if ( constRegs ) {
|
|
// shader only uses constant values
|
|
drawSurf->shaderRegisters = constRegs;
|
|
} else {
|
|
float *regs = (float *)R_FrameAlloc( shader->GetNumRegisters() * sizeof( float ) );
|
|
drawSurf->shaderRegisters = regs;
|
|
|
|
// a reference shader will take the calculated stage color value from another shader
|
|
// and use that for the parm0-parm3 of the current shader, which allows a stage of
|
|
// a light model and light flares to pick up different flashing tables from
|
|
// different light shaders
|
|
if ( renderEntity->referenceShader ) {
|
|
// evaluate the reference shader to find our shader parms
|
|
const shaderStage_t *pStage;
|
|
|
|
renderEntity->referenceShader->EvaluateRegisters( refRegs, renderEntity->shaderParms, tr.viewDef, renderEntity->referenceSound );
|
|
pStage = renderEntity->referenceShader->GetStage(0);
|
|
|
|
memcpy( generatedShaderParms, renderEntity->shaderParms, sizeof( generatedShaderParms ) );
|
|
generatedShaderParms[0] = refRegs[ pStage->color.registers[0] ];
|
|
generatedShaderParms[1] = refRegs[ pStage->color.registers[1] ];
|
|
generatedShaderParms[2] = refRegs[ pStage->color.registers[2] ];
|
|
|
|
shaderParms = generatedShaderParms;
|
|
} else {
|
|
// evaluate with the entityDef's shader parms
|
|
shaderParms = renderEntity->shaderParms;
|
|
}
|
|
|
|
float oldFloatTime = 0.0f;
|
|
int oldTime = 0;
|
|
|
|
if ( space->entityDef && space->entityDef->parms.timeGroup ) {
|
|
oldFloatTime = tr.viewDef->floatTime;
|
|
oldTime = tr.viewDef->renderView.time;
|
|
|
|
tr.viewDef->floatTime = game->GetTimeGroupTime( space->entityDef->parms.timeGroup ) * 0.001;
|
|
tr.viewDef->renderView.time = game->GetTimeGroupTime( space->entityDef->parms.timeGroup );
|
|
}
|
|
|
|
shader->EvaluateRegisters( regs, shaderParms, tr.viewDef, renderEntity->referenceSound );
|
|
|
|
if ( space->entityDef && space->entityDef->parms.timeGroup ) {
|
|
tr.viewDef->floatTime = oldFloatTime;
|
|
tr.viewDef->renderView.time = oldTime;
|
|
}
|
|
}
|
|
|
|
// check for deformations
|
|
R_DeformDrawSurf( drawSurf );
|
|
|
|
// skybox surfaces need a dynamic texgen
|
|
switch( shader->Texgen() ) {
|
|
case TG_SKYBOX_CUBE:
|
|
R_SkyboxTexGen( drawSurf, tr.viewDef->renderView.vieworg );
|
|
break;
|
|
case TG_WOBBLESKY_CUBE:
|
|
R_WobbleskyTexGen( drawSurf, tr.viewDef->renderView.vieworg );
|
|
break;
|
|
}
|
|
|
|
// check for gui surfaces
|
|
idUserInterface *gui = NULL;
|
|
|
|
if ( !space->entityDef ) {
|
|
gui = shader->GlobalGui();
|
|
} else {
|
|
int guiNum = shader->GetEntityGui() - 1;
|
|
if ( guiNum >= 0 && guiNum < MAX_RENDERENTITY_GUI ) {
|
|
gui = renderEntity->gui[ guiNum ];
|
|
}
|
|
if ( gui == NULL ) {
|
|
gui = shader->GlobalGui();
|
|
}
|
|
}
|
|
|
|
if ( gui ) {
|
|
// force guis on the fast time
|
|
float oldFloatTime;
|
|
int oldTime;
|
|
|
|
oldFloatTime = tr.viewDef->floatTime;
|
|
oldTime = tr.viewDef->renderView.time;
|
|
|
|
tr.viewDef->floatTime = game->GetTimeGroupTime( 1 ) * 0.001;
|
|
tr.viewDef->renderView.time = game->GetTimeGroupTime( 1 );
|
|
|
|
idBounds ndcBounds;
|
|
|
|
if ( !R_PreciseCullSurface( drawSurf, ndcBounds ) ) {
|
|
// did we ever use this to forward an entity color to a gui that didn't set color?
|
|
// memcpy( tr.guiShaderParms, shaderParms, sizeof( tr.guiShaderParms ) );
|
|
R_RenderGuiSurf( gui, drawSurf );
|
|
}
|
|
|
|
tr.viewDef->floatTime = oldFloatTime;
|
|
tr.viewDef->renderView.time = oldTime;
|
|
}
|
|
|
|
// we can't add subviews at this point, because that would
|
|
// increment tr.viewCount, messing up the rest of the surface
|
|
// adds for this view
|
|
}
|
|
|
|
/*
|
|
===============
|
|
R_AddAmbientDrawsurfs
|
|
|
|
Adds surfaces for the given viewEntity
|
|
Walks through the viewEntitys list and creates drawSurf_t for each surface of
|
|
each viewEntity that has a non-empty scissorRect
|
|
===============
|
|
*/
|
|
static void R_AddAmbientDrawsurfs( viewEntity_t *vEntity ) {
|
|
int i, total;
|
|
idRenderEntityLocal *def;
|
|
srfTriangles_t *tri;
|
|
idRenderModel *model;
|
|
const idMaterial *shader;
|
|
|
|
def = vEntity->entityDef;
|
|
|
|
if ( def->dynamicModel ) {
|
|
model = def->dynamicModel;
|
|
} else {
|
|
model = def->parms.hModel;
|
|
}
|
|
|
|
// add all the surfaces
|
|
total = model->NumSurfaces();
|
|
for ( i = 0 ; i < total ; i++ ) {
|
|
const modelSurface_t *surf = model->Surface( i );
|
|
|
|
// for debugging, only show a single surface at a time
|
|
if ( r_singleSurface.GetInteger() >= 0 && i != r_singleSurface.GetInteger() ) {
|
|
continue;
|
|
}
|
|
|
|
tri = surf->geometry;
|
|
if ( !tri ) {
|
|
continue;
|
|
}
|
|
if ( !tri->numIndexes ) {
|
|
continue;
|
|
}
|
|
shader = surf->shader;
|
|
shader = R_RemapShaderBySkin( shader, def->parms.customSkin, def->parms.customShader );
|
|
|
|
R_GlobalShaderOverride( &shader );
|
|
|
|
if ( !shader ) {
|
|
continue;
|
|
}
|
|
if ( !shader->IsDrawn() ) {
|
|
continue;
|
|
}
|
|
|
|
// debugging tool to make sure we are have the correct pre-calculated bounds
|
|
if ( r_checkBounds.GetBool() ) {
|
|
int j, k;
|
|
for ( j = 0 ; j < tri->numVerts ; j++ ) {
|
|
for ( k = 0 ; k < 3 ; k++ ) {
|
|
if ( tri->verts[j].xyz[k] > tri->bounds[1][k] + CHECK_BOUNDS_EPSILON
|
|
|| tri->verts[j].xyz[k] < tri->bounds[0][k] - CHECK_BOUNDS_EPSILON ) {
|
|
common->Printf( "bad tri->bounds on %s:%s\n", def->parms.hModel->Name(), shader->GetName() );
|
|
break;
|
|
}
|
|
if ( tri->verts[j].xyz[k] > def->referenceBounds[1][k] + CHECK_BOUNDS_EPSILON
|
|
|| tri->verts[j].xyz[k] < def->referenceBounds[0][k] - CHECK_BOUNDS_EPSILON ) {
|
|
common->Printf( "bad referenceBounds on %s:%s\n", def->parms.hModel->Name(), shader->GetName() );
|
|
break;
|
|
}
|
|
}
|
|
if ( k != 3 ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !R_CullLocalBox( tri->bounds, vEntity->modelMatrix, 5, tr.viewDef->frustum ) ) {
|
|
|
|
def->visibleCount = tr.viewCount;
|
|
|
|
// make sure we have an ambient cache
|
|
if ( !R_CreateAmbientCache( tri, shader->ReceivesLighting() ) ) {
|
|
// don't add anything if the vertex cache was too full to give us an ambient cache
|
|
return;
|
|
}
|
|
// touch it so it won't get purged
|
|
vertexCache.Touch( tri->ambientCache );
|
|
|
|
if ( r_useIndexBuffers.GetBool() && !tri->indexCache ) {
|
|
vertexCache.Alloc( tri->indexes, tri->numIndexes * sizeof( tri->indexes[0] ), &tri->indexCache, true );
|
|
}
|
|
if ( tri->indexCache ) {
|
|
vertexCache.Touch( tri->indexCache );
|
|
}
|
|
|
|
// Soft Particles -- SteveL #3878
|
|
float particle_radius = -1.0f; // Default = disallow softening, but allow modelDepthHack if specified in the decl.
|
|
if ( r_useSoftParticles.GetBool() && r_enableDepthCapture.GetInteger() != 0
|
|
&& !shader->ReceivesLighting() // don't soften surfaces that are meant to be solid
|
|
&& tr.viewDef->renderView.viewID >= 0 ) // Skip during "invisible" rendering passes (e.g. lightgem)
|
|
{
|
|
const idRenderModelPrt* prt = dynamic_cast<const idRenderModelPrt*>( def->parms.hModel ); // yuck.
|
|
if ( prt )
|
|
{
|
|
particle_radius = prt->SofteningRadius( surf->id );
|
|
}
|
|
}
|
|
|
|
// add the surface for drawing
|
|
R_AddDrawSurf( tri, vEntity, &vEntity->entityDef->parms, shader, vEntity->scissorRect, particle_radius );
|
|
|
|
// ambientViewCount is used to allow light interactions to be rejected
|
|
// if the ambient surface isn't visible at all
|
|
tri->ambientViewCount = tr.viewCount;
|
|
}
|
|
}
|
|
|
|
// add the lightweight decal surfaces
|
|
for ( idRenderModelDecal *decal = def->decals; decal; decal = decal->Next() ) {
|
|
decal->AddDecalDrawSurf( vEntity );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
R_CalcEntityScissorRectangle
|
|
==================
|
|
*/
|
|
idScreenRect R_CalcEntityScissorRectangle( viewEntity_t *vEntity ) {
|
|
idBounds bounds;
|
|
idRenderEntityLocal *def = vEntity->entityDef;
|
|
|
|
tr.viewDef->viewFrustum.ProjectionBounds( idBox( def->referenceBounds, def->parms.origin, def->parms.axis ), bounds );
|
|
|
|
return R_ScreenRectFromViewFrustumBounds( bounds );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_AddModelSurfaces
|
|
|
|
Here is where dynamic models actually get instantiated, and necessary
|
|
interactions get created. This is all done on a sort-by-model basis
|
|
to keep source data in cache (most likely L2) as any interactions and
|
|
shadows are generated, since dynamic models will typically be lit by
|
|
two or more lights.
|
|
===================
|
|
*/
|
|
void R_AddModelSurfaces( void ) {
|
|
viewEntity_t *vEntity;
|
|
idInteraction *inter, *next;
|
|
idRenderModel *model;
|
|
|
|
// clear the ambient surface list
|
|
tr.viewDef->numDrawSurfs = 0;
|
|
tr.viewDef->maxDrawSurfs = 0; // will be set to INITIAL_DRAWSURFS on R_AddDrawSurf
|
|
|
|
// go through each entity that is either visible to the view, or to
|
|
// any light that intersects the view (for shadows)
|
|
for ( vEntity = tr.viewDef->viewEntitys; vEntity; vEntity = vEntity->next ) {
|
|
|
|
if ( r_useEntityScissors.GetBool() ) {
|
|
// calculate the screen area covered by the entity
|
|
idScreenRect scissorRect = R_CalcEntityScissorRectangle( vEntity );
|
|
// intersect with the portal crossing scissor rectangle
|
|
vEntity->scissorRect.Intersect( scissorRect );
|
|
|
|
if ( r_showEntityScissors.GetBool() ) {
|
|
R_ShowColoredScreenRect( vEntity->scissorRect, vEntity->entityDef->index );
|
|
}
|
|
}
|
|
|
|
float oldFloatTime = 0.0f;
|
|
int oldTime = 0;
|
|
|
|
game->SelectTimeGroup( vEntity->entityDef->parms.timeGroup );
|
|
|
|
if ( vEntity->entityDef->parms.timeGroup ) {
|
|
oldFloatTime = tr.viewDef->floatTime;
|
|
oldTime = tr.viewDef->renderView.time;
|
|
|
|
tr.viewDef->floatTime = game->GetTimeGroupTime( vEntity->entityDef->parms.timeGroup ) * 0.001;
|
|
tr.viewDef->renderView.time = game->GetTimeGroupTime( vEntity->entityDef->parms.timeGroup );
|
|
}
|
|
|
|
if ( tr.viewDef->isXraySubview && vEntity->entityDef->parms.xrayIndex == 1 ) {
|
|
if ( vEntity->entityDef->parms.timeGroup ) {
|
|
tr.viewDef->floatTime = oldFloatTime;
|
|
tr.viewDef->renderView.time = oldTime;
|
|
}
|
|
continue;
|
|
} else if ( !tr.viewDef->isXraySubview && vEntity->entityDef->parms.xrayIndex == 2 ) {
|
|
if ( vEntity->entityDef->parms.timeGroup ) {
|
|
tr.viewDef->floatTime = oldFloatTime;
|
|
tr.viewDef->renderView.time = oldTime;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Don't let particle entities re-instantiate their dynamic model during non-visible
|
|
// views (in TDM, the light gem render) -- SteveL #3970
|
|
if ( tr.viewDef->renderView.viewID < 0
|
|
&& dynamic_cast<const idRenderModelPrt*>( vEntity->entityDef->parms.hModel ) != NULL ) // yuck.
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// add the ambient surface if it has a visible rectangle
|
|
if ( !vEntity->scissorRect.IsEmpty() ) {
|
|
model = R_EntityDefDynamicModel( vEntity->entityDef );
|
|
if ( model == NULL || model->NumSurfaces() <= 0 ) {
|
|
if ( vEntity->entityDef->parms.timeGroup ) {
|
|
tr.viewDef->floatTime = oldFloatTime;
|
|
tr.viewDef->renderView.time = oldTime;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
R_AddAmbientDrawsurfs( vEntity );
|
|
tr.pc.c_visibleViewEntities++;
|
|
} else {
|
|
tr.pc.c_shadowViewEntities++;
|
|
}
|
|
|
|
//
|
|
// for all the entity / light interactions on this entity, add them to the view
|
|
//
|
|
if ( tr.viewDef->isXraySubview ) {
|
|
if ( vEntity->entityDef->parms.xrayIndex == 2 ) {
|
|
for ( inter = vEntity->entityDef->firstInteraction; inter != NULL && !inter->IsEmpty(); inter = next ) {
|
|
next = inter->entityNext;
|
|
if ( inter->lightDef->viewCount != tr.viewCount ) {
|
|
continue;
|
|
}
|
|
inter->AddActiveInteraction();
|
|
}
|
|
}
|
|
} else {
|
|
// all empty interactions are at the end of the list so once the
|
|
// first is encountered all the remaining interactions are empty
|
|
for ( inter = vEntity->entityDef->firstInteraction; inter != NULL && !inter->IsEmpty(); inter = next ) {
|
|
next = inter->entityNext;
|
|
|
|
// skip any lights that aren't currently visible
|
|
// this is run after any lights that are turned off have already
|
|
// been removed from the viewLights list, and had their viewCount cleared
|
|
if ( inter->lightDef->viewCount != tr.viewCount ) {
|
|
continue;
|
|
}
|
|
inter->AddActiveInteraction();
|
|
}
|
|
}
|
|
|
|
if ( vEntity->entityDef->parms.timeGroup ) {
|
|
tr.viewDef->floatTime = oldFloatTime;
|
|
tr.viewDef->renderView.time = oldTime;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
R_RemoveUnecessaryViewLights
|
|
=====================
|
|
*/
|
|
void R_RemoveUnecessaryViewLights( void ) {
|
|
viewLight_t *vLight;
|
|
|
|
// go through each visible light
|
|
for ( vLight = tr.viewDef->viewLights ; vLight ; vLight = vLight->next ) {
|
|
// if the light didn't have any lit surfaces visible, there is no need to
|
|
// draw any of the shadows. We still keep the vLight for debugging
|
|
// draws
|
|
if ( !vLight->localInteractions && !vLight->globalInteractions && !vLight->translucentInteractions ) {
|
|
vLight->localShadows = NULL;
|
|
vLight->globalShadows = NULL;
|
|
}
|
|
}
|
|
|
|
if ( r_useShadowSurfaceScissor.GetBool() ) {
|
|
// shrink the light scissor rect to only intersect the surfaces that will actually be drawn.
|
|
// This doesn't seem to actually help, perhaps because the surface scissor
|
|
// rects aren't actually the surface, but only the portal clippings.
|
|
for ( vLight = tr.viewDef->viewLights ; vLight ; vLight = vLight->next ) {
|
|
const drawSurf_t *surf;
|
|
idScreenRect surfRect;
|
|
|
|
if ( !vLight->lightShader->LightCastsShadows() ) {
|
|
continue;
|
|
}
|
|
|
|
surfRect.Clear();
|
|
|
|
for ( surf = vLight->globalInteractions ; surf ; surf = surf->nextOnLight ) {
|
|
surfRect.Union( surf->scissorRect );
|
|
}
|
|
for ( surf = vLight->localShadows ; surf ; surf = surf->nextOnLight ) {
|
|
const_cast<drawSurf_t *>(surf)->scissorRect.Intersect( surfRect );
|
|
}
|
|
|
|
for ( surf = vLight->localInteractions ; surf ; surf = surf->nextOnLight ) {
|
|
surfRect.Union( surf->scissorRect );
|
|
}
|
|
for ( surf = vLight->globalShadows ; surf ; surf = surf->nextOnLight ) {
|
|
const_cast<drawSurf_t *>(surf)->scissorRect.Intersect( surfRect );
|
|
}
|
|
|
|
for ( surf = vLight->translucentInteractions ; surf ; surf = surf->nextOnLight ) {
|
|
surfRect.Union( surf->scissorRect );
|
|
}
|
|
|
|
vLight->scissorRect.Intersect( surfRect );
|
|
}
|
|
}
|
|
}
|