mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-11-22 12:21:04 +00:00
739 lines
20 KiB
C++
739 lines
20 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition 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 BFG Edition 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 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition 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 BFG Edition 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.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#pragma hdrstop
|
|
#include "../idlib/precompiled.h"
|
|
|
|
#include "Model_local.h"
|
|
#include "tr_local.h" // just for R_FreeWorldInteractions and R_CreateWorldInteractions
|
|
|
|
idCVar r_binaryLoadRenderModels( "r_binaryLoadRenderModels", "1", 0, "enable binary load/write of render models" );
|
|
idCVar preload_MapModels( "preload_MapModels", "1", CVAR_SYSTEM | CVAR_BOOL, "preload models during begin or end levelload" );
|
|
|
|
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 Preload( const idPreloadManifest &manifest );
|
|
|
|
virtual void PrintMemInfo( MemInfo_t *mi );
|
|
|
|
private:
|
|
idList<idRenderModel*, TAG_MODEL> models;
|
|
idHashIndex hash;
|
|
idRenderModel * defaultModel;
|
|
idRenderModel * beamModel;
|
|
idRenderModel * spriteModel;
|
|
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;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
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 );
|
|
const bool captureToImage = false;
|
|
common->UpdateScreen( captureToImage );
|
|
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 (TAG_MODEL) idRenderModelStatic;
|
|
model->InitEmpty( "_DEFAULT" );
|
|
model->MakeDefaultModel();
|
|
model->SetLevelLoadReferenced( true );
|
|
defaultModel = model;
|
|
AddModel( model );
|
|
|
|
// create the beam model
|
|
idRenderModelStatic *beam = new (TAG_MODEL) idRenderModelBeam;
|
|
beam->InitEmpty( "_BEAM" );
|
|
beam->SetLevelLoadReferenced( true );
|
|
beamModel = beam;
|
|
AddModel( beam );
|
|
|
|
idRenderModelStatic *sprite = new (TAG_MODEL) 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 ) {
|
|
|
|
if ( !_modelName || !_modelName[0] ) {
|
|
return NULL;
|
|
}
|
|
|
|
idStrStatic< MAX_OSPATH > canonical = _modelName;
|
|
canonical.ToLower();
|
|
|
|
idStrStatic< MAX_OSPATH > extension;
|
|
canonical.ExtractFileExtension( extension );
|
|
|
|
// see if it is already present
|
|
int key = hash.GenerateKey( canonical, 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
|
|
idStr generatedFileName = "generated/rendermodels/";
|
|
generatedFileName.AppendPath( canonical );
|
|
generatedFileName.SetFileExtension( va( "b%s", extension.c_str() ) );
|
|
if ( model->SupportsBinaryModel() && r_binaryLoadRenderModels.GetBool() ) {
|
|
idFileLocal file( fileSystem->OpenFileReadMemory( generatedFileName ) );
|
|
model->PurgeModel();
|
|
if ( !model->LoadBinaryModel( file, 0 ) ) {
|
|
model->LoadModel();
|
|
}
|
|
} else {
|
|
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 = NULL;
|
|
|
|
if ( ( extension.Icmp( "ase" ) == 0 ) || ( extension.Icmp( "lwo" ) == 0 ) || ( extension.Icmp( "flt" ) == 0 ) || ( extension.Icmp( "ma" ) == 0 ) ) {
|
|
model = new (TAG_MODEL) idRenderModelStatic;
|
|
} else if ( extension.Icmp( MD5_MESH_EXT ) == 0 ) {
|
|
model = new (TAG_MODEL) idRenderModelMD5;
|
|
} else if ( extension.Icmp( "md3" ) == 0 ) {
|
|
model = new (TAG_MODEL) idRenderModelMD3;
|
|
} else if ( extension.Icmp( "prt" ) == 0 ) {
|
|
model = new (TAG_MODEL) idRenderModelPrt;
|
|
} else if ( extension.Icmp( "liquid" ) == 0 ) {
|
|
model = new (TAG_MODEL) idRenderModelLiquid;
|
|
}
|
|
|
|
idStrStatic< MAX_OSPATH > generatedFileName;
|
|
|
|
if ( model != NULL ) {
|
|
|
|
generatedFileName = "generated/rendermodels/";
|
|
generatedFileName.AppendPath( canonical );
|
|
generatedFileName.SetFileExtension( va( "b%s", extension.c_str() ) );
|
|
|
|
// Get the timestamp on the original file, if it's newer than what is stored in binary model, regenerate it
|
|
ID_TIME_T sourceTimeStamp = fileSystem->GetTimestamp( canonical );
|
|
|
|
idFileLocal file( fileSystem->OpenFileReadMemory( generatedFileName ) );
|
|
|
|
if ( !model->SupportsBinaryModel() || !r_binaryLoadRenderModels.GetBool() ) {
|
|
model->InitFromFile( canonical );
|
|
} else {
|
|
if ( !model->LoadBinaryModel( file, sourceTimeStamp ) ) {
|
|
model->InitFromFile( canonical );
|
|
|
|
idFileLocal outputFile( fileSystem->OpenFileWrite( generatedFileName, "fs_basepath" ) );
|
|
idLib::Printf( "Writing %s\n", generatedFileName.c_str() );
|
|
model->WriteBinaryModel( outputFile );
|
|
} /* else {
|
|
idLib::Printf( "loaded binary model %s from file %s\n", model->Name(), generatedFileName.c_str() );
|
|
} */
|
|
}
|
|
}
|
|
|
|
// Not one of the known formats
|
|
if ( model == NULL ) {
|
|
|
|
if ( extension.Length() ) {
|
|
common->Warning( "unknown model type '%s'", canonical.c_str() );
|
|
}
|
|
|
|
if ( !createIfNotFound ) {
|
|
return NULL;
|
|
}
|
|
|
|
idRenderModelStatic *smodel = new (TAG_MODEL) idRenderModelStatic;
|
|
smodel->InitEmpty( canonical );
|
|
smodel->MakeDefaultModel();
|
|
|
|
model = smodel;
|
|
}
|
|
|
|
if ( cvarSystem->GetCVarBool( "fs_buildresources" ) ) {
|
|
fileSystem->AddModelPreload( canonical );
|
|
}
|
|
model->SetLevelLoadReferenced( true );
|
|
|
|
if ( !createIfNotFound && model->IsDefaultModel() ) {
|
|
delete model;
|
|
model = NULL;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if ( cvarSystem->GetCVarBool( "fs_buildgame" ) ) {
|
|
fileSystem->AddModelPreload( model->Name() );
|
|
}
|
|
|
|
AddModel( model );
|
|
|
|
return model;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::AllocModel
|
|
=================
|
|
*/
|
|
idRenderModel *idRenderModelManagerLocal::AllocModel() {
|
|
return new (TAG_MODEL) 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 );
|
|
if ( index != -1 ) {
|
|
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];
|
|
|
|
// always reload all models
|
|
if ( model->IsReloadable() ) {
|
|
R_CheckForEntityDefsUsingModel( model );
|
|
model->PurgeModel();
|
|
}
|
|
|
|
model->SetLevelLoadReferenced( false );
|
|
}
|
|
|
|
vertexCache.FreeStaticData();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idRenderModelManagerLocal::Preload
|
|
=================
|
|
*/
|
|
void idRenderModelManagerLocal::Preload( const idPreloadManifest &manifest ) {
|
|
if ( preload_MapModels.GetBool() ) {
|
|
// preload this levels images
|
|
int start = Sys_Milliseconds();
|
|
int numLoaded = 0;
|
|
idList< preloadSort_t > preloadSort;
|
|
preloadSort.Resize( manifest.NumResources() );
|
|
for ( int i = 0; i < manifest.NumResources(); i++ ) {
|
|
const preloadEntry_s & p = manifest.GetPreloadByIndex( i );
|
|
idResourceCacheEntry rc;
|
|
idStrStatic< MAX_OSPATH > filename;
|
|
if ( p.resType == PRELOAD_MODEL ) {
|
|
filename = "generated/rendermodels/";
|
|
filename += p.resourceName;
|
|
idStrStatic< 16 > ext;
|
|
filename.ExtractFileExtension( ext );
|
|
filename.SetFileExtension( va( "b%s", ext.c_str() ) );
|
|
}
|
|
if ( p.resType == PRELOAD_PARTICLE ) {
|
|
filename = "generated/particles/";
|
|
filename += p.resourceName;
|
|
filename += ".bprt";
|
|
}
|
|
if ( !filename.IsEmpty() ) {
|
|
if ( fileSystem->GetResourceCacheEntry( filename, rc ) ) {
|
|
preloadSort_t ps = {};
|
|
ps.idx = i;
|
|
ps.ofs = rc.offset;
|
|
preloadSort.Append( ps );
|
|
}
|
|
}
|
|
}
|
|
|
|
preloadSort.SortWithTemplate( idSort_Preload() );
|
|
|
|
for ( int i = 0; i < preloadSort.Num(); i++ ) {
|
|
const preloadSort_t & ps = preloadSort[ i ];
|
|
const preloadEntry_s & p = manifest.GetPreloadByIndex( ps.idx );
|
|
if ( p.resType == PRELOAD_MODEL ) {
|
|
idRenderModel * model = FindModel( p.resourceName );
|
|
if ( model != NULL ) {
|
|
model->SetLevelLoadReferenced( true );
|
|
}
|
|
} else if ( p.resType == PRELOAD_PARTICLE ) {
|
|
declManager->FindType( DECL_PARTICLE, p.resourceName );
|
|
}
|
|
numLoaded++;
|
|
}
|
|
|
|
int end = Sys_Milliseconds();
|
|
common->Printf( "%05d models preloaded ( or were already loaded ) in %5.1f seconds\n", numLoaded, ( end - start ) * 0.001 );
|
|
common->Printf( "----------------------------------------\n" );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
=================
|
|
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++;
|
|
}
|
|
|
|
common->UpdateLevelLoadPacifier();
|
|
}
|
|
|
|
// load any new ones
|
|
for ( int i = 0; i < models.Num(); i++ ) {
|
|
common->UpdateLevelLoadPacifier();
|
|
|
|
|
|
idRenderModel *model = models[i];
|
|
|
|
if ( model->IsLevelLoadReferenced() && !model->IsLoaded() && model->IsReloadable() ) {
|
|
loadCount++;
|
|
model->LoadModel();
|
|
}
|
|
}
|
|
|
|
// create static vertex/index buffers for all models
|
|
for ( int i = 0; i < models.Num(); i++ ) {
|
|
common->UpdateLevelLoadPacifier();
|
|
|
|
|
|
idRenderModel *model = models[i];
|
|
if ( model->IsLoaded() ) {
|
|
for ( int j = 0; j < model->NumSurfaces(); j++ ) {
|
|
R_CreateStaticBuffersForTri( *(model->Surface( j )->geometry) );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// _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 (TAG_MODEL) 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 );
|
|
}
|