mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-27 14:42:23 +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.
624 lines
16 KiB
C++
624 lines
16 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/CVarSystem.h"
|
|
#include "framework/Session.h"
|
|
#include "renderer/RenderWorld.h"
|
|
#include "renderer/Model_local.h"
|
|
#include "renderer/tr_local.h" // just for R_FreeWorldInteractions and R_CreateWorldInteractions
|
|
|
|
#include "renderer/ModelManager.h"
|
|
|
|
class idRenderModelManagerLocal : public idRenderModelManager {
|
|
public:
|
|
idRenderModelManagerLocal();
|
|
virtual ~idRenderModelManagerLocal() {}
|
|
|
|
virtual void Init();
|
|
virtual void Shutdown();
|
|
virtual idRenderModel * AllocModel();
|
|
virtual void FreeModel( idRenderModel *model );
|
|
virtual idRenderModel * FindModel( const char *modelName );
|
|
virtual idRenderModel * CheckModel( const char *modelName );
|
|
virtual idRenderModel * DefaultModel();
|
|
virtual void AddModel( idRenderModel *model );
|
|
virtual void RemoveModel( idRenderModel *model );
|
|
virtual void ReloadModels( bool forceAll = false );
|
|
virtual void FreeModelVertexCaches();
|
|
virtual void WritePrecacheCommands( idFile *file );
|
|
virtual void BeginLevelLoad();
|
|
virtual void EndLevelLoad();
|
|
|
|
virtual void PrintMemInfo( MemInfo_t *mi );
|
|
|
|
private:
|
|
idList<idRenderModel*> models;
|
|
idHashIndex hash;
|
|
idRenderModel * defaultModel;
|
|
idRenderModel * beamModel;
|
|
idRenderModel * spriteModel;
|
|
idRenderModel * trailModel;
|
|
bool insideLevelLoad; // don't actually load now
|
|
|
|
idRenderModel * GetModel( const char *modelName, bool createIfNotFound );
|
|
|
|
static void PrintModel_f( const idCmdArgs &args );
|
|
static void ListModels_f( const idCmdArgs &args );
|
|
static void ReloadModels_f( const idCmdArgs &args );
|
|
static void TouchModel_f( const idCmdArgs &args );
|
|
};
|
|
|
|
|
|
idRenderModelManagerLocal localModelManager;
|
|
idRenderModelManager * renderModelManager = &localModelManager;
|
|
|
|
/*
|
|
==============
|
|
idRenderModelManagerLocal::idRenderModelManagerLocal
|
|
==============
|
|
*/
|
|
idRenderModelManagerLocal::idRenderModelManagerLocal() {
|
|
defaultModel = NULL;
|
|
beamModel = NULL;
|
|
spriteModel = NULL;
|
|
insideLevelLoad = false;
|
|
trailModel = NULL;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
idRenderModelManagerLocal::PrintModel_f
|
|
==============
|
|
*/
|
|
void idRenderModelManagerLocal::PrintModel_f( const idCmdArgs &args ) {
|
|
idRenderModel *model;
|
|
|
|
if ( args.Argc() != 2 ) {
|
|
common->Printf( "usage: printModel <modelName>\n" );
|
|
return;
|
|
}
|
|
|
|
model = renderModelManager->CheckModel( args.Argv( 1 ) );
|
|
if ( !model ) {
|
|
common->Printf( "model \"%s\" not found\n", args.Argv( 1 ) );
|
|
return;
|
|
}
|
|
|
|
model->Print();
|
|
}
|
|
|
|
/*
|
|
==============
|
|
idRenderModelManagerLocal::ListModels_f
|
|
==============
|
|
*/
|
|
void idRenderModelManagerLocal::ListModels_f( const idCmdArgs &args ) {
|
|
int totalMem = 0;
|
|
int inUse = 0;
|
|
|
|
common->Printf( " mem srf verts tris\n" );
|
|
common->Printf( " --- --- ----- ----\n" );
|
|
|
|
for ( int i = 0 ; i < localModelManager.models.Num() ; i++ ) {
|
|
idRenderModel *model = localModelManager.models[i];
|
|
|
|
if ( !model->IsLoaded() ) {
|
|
continue;
|
|
}
|
|
model->List();
|
|
totalMem += model->Memory();
|
|
inUse++;
|
|
}
|
|
|
|
common->Printf( " --- --- ----- ----\n" );
|
|
common->Printf( " mem srf verts tris\n" );
|
|
|
|
common->Printf( "%i loaded models\n", inUse );
|
|
common->Printf( "total memory: %4.1fM\n", (float)totalMem / (1024*1024) );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
idRenderModelManagerLocal::ReloadModels_f
|
|
==============
|
|
*/
|
|
void idRenderModelManagerLocal::ReloadModels_f( const idCmdArgs &args ) {
|
|
if ( idStr::Icmp( args.Argv(1), "all" ) == 0 ) {
|
|
localModelManager.ReloadModels( true );
|
|
} else {
|
|
localModelManager.ReloadModels( false );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==============
|
|
idRenderModelManagerLocal::TouchModel_f
|
|
|
|
Precache a specific model
|
|
==============
|
|
*/
|
|
void idRenderModelManagerLocal::TouchModel_f( const idCmdArgs &args ) {
|
|
const char *model = args.Argv( 1 );
|
|
|
|
if ( !model[0] ) {
|
|
common->Printf( "usage: touchModel <modelName>\n" );
|
|
return;
|
|
}
|
|
|
|
common->Printf( "touchModel %s\n", model );
|
|
session->UpdateScreen();
|
|
idRenderModel *m = renderModelManager->CheckModel( model );
|
|
if ( !m ) {
|
|
common->Printf( "...not found\n" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::WritePrecacheCommands
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::WritePrecacheCommands( idFile *f ) {
|
|
for ( int i = 0 ; i < models.Num() ; i++ ) {
|
|
idRenderModel *model = models[i];
|
|
|
|
if ( !model ) {
|
|
continue;
|
|
}
|
|
if ( !model->IsReloadable() ) {
|
|
continue;
|
|
}
|
|
|
|
char str[1024];
|
|
sprintf( str, "touchModel %s\n", model->Name() );
|
|
common->Printf( "%s", str );
|
|
f->Printf( "%s", str );
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::Init
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::Init() {
|
|
cmdSystem->AddCommand( "listModels", ListModels_f, CMD_FL_RENDERER, "lists all models" );
|
|
cmdSystem->AddCommand( "printModel", PrintModel_f, CMD_FL_RENDERER, "prints model info", idCmdSystem::ArgCompletion_ModelName );
|
|
cmdSystem->AddCommand( "reloadModels", ReloadModels_f, CMD_FL_RENDERER|CMD_FL_CHEAT, "reloads models" );
|
|
cmdSystem->AddCommand( "touchModel", TouchModel_f, CMD_FL_RENDERER, "touches a model", idCmdSystem::ArgCompletion_ModelName );
|
|
|
|
insideLevelLoad = false;
|
|
|
|
// create a default model
|
|
idRenderModelStatic *model = new idRenderModelStatic;
|
|
model->InitEmpty( "_DEFAULT" );
|
|
model->MakeDefaultModel();
|
|
model->SetLevelLoadReferenced( true );
|
|
defaultModel = model;
|
|
AddModel( model );
|
|
|
|
// create the beam model
|
|
idRenderModelStatic *beam = new idRenderModelBeam;
|
|
beam->InitEmpty( "_BEAM" );
|
|
beam->SetLevelLoadReferenced( true );
|
|
beamModel = beam;
|
|
AddModel( beam );
|
|
|
|
idRenderModelStatic *sprite = new idRenderModelSprite;
|
|
sprite->InitEmpty( "_SPRITE" );
|
|
sprite->SetLevelLoadReferenced( true );
|
|
spriteModel = sprite;
|
|
AddModel( sprite );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::Shutdown
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::Shutdown() {
|
|
models.DeleteContents( true );
|
|
hash.Free();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::GetModel
|
|
=================
|
|
*/
|
|
idRenderModel *idRenderModelManagerLocal::GetModel( const char *modelName, bool createIfNotFound ) {
|
|
idStr canonical;
|
|
idStr extension;
|
|
|
|
if ( !modelName || !modelName[0] ) {
|
|
return NULL;
|
|
}
|
|
|
|
canonical = modelName;
|
|
canonical.ToLower();
|
|
|
|
// see if it is already present
|
|
int key = hash.GenerateKey( modelName, false );
|
|
for ( int i = hash.First( key ); i != -1; i = hash.Next( i ) ) {
|
|
idRenderModel *model = models[i];
|
|
|
|
if ( canonical.Icmp( model->Name() ) == 0 ) {
|
|
if ( !model->IsLoaded() ) {
|
|
// reload it if it was purged
|
|
model->LoadModel();
|
|
} else if ( insideLevelLoad && !model->IsLevelLoadReferenced() ) {
|
|
// we are reusing a model already in memory, but
|
|
// touch all the materials to make sure they stay
|
|
// in memory as well
|
|
model->TouchData();
|
|
}
|
|
model->SetLevelLoadReferenced( true );
|
|
return model;
|
|
}
|
|
}
|
|
|
|
// see if we can load it
|
|
|
|
// determine which subclass of idRenderModel to initialize
|
|
|
|
idRenderModel *model;
|
|
|
|
canonical.ExtractFileExtension( extension );
|
|
|
|
if ( ( extension.Icmp( "ase" ) == 0 ) || ( extension.Icmp( "lwo" ) == 0 ) || ( extension.Icmp( "flt" ) == 0 ) ) {
|
|
model = new idRenderModelStatic;
|
|
model->InitFromFile( modelName );
|
|
} else if ( extension.Icmp( "ma" ) == 0 ) {
|
|
model = new idRenderModelStatic;
|
|
model->InitFromFile( modelName );
|
|
} else if ( extension.Icmp( MD5_MESH_EXT ) == 0 ) {
|
|
model = new idRenderModelMD5;
|
|
model->InitFromFile( modelName );
|
|
} else if ( extension.Icmp( "md3" ) == 0 ) {
|
|
model = new idRenderModelMD3;
|
|
model->InitFromFile( modelName );
|
|
} else if ( extension.Icmp( "prt" ) == 0 ) {
|
|
model = new idRenderModelPrt;
|
|
model->InitFromFile( modelName );
|
|
} else if ( extension.Icmp( "liquid" ) == 0 ) {
|
|
model = new idRenderModelLiquid;
|
|
model->InitFromFile( modelName );
|
|
} else {
|
|
|
|
if ( extension.Length() ) {
|
|
common->Warning( "unknown model type '%s'", canonical.c_str() );
|
|
}
|
|
|
|
if ( !createIfNotFound ) {
|
|
return NULL;
|
|
}
|
|
|
|
idRenderModelStatic *smodel = new idRenderModelStatic;
|
|
smodel->InitEmpty( modelName );
|
|
smodel->MakeDefaultModel();
|
|
|
|
model = smodel;
|
|
}
|
|
|
|
model->SetLevelLoadReferenced( true );
|
|
|
|
if ( !createIfNotFound && model->IsDefaultModel() ) {
|
|
delete model;
|
|
model = NULL;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
AddModel( model );
|
|
|
|
return model;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::AllocModel
|
|
=================
|
|
*/
|
|
idRenderModel *idRenderModelManagerLocal::AllocModel() {
|
|
return new idRenderModelStatic();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::FreeModel
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::FreeModel( idRenderModel *model ) {
|
|
if ( !model ) {
|
|
return;
|
|
}
|
|
if ( !dynamic_cast<idRenderModelStatic *>( model ) ) {
|
|
common->Error( "idRenderModelManager::FreeModel: model '%s' is not a static model", model->Name() );
|
|
return;
|
|
}
|
|
if ( model == defaultModel ) {
|
|
common->Error( "idRenderModelManager::FreeModel: can't free the default model" );
|
|
return;
|
|
}
|
|
if ( model == beamModel ) {
|
|
common->Error( "idRenderModelManager::FreeModel: can't free the beam model" );
|
|
return;
|
|
}
|
|
if ( model == spriteModel ) {
|
|
common->Error( "idRenderModelManager::FreeModel: can't free the sprite model" );
|
|
return;
|
|
}
|
|
|
|
R_CheckForEntityDefsUsingModel( model );
|
|
|
|
delete model;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::FindModel
|
|
=================
|
|
*/
|
|
idRenderModel *idRenderModelManagerLocal::FindModel( const char *modelName ) {
|
|
return GetModel( modelName, true );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::CheckModel
|
|
=================
|
|
*/
|
|
idRenderModel *idRenderModelManagerLocal::CheckModel( const char *modelName ) {
|
|
return GetModel( modelName, false );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::DefaultModel
|
|
=================
|
|
*/
|
|
idRenderModel *idRenderModelManagerLocal::DefaultModel() {
|
|
return defaultModel;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::AddModel
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::AddModel( idRenderModel *model ) {
|
|
hash.Add( hash.GenerateKey( model->Name(), false ), models.Append( model ) );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::RemoveModel
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::RemoveModel( idRenderModel *model ) {
|
|
int index = models.FindIndex( model );
|
|
hash.RemoveIndex( hash.GenerateKey( model->Name(), false ), index );
|
|
models.RemoveIndex( index );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::ReloadModels
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::ReloadModels( bool forceAll ) {
|
|
if ( forceAll ) {
|
|
common->Printf( "Reloading all model files...\n" );
|
|
} else {
|
|
common->Printf( "Checking for changed model files...\n" );
|
|
}
|
|
|
|
R_FreeDerivedData();
|
|
|
|
// skip the default model at index 0
|
|
for ( int i = 1 ; i < models.Num() ; i++ ) {
|
|
idRenderModel *model = models[i];
|
|
|
|
// we may want to allow world model reloading in the future, but we don't now
|
|
if ( !model->IsReloadable() ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !forceAll ) {
|
|
// check timestamp
|
|
ID_TIME_T current;
|
|
|
|
fileSystem->ReadFile( model->Name(), NULL, ¤t );
|
|
if ( current <= model->Timestamp() ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
common->DPrintf( "reloading %s.\n", model->Name() );
|
|
|
|
model->LoadModel();
|
|
}
|
|
|
|
// we must force the world to regenerate, because models may
|
|
// have changed size, making their references invalid
|
|
R_ReCreateWorldReferences();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::FreeModelVertexCaches
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::FreeModelVertexCaches() {
|
|
for ( int i = 0 ; i < models.Num() ; i++ ) {
|
|
idRenderModel *model = models[i];
|
|
model->FreeVertexCache();
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::BeginLevelLoad
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::BeginLevelLoad() {
|
|
insideLevelLoad = true;
|
|
|
|
for ( int i = 0 ; i < models.Num() ; i++ ) {
|
|
idRenderModel *model = models[i];
|
|
|
|
if ( com_purgeAll.GetBool() && model->IsReloadable() ) {
|
|
R_CheckForEntityDefsUsingModel( model );
|
|
model->PurgeModel();
|
|
}
|
|
|
|
model->SetLevelLoadReferenced( false );
|
|
}
|
|
|
|
// purge unused triangle surface memory
|
|
R_PurgeTriSurfData( frameData );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::EndLevelLoad
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::EndLevelLoad() {
|
|
common->Printf( "----- idRenderModelManagerLocal::EndLevelLoad -----\n" );
|
|
|
|
int start = Sys_Milliseconds();
|
|
|
|
insideLevelLoad = false;
|
|
int purgeCount = 0;
|
|
int keepCount = 0;
|
|
int loadCount = 0;
|
|
|
|
// purge any models not touched
|
|
for ( int i = 0 ; i < models.Num() ; i++ ) {
|
|
idRenderModel *model = models[i];
|
|
|
|
if ( !model->IsLevelLoadReferenced() && model->IsLoaded() && model->IsReloadable() ) {
|
|
|
|
// common->Printf( "purging %s\n", model->Name() );
|
|
|
|
purgeCount++;
|
|
|
|
R_CheckForEntityDefsUsingModel( model );
|
|
|
|
model->PurgeModel();
|
|
|
|
} else {
|
|
|
|
// common->Printf( "keeping %s\n", model->Name() );
|
|
|
|
keepCount++;
|
|
}
|
|
}
|
|
|
|
// purge unused triangle surface memory
|
|
R_PurgeTriSurfData( frameData );
|
|
|
|
// load any new ones
|
|
for ( int i = 0 ; i < models.Num() ; i++ ) {
|
|
idRenderModel *model = models[i];
|
|
|
|
if ( model->IsLevelLoadReferenced() && !model->IsLoaded() && model->IsReloadable() ) {
|
|
|
|
loadCount++;
|
|
model->LoadModel();
|
|
|
|
if ( ( loadCount & 15 ) == 0 ) {
|
|
session->PacifierUpdate();
|
|
}
|
|
}
|
|
}
|
|
|
|
// _D3XP added this
|
|
int end = Sys_Milliseconds();
|
|
common->Printf( "%5i models purged from previous level, ", purgeCount );
|
|
common->Printf( "%5i models kept.\n", keepCount );
|
|
if ( loadCount ) {
|
|
common->Printf( "%5i new models loaded in %5.1f seconds\n", loadCount, (end-start) * 0.001 );
|
|
}
|
|
common->Printf( "---------------------------------------------------\n" );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::PrintMemInfo
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::PrintMemInfo( MemInfo_t *mi ) {
|
|
int i, j, totalMem = 0;
|
|
int *sortIndex;
|
|
idFile *f;
|
|
|
|
f = fileSystem->OpenFileWrite( mi->filebase + "_models.txt" );
|
|
if ( !f ) {
|
|
return;
|
|
}
|
|
|
|
// sort first
|
|
sortIndex = new int[ localModelManager.models.Num()];
|
|
|
|
for ( i = 0; i < localModelManager.models.Num(); i++ ) {
|
|
sortIndex[i] = i;
|
|
}
|
|
|
|
for ( i = 0; i < localModelManager.models.Num() - 1; i++ ) {
|
|
for ( j = i + 1; j < localModelManager.models.Num(); j++ ) {
|
|
if ( localModelManager.models[sortIndex[i]]->Memory() < localModelManager.models[sortIndex[j]]->Memory() ) {
|
|
int temp = sortIndex[i];
|
|
sortIndex[i] = sortIndex[j];
|
|
sortIndex[j] = temp;
|
|
}
|
|
}
|
|
}
|
|
|
|
// print next
|
|
for ( int i = 0 ; i < localModelManager.models.Num() ; i++ ) {
|
|
idRenderModel *model = localModelManager.models[sortIndex[i]];
|
|
int mem;
|
|
|
|
if ( !model->IsLoaded() ) {
|
|
continue;
|
|
}
|
|
|
|
mem = model->Memory();
|
|
totalMem += mem;
|
|
f->Printf( "%s %s\n", idStr::FormatNumber( mem ).c_str(), model->Name() );
|
|
}
|
|
|
|
delete sortIndex;
|
|
mi->modelAssetsTotal = totalMem;
|
|
|
|
f->Printf( "\nTotal model bytes allocated: %s\n", idStr::FormatNumber( totalMem ).c_str() );
|
|
fileSystem->CloseFile( f );
|
|
}
|