/*
===============
idClipModel::ClearTraceModelCache
===============
*/
void idClipModel::ClearTraceModelCache()
{
traceModelCache.DeleteContents( true );
traceModelCache_Unsaved.DeleteContents( true );
traceModelHash.Free();
traceModelHash_Unsaved.Free();
}
/*
============
idCVarSystemLocal::FindInternal
============
*/
idInternalCVar *idCVarSystemLocal::FindInternal( const char *name ) const {
int hash = cvarHash.GenerateKey( name, false );
for ( int i = cvarHash.First( hash ); i != -1; i = cvarHash.Next( i ) ) {
if ( cvars[i]->nameString.Icmp( name ) == 0 ) {
return cvars[i];
}
}
return NULL;
}
/*
=================
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 );
}
}
/*
============
idCVarSystemLocal::SetInternal
============
*/
void idCVarSystemLocal::SetInternal( const char *name, const char *value, int flags ) {
int hash;
idInternalCVar *internal;
internal = FindInternal( name );
if ( internal ) {
internal->InternalSetString( value );
internal->flags |= flags & ~CVAR_STATIC;
internal->UpdateCheat();
} else {
internal = new idInternalCVar( name, value, flags );
hash = cvarHash.GenerateKey( internal->nameString.c_str(), false );
cvarHash.Add( hash, cvars.Append( internal ) );
}
}
/*
============
idCVarSystemLocal::Shutdown
============
*/
void idCVarSystemLocal::Shutdown( void )
{
cvars.DeleteContents( true );
cvarHash.Free();
moveCVarsToDict.Clear();
initialized = false;
}
/*
============
idCVarSystemLocal::Register
============
*/
void idCVarSystemLocal::Register( idCVar *cvar ) {
int hash;
idInternalCVar *internal;
cvar->SetInternalVar( cvar );
internal = FindInternal( cvar->GetName() );
if ( internal ) {
internal->Update( cvar );
} else {
internal = new idInternalCVar( cvar );
hash = cvarHash.GenerateKey( internal->nameString.c_str(), false );
cvarHash.Add( hash, cvars.Append( internal ) );
}
cvar->SetInternalVar( internal );
}
/*
===============
idClipModel::AllocTraceModel
===============
*/
int idClipModel::AllocTraceModel( const idTraceModel &trm ) {
int i, hashKey, traceModelIndex;
trmCache_t *entry;
hashKey = GetTraceModelHashKey( trm );
for( i = traceModelHash.First( hashKey ); i >= 0; i = traceModelHash.Next( i ) ) {
if( traceModelCache[i]->trm == trm ) {
traceModelCache[i]->refCount++;
return i;
}
}
entry = new trmCache_t;
entry->trm = trm;
entry->trm.GetMassProperties( 1.0f, entry->volume, entry->centerOfMass, entry->inertiaTensor );
entry->refCount = 1;
traceModelIndex = traceModelCache.Append( entry );
traceModelHash.Add( hashKey, traceModelIndex );
return traceModelIndex;
}
/*
================
sdPersistentRankInfo::FindData
================
*/
float sdPersistentRankInfo::FindData( const char* key, const idHashIndex& hash, const sdNetStatKeyValList& list ) {
int hashkey = hash.GenerateKey( key, false );
for ( int index = hash.GetFirst( hashkey ); index != -1; index = hash.GetNext( index ) ) {
if ( idStr::Icmp( list[ index ].key->c_str(), key ) != 0 ) {
continue;
}
switch ( list[ index ].type ) {
case sdNetStatKeyValue::SVT_INT:
return list[ index ].val.i;
case sdNetStatKeyValue::SVT_FLOAT:
return list[ index ].val.f;
default:
assert( false );
break;
}
}
return 0.f;
}
/*
===============
idClipModel::RestoreTraceModels
===============
*/
void idClipModel::RestoreTraceModels( idRestoreGame *savefile ) {
int i, num;
ClearTraceModelCache();
savefile->ReadInt( num );
traceModelCache.SetNum( num );
for( i = 0; i < num; i++ ) {
trmCache_t *entry = new trmCache_t;
savefile->ReadTraceModel( entry->trm );
savefile->ReadFloat( entry->volume );
savefile->ReadVec3( entry->centerOfMass );
savefile->ReadMat3( entry->inertiaTensor );
entry->refCount = 0;
traceModelCache[i] = entry;
traceModelHash.Add( GetTraceModelHashKey( entry->trm ), i );
}
}
/*
=================
idRenderModelManagerLocal::AddModel
=================
*/
void idRenderModelManagerLocal::AddModel( idRenderModel *model ) {
hash.Add( hash.GenerateKey( model->Name(), false ), models.Append( model ) );
}
/*
=================
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 ) || ( extension.Icmp( "obj" ) == 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::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;
}
/*
===============
idClipModel::AllocTraceModel
===============
*/
int idClipModel::AllocTraceModel( const idTraceModel& trm, bool persistantThroughSaves )
{
int i, hashKey, traceModelIndex;
trmCache_t* entry;
hashKey = GetTraceModelHashKey( trm );
if( persistantThroughSaves )
{
// Look Inside the saved list.
for( i = traceModelHash.First( hashKey ); i >= 0; i = traceModelHash.Next( i ) )
{
if( traceModelCache[i]->trm == trm )
{
traceModelCache[i]->refCount++;
int flagged_index = i | TRACE_MODEL_SAVED;
return flagged_index;
}
}
}
else
{
// Look inside the unsaved list.
for( i = traceModelHash_Unsaved.First( hashKey ); i >= 0; i = traceModelHash_Unsaved.Next( i ) )
{
if( traceModelCache_Unsaved[i]->trm == trm )
{
traceModelCache_Unsaved[i]->refCount++;
return i;
}
}
}
entry = new( TAG_PHYSICS_CLIP ) trmCache_t;
entry->trm = trm;
entry->trm.GetMassProperties( 1.0f, entry->volume, entry->centerOfMass, entry->inertiaTensor );
entry->refCount = 1;
if( persistantThroughSaves )
{
traceModelIndex = traceModelCache.Append( entry );
traceModelHash.Add( hashKey, traceModelIndex );
// Set the saved bit.
traceModelIndex |= TRACE_MODEL_SAVED;
}
else
{
traceModelIndex = traceModelCache_Unsaved.Append( entry );
traceModelHash_Unsaved.Add( hashKey, traceModelIndex );
// remove the saved bit
traceModelIndex &= ~TRACE_MODEL_SAVED;
}
return traceModelIndex;
}
