mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-23 21:02:11 +00:00
736ec20d4d
Don't include the lazy precompiled.h everywhere, only what's required for the compilation unit. platform.h needs to be included instead to provide all essential defines and types. All includes use the relative path to the neo or the game specific root. Move all idlib related includes from idlib/Lib.h to precompiled.h. precompiled.h still exists for the MFC stuff in tools/. Add some missing header guards.
874 lines
23 KiB
C++
874 lines
23 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 "framework/Session.h"
|
|
#include "renderer/ModelManager.h"
|
|
#include "renderer/RenderWorld_local.h"
|
|
#include "ui/UserInterface.h"
|
|
|
|
#include "renderer/tr_local.h"
|
|
|
|
/*
|
|
|
|
|
|
Prelight models
|
|
|
|
"_prelight_<lightname>", ie "_prelight_light1"
|
|
|
|
Static surfaces available to dmap will be processed to optimized
|
|
shadow and lit surface geometry
|
|
|
|
Entity models are never prelighted.
|
|
|
|
Light entity can have a "noPrelight 1" key set to avoid the preprocessing
|
|
and carving of the world. A light that will move should usually have this
|
|
set.
|
|
|
|
Prelight models will usually have multiple surfaces
|
|
|
|
Shadow volume surfaces will have the material "_shadowVolume"
|
|
|
|
The exact same vertexes as the ambient surfaces will be used for the
|
|
non-shadow surfaces, so there is opportunity to share
|
|
|
|
|
|
Reference their parent surfaces?
|
|
Reference their parent area?
|
|
|
|
|
|
If we don't track parts that are in different areas, there will be huge
|
|
losses when an areaportal closed door has a light poking slightly
|
|
through it.
|
|
|
|
There is potential benefit to splitting even the shadow volumes
|
|
at area boundaries, but it would involve the possibility of an
|
|
extra plane of shadow drawing at the area boundary.
|
|
|
|
|
|
interaction lightName numIndexes
|
|
|
|
Shadow volume surface
|
|
|
|
Surfaces in the world cannot have "no self shadow" properties, because all
|
|
the surfaces are considered together for the optimized shadow volume. If
|
|
you want no self shadow on a static surface, you must still make it into an
|
|
entity so it isn't considered in the prelight.
|
|
|
|
|
|
r_hidePrelights
|
|
r_hideNonPrelights
|
|
|
|
|
|
|
|
each surface could include prelight indexes
|
|
|
|
generation procedure in dmap:
|
|
|
|
carve original surfaces into areas
|
|
|
|
for each light
|
|
build shadow volume and beam tree
|
|
cut all potentially lit surfaces into the beam tree
|
|
move lit fragments into a new optimize group
|
|
|
|
optimize groups
|
|
|
|
build light models
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
/*
|
|
=================================================================================
|
|
|
|
LIGHT TESTING
|
|
|
|
=================================================================================
|
|
*/
|
|
|
|
|
|
/*
|
|
====================
|
|
R_ModulateLights_f
|
|
|
|
Modifies the shaderParms on all the lights so the level
|
|
designers can easily test different color schemes
|
|
====================
|
|
*/
|
|
void R_ModulateLights_f( const idCmdArgs &args ) {
|
|
if ( !tr.primaryWorld ) {
|
|
return;
|
|
}
|
|
if ( args.Argc() != 4 ) {
|
|
common->Printf( "usage: modulateLights <redFloat> <greenFloat> <blueFloat>\n" );
|
|
return;
|
|
}
|
|
|
|
float modulate[3];
|
|
int i;
|
|
for ( i = 0 ; i < 3 ; i++ ) {
|
|
modulate[i] = atof( args.Argv( i+1 ) );
|
|
}
|
|
|
|
int count = 0;
|
|
for ( i = 0 ; i < tr.primaryWorld->lightDefs.Num() ; i++ ) {
|
|
idRenderLightLocal *light;
|
|
|
|
light = tr.primaryWorld->lightDefs[i];
|
|
if ( light ) {
|
|
count++;
|
|
for ( int j = 0 ; j < 3 ; j++ ) {
|
|
light->parms.shaderParms[j] *= modulate[j];
|
|
}
|
|
}
|
|
}
|
|
common->Printf( "modulated %i lights\n", count );
|
|
}
|
|
|
|
|
|
|
|
//======================================================================================
|
|
|
|
|
|
/*
|
|
===============
|
|
R_CreateEntityRefs
|
|
|
|
Creates all needed model references in portal areas,
|
|
chaining them to both the area and the entityDef.
|
|
|
|
Bumps tr.viewCount.
|
|
===============
|
|
*/
|
|
void R_CreateEntityRefs( idRenderEntityLocal *def ) {
|
|
int i;
|
|
idVec3 transformed[8];
|
|
idVec3 v;
|
|
|
|
if ( !def->parms.hModel ) {
|
|
def->parms.hModel = renderModelManager->DefaultModel();
|
|
}
|
|
|
|
// if the entity hasn't been fully specified due to expensive animation calcs
|
|
// for md5 and particles, use the provided conservative bounds.
|
|
if ( def->parms.callback ) {
|
|
def->referenceBounds = def->parms.bounds;
|
|
} else {
|
|
def->referenceBounds = def->parms.hModel->Bounds( &def->parms );
|
|
}
|
|
|
|
// some models, like empty particles, may not need to be added at all
|
|
if ( def->referenceBounds.IsCleared() ) {
|
|
return;
|
|
}
|
|
|
|
if ( r_showUpdates.GetBool() &&
|
|
( def->referenceBounds[1][0] - def->referenceBounds[0][0] > 1024 ||
|
|
def->referenceBounds[1][1] - def->referenceBounds[0][1] > 1024 ) ) {
|
|
common->Printf( "big entityRef: %f,%f\n", def->referenceBounds[1][0] - def->referenceBounds[0][0],
|
|
def->referenceBounds[1][1] - def->referenceBounds[0][1] );
|
|
}
|
|
|
|
for (i = 0 ; i < 8 ; i++) {
|
|
v[0] = def->referenceBounds[i&1][0];
|
|
v[1] = def->referenceBounds[(i>>1)&1][1];
|
|
v[2] = def->referenceBounds[(i>>2)&1][2];
|
|
|
|
R_LocalPointToGlobal( def->modelMatrix, v, transformed[i] );
|
|
}
|
|
|
|
// bump the view count so we can tell if an
|
|
// area already has a reference
|
|
tr.viewCount++;
|
|
|
|
// push these points down the BSP tree into areas
|
|
def->world->PushVolumeIntoTree( def, NULL, 8, transformed );
|
|
}
|
|
|
|
|
|
/*
|
|
=================================================================================
|
|
|
|
CREATE LIGHT REFS
|
|
|
|
=================================================================================
|
|
*/
|
|
|
|
/*
|
|
=====================
|
|
R_SetLightProject
|
|
|
|
All values are reletive to the origin
|
|
Assumes that right and up are not normalized
|
|
This is also called by dmap during map processing.
|
|
=====================
|
|
*/
|
|
void R_SetLightProject( idPlane lightProject[4], const idVec3 origin, const idVec3 target,
|
|
const idVec3 rightVector, const idVec3 upVector, const idVec3 start, const idVec3 stop ) {
|
|
float dist;
|
|
float scale;
|
|
float rLen, uLen;
|
|
idVec3 normal;
|
|
float ofs;
|
|
idVec3 right, up;
|
|
idVec3 startGlobal;
|
|
idVec4 targetGlobal;
|
|
|
|
right = rightVector;
|
|
rLen = right.Normalize();
|
|
up = upVector;
|
|
uLen = up.Normalize();
|
|
normal = up.Cross( right );
|
|
//normal = right.Cross( up );
|
|
normal.Normalize();
|
|
|
|
dist = target * normal; // - ( origin * normal );
|
|
if ( dist < 0 ) {
|
|
dist = -dist;
|
|
normal = -normal;
|
|
}
|
|
|
|
scale = ( 0.5f * dist ) / rLen;
|
|
right *= scale;
|
|
scale = -( 0.5f * dist ) / uLen;
|
|
up *= scale;
|
|
|
|
lightProject[2] = normal;
|
|
lightProject[2][3] = -( origin * lightProject[2].Normal() );
|
|
|
|
lightProject[0] = right;
|
|
lightProject[0][3] = -( origin * lightProject[0].Normal() );
|
|
|
|
lightProject[1] = up;
|
|
lightProject[1][3] = -( origin * lightProject[1].Normal() );
|
|
|
|
// now offset to center
|
|
targetGlobal.ToVec3() = target + origin;
|
|
targetGlobal[3] = 1;
|
|
ofs = 0.5f - ( targetGlobal * lightProject[0].ToVec4() ) / ( targetGlobal * lightProject[2].ToVec4() );
|
|
lightProject[0].ToVec4() += ofs * lightProject[2].ToVec4();
|
|
ofs = 0.5f - ( targetGlobal * lightProject[1].ToVec4() ) / ( targetGlobal * lightProject[2].ToVec4() );
|
|
lightProject[1].ToVec4() += ofs * lightProject[2].ToVec4();
|
|
|
|
// set the falloff vector
|
|
normal = stop - start;
|
|
dist = normal.Normalize();
|
|
if ( dist <= 0 ) {
|
|
dist = 1;
|
|
}
|
|
lightProject[3] = normal * ( 1.0f / dist );
|
|
startGlobal = start + origin;
|
|
lightProject[3][3] = -( startGlobal * lightProject[3].Normal() );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_SetLightFrustum
|
|
|
|
Creates plane equations from the light projection, positive sides
|
|
face out of the light
|
|
===================
|
|
*/
|
|
void R_SetLightFrustum( const idPlane lightProject[4], idPlane frustum[6] ) {
|
|
int i;
|
|
|
|
// we want the planes of s=0, s=q, t=0, and t=q
|
|
frustum[0] = lightProject[0];
|
|
frustum[1] = lightProject[1];
|
|
frustum[2] = lightProject[2] - lightProject[0];
|
|
frustum[3] = lightProject[2] - lightProject[1];
|
|
|
|
// we want the planes of s=0 and s=1 for front and rear clipping planes
|
|
frustum[4] = lightProject[3];
|
|
|
|
frustum[5] = lightProject[3];
|
|
frustum[5][3] -= 1.0f;
|
|
frustum[5] = -frustum[5];
|
|
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
float l;
|
|
|
|
frustum[i] = -frustum[i];
|
|
l = frustum[i].Normalize();
|
|
frustum[i][3] /= l;
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
R_FreeLightDefFrustum
|
|
====================
|
|
*/
|
|
void R_FreeLightDefFrustum( idRenderLightLocal *ldef ) {
|
|
int i;
|
|
|
|
// free the frustum tris
|
|
if ( ldef->frustumTris ) {
|
|
R_FreeStaticTriSurf( ldef->frustumTris );
|
|
ldef->frustumTris = NULL;
|
|
}
|
|
// free frustum windings
|
|
for ( i = 0; i < 6; i++ ) {
|
|
if ( ldef->frustumWindings[i] ) {
|
|
delete ldef->frustumWindings[i];
|
|
ldef->frustumWindings[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_DeriveLightData
|
|
|
|
Fills everything in based on light->parms
|
|
=================
|
|
*/
|
|
void R_DeriveLightData( idRenderLightLocal *light ) {
|
|
int i;
|
|
|
|
// decide which light shader we are going to use
|
|
if ( light->parms.shader ) {
|
|
light->lightShader = light->parms.shader;
|
|
}
|
|
if ( !light->lightShader ) {
|
|
if ( light->parms.pointLight ) {
|
|
light->lightShader = declManager->FindMaterial( "lights/defaultPointLight" );
|
|
} else {
|
|
light->lightShader = declManager->FindMaterial( "lights/defaultProjectedLight" );
|
|
}
|
|
}
|
|
|
|
// get the falloff image
|
|
light->falloffImage = light->lightShader->LightFalloffImage();
|
|
if ( !light->falloffImage ) {
|
|
// use the falloff from the default shader of the correct type
|
|
const idMaterial *defaultShader;
|
|
|
|
if ( light->parms.pointLight ) {
|
|
defaultShader = declManager->FindMaterial( "lights/defaultPointLight" );
|
|
light->falloffImage = defaultShader->LightFalloffImage();
|
|
} else {
|
|
// projected lights by default don't diminish with distance
|
|
defaultShader = declManager->FindMaterial( "lights/defaultProjectedLight" );
|
|
light->falloffImage = defaultShader->LightFalloffImage();
|
|
}
|
|
}
|
|
|
|
// set the projection
|
|
if ( !light->parms.pointLight ) {
|
|
// projected light
|
|
|
|
R_SetLightProject( light->lightProject, vec3_origin /* light->parms.origin */, light->parms.target,
|
|
light->parms.right, light->parms.up, light->parms.start, light->parms.end);
|
|
} else {
|
|
// point light
|
|
memset( light->lightProject, 0, sizeof( light->lightProject ) );
|
|
light->lightProject[0][0] = 0.5f / light->parms.lightRadius[0];
|
|
light->lightProject[1][1] = 0.5f / light->parms.lightRadius[1];
|
|
light->lightProject[3][2] = 0.5f / light->parms.lightRadius[2];
|
|
light->lightProject[0][3] = 0.5f;
|
|
light->lightProject[1][3] = 0.5f;
|
|
light->lightProject[2][3] = 1.0f;
|
|
light->lightProject[3][3] = 0.5f;
|
|
}
|
|
|
|
// set the frustum planes
|
|
R_SetLightFrustum( light->lightProject, light->frustum );
|
|
|
|
// rotate the light planes and projections by the axis
|
|
R_AxisToModelMatrix( light->parms.axis, light->parms.origin, light->modelMatrix );
|
|
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
idPlane temp;
|
|
temp = light->frustum[i];
|
|
R_LocalPlaneToGlobal( light->modelMatrix, temp, light->frustum[i] );
|
|
}
|
|
for ( i = 0 ; i < 4 ; i++ ) {
|
|
idPlane temp;
|
|
temp = light->lightProject[i];
|
|
R_LocalPlaneToGlobal( light->modelMatrix, temp, light->lightProject[i] );
|
|
}
|
|
|
|
// adjust global light origin for off center projections and parallel projections
|
|
// we are just faking parallel by making it a very far off center for now
|
|
if ( light->parms.parallel ) {
|
|
idVec3 dir;
|
|
|
|
dir = light->parms.lightCenter;
|
|
if ( !dir.Normalize() ) {
|
|
// make point straight up if not specified
|
|
dir[2] = 1;
|
|
}
|
|
light->globalLightOrigin = light->parms.origin + dir * 100000;
|
|
} else {
|
|
light->globalLightOrigin = light->parms.origin + light->parms.axis * light->parms.lightCenter;
|
|
}
|
|
|
|
R_FreeLightDefFrustum( light );
|
|
|
|
light->frustumTris = R_PolytopeSurface( 6, light->frustum, light->frustumWindings );
|
|
|
|
// a projected light will have one shadowFrustum, a point light will have
|
|
// six unless the light center is outside the box
|
|
R_MakeShadowFrustums( light );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_CreateLightRefs
|
|
=================
|
|
*/
|
|
#define MAX_LIGHT_VERTS 40
|
|
void R_CreateLightRefs( idRenderLightLocal *light ) {
|
|
idVec3 points[MAX_LIGHT_VERTS];
|
|
int i;
|
|
srfTriangles_t *tri;
|
|
|
|
tri = light->frustumTris;
|
|
|
|
// because a light frustum is made of only six intersecting planes,
|
|
// we should never be able to get a stupid number of points...
|
|
if ( tri->numVerts > MAX_LIGHT_VERTS ) {
|
|
common->Error( "R_CreateLightRefs: %i points in frustumTris!", tri->numVerts );
|
|
}
|
|
for ( i = 0 ; i < tri->numVerts ; i++ ) {
|
|
points[i] = tri->verts[i].xyz;
|
|
}
|
|
|
|
if ( r_showUpdates.GetBool() && ( tri->bounds[1][0] - tri->bounds[0][0] > 1024 ||
|
|
tri->bounds[1][1] - tri->bounds[0][1] > 1024 ) ) {
|
|
common->Printf( "big lightRef: %f,%f\n", tri->bounds[1][0] - tri->bounds[0][0]
|
|
,tri->bounds[1][1] - tri->bounds[0][1] );
|
|
}
|
|
|
|
// determine the areaNum for the light origin, which may let us
|
|
// cull the light if it is behind a closed door
|
|
// it is debatable if we want to use the entity origin or the center offset origin,
|
|
// but we definitely don't want to use a parallel offset origin
|
|
light->areaNum = light->world->PointInArea( light->globalLightOrigin );
|
|
if ( light->areaNum == -1 ) {
|
|
light->areaNum = light->world->PointInArea( light->parms.origin );
|
|
}
|
|
|
|
// bump the view count so we can tell if an
|
|
// area already has a reference
|
|
tr.viewCount++;
|
|
|
|
// if we have a prelight model that includes all the shadows for the major world occluders,
|
|
// we can limit the area references to those visible through the portals from the light center.
|
|
// We can't do this in the normal case, because shadows are cast from back facing triangles, which
|
|
// may be in areas not directly visible to the light projection center.
|
|
if ( light->parms.prelightModel && r_useLightPortalFlow.GetBool() && light->lightShader->LightCastsShadows() ) {
|
|
light->world->FlowLightThroughPortals( light );
|
|
} else {
|
|
// push these points down the BSP tree into areas
|
|
light->world->PushVolumeIntoTree( NULL, light, tri->numVerts, points );
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
R_RenderLightFrustum
|
|
|
|
Called by the editor and dmap to operate on light volumes
|
|
===============
|
|
*/
|
|
void R_RenderLightFrustum( const renderLight_t &renderLight, idPlane lightFrustum[6] ) {
|
|
idRenderLightLocal fakeLight;
|
|
|
|
fakeLight.parms = renderLight;
|
|
|
|
R_DeriveLightData( &fakeLight );
|
|
|
|
R_FreeStaticTriSurf( fakeLight.frustumTris );
|
|
|
|
for ( int i = 0 ; i < 6 ; i++ ) {
|
|
lightFrustum[i] = fakeLight.frustum[i];
|
|
}
|
|
}
|
|
|
|
|
|
//=================================================================================
|
|
|
|
/*
|
|
===============
|
|
WindingCompletelyInsideLight
|
|
===============
|
|
*/
|
|
bool WindingCompletelyInsideLight( const idWinding *w, const idRenderLightLocal *ldef ) {
|
|
int i, j;
|
|
|
|
for ( i = 0 ; i < w->GetNumPoints() ; i++ ) {
|
|
for ( j = 0 ; j < 6 ; j++ ) {
|
|
float d;
|
|
|
|
d = (*w)[i].ToVec3() * ldef->frustum[j].Normal() + ldef->frustum[j][3];
|
|
if ( d > 0 ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_CreateLightDefFogPortals
|
|
|
|
When a fog light is created or moved, see if it completely
|
|
encloses any portals, which may allow them to be fogged closed.
|
|
======================
|
|
*/
|
|
void R_CreateLightDefFogPortals( idRenderLightLocal *ldef ) {
|
|
areaReference_t *lref;
|
|
portalArea_t *area;
|
|
|
|
ldef->foggedPortals = NULL;
|
|
|
|
if ( !ldef->lightShader->IsFogLight() ) {
|
|
return;
|
|
}
|
|
|
|
// some fog lights will explicitly disallow portal fogging
|
|
if ( ldef->lightShader->TestMaterialFlag( MF_NOPORTALFOG ) ) {
|
|
return;
|
|
}
|
|
|
|
for ( lref = ldef->references ; lref ; lref = lref->ownerNext ) {
|
|
// check all the models in this area
|
|
area = lref->area;
|
|
|
|
portal_t *prt;
|
|
doublePortal_t *dp;
|
|
|
|
for ( prt = area->portals ; prt ; prt = prt->next ) {
|
|
dp = prt->doublePortal;
|
|
|
|
// we only handle a single fog volume covering a portal
|
|
// this will never cause incorrect drawing, but it may
|
|
// fail to cull a portal
|
|
if ( dp->fogLight ) {
|
|
continue;
|
|
}
|
|
|
|
if ( WindingCompletelyInsideLight( prt->w, ldef ) ) {
|
|
dp->fogLight = ldef;
|
|
dp->nextFoggedPortal = ldef->foggedPortals;
|
|
ldef->foggedPortals = dp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
R_FreeLightDefDerivedData
|
|
|
|
Frees all references and lit surfaces from the light
|
|
====================
|
|
*/
|
|
void R_FreeLightDefDerivedData( idRenderLightLocal *ldef ) {
|
|
areaReference_t *lref, *nextRef;
|
|
|
|
// rmove any portal fog references
|
|
for ( doublePortal_t *dp = ldef->foggedPortals ; dp ; dp = dp->nextFoggedPortal ) {
|
|
dp->fogLight = NULL;
|
|
}
|
|
|
|
// free all the interactions
|
|
while ( ldef->firstInteraction != NULL ) {
|
|
ldef->firstInteraction->UnlinkAndFree();
|
|
}
|
|
|
|
// free all the references to the light
|
|
for ( lref = ldef->references ; lref ; lref = nextRef ) {
|
|
nextRef = lref->ownerNext;
|
|
|
|
// unlink from the area
|
|
lref->areaNext->areaPrev = lref->areaPrev;
|
|
lref->areaPrev->areaNext = lref->areaNext;
|
|
|
|
// put it back on the free list for reuse
|
|
ldef->world->areaReferenceAllocator.Free( lref );
|
|
}
|
|
ldef->references = NULL;
|
|
|
|
R_FreeLightDefFrustum( ldef );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_FreeEntityDefDerivedData
|
|
|
|
Used by both RE_FreeEntityDef and RE_UpdateEntityDef
|
|
Does not actually free the entityDef.
|
|
===================
|
|
*/
|
|
void R_FreeEntityDefDerivedData( idRenderEntityLocal *def, bool keepDecals, bool keepCachedDynamicModel ) {
|
|
int i;
|
|
areaReference_t *ref, *next;
|
|
|
|
// demo playback needs to free the joints, while normal play
|
|
// leaves them in the control of the game
|
|
if ( session->readDemo ) {
|
|
if ( def->parms.joints ) {
|
|
Mem_Free16( def->parms.joints );
|
|
def->parms.joints = NULL;
|
|
}
|
|
if ( def->parms.callbackData ) {
|
|
Mem_Free( def->parms.callbackData );
|
|
def->parms.callbackData = NULL;
|
|
}
|
|
for ( i = 0; i < MAX_RENDERENTITY_GUI; i++ ) {
|
|
if ( def->parms.gui[ i ] ) {
|
|
delete def->parms.gui[ i ];
|
|
def->parms.gui[ i ] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// free all the interactions
|
|
while ( def->firstInteraction != NULL ) {
|
|
def->firstInteraction->UnlinkAndFree();
|
|
}
|
|
|
|
// clear the dynamic model if present
|
|
if ( def->dynamicModel ) {
|
|
def->dynamicModel = NULL;
|
|
}
|
|
|
|
if ( !keepDecals ) {
|
|
R_FreeEntityDefDecals( def );
|
|
R_FreeEntityDefOverlay( def );
|
|
}
|
|
|
|
if ( !keepCachedDynamicModel ) {
|
|
delete def->cachedDynamicModel;
|
|
def->cachedDynamicModel = NULL;
|
|
}
|
|
|
|
// free the entityRefs from the areas
|
|
for ( ref = def->entityRefs ; ref ; ref = next ) {
|
|
next = ref->ownerNext;
|
|
|
|
// unlink from the area
|
|
ref->areaNext->areaPrev = ref->areaPrev;
|
|
ref->areaPrev->areaNext = ref->areaNext;
|
|
|
|
// put it back on the free list for reuse
|
|
def->world->areaReferenceAllocator.Free( ref );
|
|
}
|
|
def->entityRefs = NULL;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
R_ClearEntityDefDynamicModel
|
|
|
|
If we know the reference bounds stays the same, we
|
|
only need to do this on entity update, not the full
|
|
R_FreeEntityDefDerivedData
|
|
==================
|
|
*/
|
|
void R_ClearEntityDefDynamicModel( idRenderEntityLocal *def ) {
|
|
// free all the interaction surfaces
|
|
for( idInteraction *inter = def->firstInteraction; inter != NULL && !inter->IsEmpty(); inter = inter->entityNext ) {
|
|
inter->FreeSurfaces();
|
|
}
|
|
|
|
// clear the dynamic model if present
|
|
if ( def->dynamicModel ) {
|
|
def->dynamicModel = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_FreeEntityDefDecals
|
|
===================
|
|
*/
|
|
void R_FreeEntityDefDecals( idRenderEntityLocal *def ) {
|
|
while( def->decals ) {
|
|
idRenderModelDecal *next = def->decals->Next();
|
|
idRenderModelDecal::Free( def->decals );
|
|
def->decals = next;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_FreeEntityDefFadedDecals
|
|
===================
|
|
*/
|
|
void R_FreeEntityDefFadedDecals( idRenderEntityLocal *def, int time ) {
|
|
def->decals = idRenderModelDecal::RemoveFadedDecals( def->decals, time );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_FreeEntityDefOverlay
|
|
===================
|
|
*/
|
|
void R_FreeEntityDefOverlay( idRenderEntityLocal *def ) {
|
|
if ( def->overlay ) {
|
|
idRenderModelOverlay::Free( def->overlay );
|
|
def->overlay = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_FreeDerivedData
|
|
|
|
ReloadModels and RegenerateWorld call this
|
|
// FIXME: need to do this for all worlds
|
|
===================
|
|
*/
|
|
void R_FreeDerivedData( void ) {
|
|
int i, j;
|
|
idRenderWorldLocal *rw;
|
|
idRenderEntityLocal *def;
|
|
idRenderLightLocal *light;
|
|
|
|
for ( j = 0; j < tr.worlds.Num(); j++ ) {
|
|
rw = tr.worlds[j];
|
|
|
|
for ( i = 0; i < rw->entityDefs.Num(); i++ ) {
|
|
def = rw->entityDefs[i];
|
|
if ( !def ) {
|
|
continue;
|
|
}
|
|
R_FreeEntityDefDerivedData( def, false, false );
|
|
}
|
|
|
|
for ( i = 0; i < rw->lightDefs.Num(); i++ ) {
|
|
light = rw->lightDefs[i];
|
|
if ( !light ) {
|
|
continue;
|
|
}
|
|
R_FreeLightDefDerivedData( light );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_CheckForEntityDefsUsingModel
|
|
===================
|
|
*/
|
|
void R_CheckForEntityDefsUsingModel( idRenderModel *model ) {
|
|
int i, j;
|
|
idRenderWorldLocal *rw;
|
|
idRenderEntityLocal *def;
|
|
|
|
for ( j = 0; j < tr.worlds.Num(); j++ ) {
|
|
rw = tr.worlds[j];
|
|
|
|
for ( i = 0 ; i < rw->entityDefs.Num(); i++ ) {
|
|
def = rw->entityDefs[i];
|
|
if ( !def ) {
|
|
continue;
|
|
}
|
|
if ( def->parms.hModel == model ) {
|
|
//assert( 0 );
|
|
// this should never happen but Radiant messes it up all the time so just free the derived data
|
|
R_FreeEntityDefDerivedData( def, false, false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_ReCreateWorldReferences
|
|
|
|
ReloadModels and RegenerateWorld call this
|
|
// FIXME: need to do this for all worlds
|
|
===================
|
|
*/
|
|
void R_ReCreateWorldReferences( void ) {
|
|
int i, j;
|
|
idRenderWorldLocal *rw;
|
|
idRenderEntityLocal *def;
|
|
idRenderLightLocal *light;
|
|
|
|
// let the interaction generation code know this shouldn't be optimized for
|
|
// a particular view
|
|
tr.viewDef = NULL;
|
|
|
|
for ( j = 0; j < tr.worlds.Num(); j++ ) {
|
|
rw = tr.worlds[j];
|
|
|
|
for ( i = 0 ; i < rw->entityDefs.Num() ; i++ ) {
|
|
def = rw->entityDefs[i];
|
|
if ( !def ) {
|
|
continue;
|
|
}
|
|
// the world model entities are put specifically in a single
|
|
// area, instead of just pushing their bounds into the tree
|
|
if ( i < rw->numPortalAreas ) {
|
|
rw->AddEntityRefToArea( def, &rw->portalAreas[i] );
|
|
} else {
|
|
R_CreateEntityRefs( def );
|
|
}
|
|
}
|
|
|
|
for ( i = 0 ; i < rw->lightDefs.Num() ; i++ ) {
|
|
light = rw->lightDefs[i];
|
|
if ( !light ) {
|
|
continue;
|
|
}
|
|
renderLight_t parms = light->parms;
|
|
|
|
light->world->FreeLightDef( i );
|
|
rw->UpdateLightDef( i, &parms );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
R_RegenerateWorld_f
|
|
|
|
Frees and regenerates all references and interactions, which
|
|
must be done when switching between display list mode and immediate mode
|
|
===================
|
|
*/
|
|
void R_RegenerateWorld_f( const idCmdArgs &args ) {
|
|
R_FreeDerivedData();
|
|
|
|
// watch how much memory we allocate
|
|
tr.staticAllocCount = 0;
|
|
|
|
R_ReCreateWorldReferences();
|
|
|
|
common->Printf( "Regenerated world, staticAllocCount = %i.\n", tr.staticAllocCount );
|
|
}
|