ModelManager.cpp

Go to the documentation of this file.

/*
===========================================================================

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 "../idlib/precompiled.h"
#pragma hdrstop

#include "Model_local.h"
#include "tr_local.h"   // just for R_FreeWorldInteractions and R_CreateWorldInteractions


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, &current );
                        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 );
}