// this now auto-loads LOD models for MD3s...
//
bool loadmdl( char *filename )
{
gl_model* pModel_LOD1 = NULL;
gl_model* pModel_LOD2 = NULL;
// new stuff, if it's an MD3, try loading in LOD versions of it as well, but do them first, so that
// all the goofy shit to do with tagmenu stuff is still left in valid state...
//
LPCSTR psMD3EXT = strstr(String_ToLower(filename),".md3");
if (psMD3EXT)
{
char sNewFilename[MAX_PATH];
strcpy(sNewFilename,Filename_WithoutExt(filename));
strcat(sNewFilename,"_1.md3");
if (loadmdl_original(sNewFilename, filename, NULL, NULL))
pModel_LOD1 = pLastLoadedModel;
strcpy(sNewFilename,Filename_WithoutExt(filename));
strcat(sNewFilename,"_2.md3");
if (loadmdl_original(sNewFilename, filename, NULL, NULL))
pModel_LOD2 = pLastLoadedModel;
}
// finally, load the model we were originally asking for...
//
return loadmdl_original(filename, NULL, pModel_LOD1, pModel_LOD2);
}
void CStringEdPackage::SetupNewFileParse( const char *psFileName, SE_BOOL bLoadDebug )
{
char sString[ iSE_MAX_FILENAME_LENGTH ];
strcpy(sString, Filename_WithoutPath( Filename_WithoutExt( psFileName ) ));
Q_strupr(sString);
m_strCurrentFileRef_ParseOnly = sString; // eg "OBJECTIVES"
m_strLoadingLanguage_ParseOnly = ExtractLanguageFromPath( psFileName );
m_bLoadingEnglish_ParseOnly = (!Q_stricmp( m_strLoadingLanguage_ParseOnly.c_str(), "english" )) ? SE_TRUE : SE_FALSE;
m_bLoadDebug = bLoadDebug;
}
void CMainFrame::OnModelSaveAs()
{
LPCSTR psFullPathedFilename = InputSaveFileName(va("%s",Filename_WithoutExt(Model_GetFullPrimaryFilename())),
"Save Model", // LPCSTR psCaption,
Filename_PathOnly(Model_GetFullPrimaryFilename()), // "S:\\baseq3\\models\\test\\bonehier", // LPCSTR psInitialDir,
Model_GetSupportedTypesFilter(true), // LPCSTR psFilter
".glm"
);
if (psFullPathedFilename)
{
Model_Save(psFullPathedFilename);
}
}
bool Anims_ReadFile_FRAMES(ModelContainer_t *pContainer, LPCSTR psLocalFilename_GLA)
{
LPCSTR psFilename = va("%s%s.frames",gamedir,Filename_WithoutExt(psLocalFilename_GLA));
FILE *fHandle = fopen(psFilename,"rt");
if (fHandle)
{
// file format is like this per XSI...
//
// models/test/m4/m44keith.xsi
// {
// startframe "0"
// duration "2"
// }
//
// so...
Sequence_t Sequence;
bool bStartFrameRead = false;
bool bDurationRead = false;
bool bFPSRead = false;
char sLine[1024];
while (fgets(sLine,sizeof(sLine)-1,fHandle)!=NULL)
{
if (bStartFrameRead && bDurationRead && bFPSRead)
{
pContainer->SequenceList.push_back(Sequence);
bStartFrameRead = false;
bDurationRead = false;
bFPSRead = false;
}
sLine[sizeof(sLine)-1]='\0';
strlwr(sLine);
// :-)
CString str(sLine);
str.TrimLeft();
str.TrimRight();
str.Replace("\"","");
strcpy(sLine,str);
if (strstr(sLine,".xsi"))
{
Sequence_Clear(&Sequence);
strcpy(Sequence.sName,Filename_WithoutPath(Filename_WithoutExt(sLine)));
// these can be really long...
strncpy(Sequence.sNameWithPath,Filename_WithoutExt(sLine),sizeof(Sequence.sNameWithPath));
Sequence.sNameWithPath[sizeof(Sequence.sNameWithPath)-1]='\0';
}
else
if (strnicmp(sLine,"startframe",strlen("startframe"))==0)
{
CString str(&sLine[strlen("startframe")]);
str.Replace("\"","");
Sequence.iStartFrame = atoi(str);
bStartFrameRead = true;
}
else
if (strnicmp(sLine,"duration",strlen("duration"))==0)
{
CString str(&sLine[strlen("duration")]);
str.Replace("\"","");
Sequence.iFrameCount = atoi(str);
bDurationRead = true;
}
else
if (strnicmp(sLine,"fps",strlen("fps"))==0)
{
CString str(&sLine[strlen("fps")]);
str.Replace("\"","");
Sequence.iFPS = atoi(str);
bFPSRead = true;
}
}
fclose(fHandle);
}
/*
else
{
ErrorBox( va("Couldn't open file: %s\n", psFilename));
return false;
}
*/
return !!(pContainer->SequenceList.size());
}
void R_CheckMP3s( const char *psDir )
{
// Com_Printf(va("Scanning Dir: %s\n",psDir));
Com_Printf("."); // stops useful info scrolling off screen
char **sysFiles, **dirFiles;
int numSysFiles, i, numdirs;
dirFiles = FS_ListFiles( psDir, "/", &numdirs);
if (numdirs > 2)
{
for (i=2;i<numdirs;i++)
{
char sDirName[MAX_QPATH];
sprintf(sDirName, "%s\\%s", psDir, dirFiles[i]);
R_CheckMP3s(sDirName);
}
}
sysFiles = FS_ListFiles( psDir, ".mp3", &numSysFiles );
for(i=0; i<numSysFiles; i++)
{
char sFilename[MAX_QPATH];
sprintf(sFilename,"%s\\%s", psDir, sysFiles[i]);
Com_Printf("%sFound file: %s",!i?"\n":"",sFilename);
iFilesFound++;
// read it in...
//
byte *pbData = NULL;
int iSize = FS_ReadFile( sFilename, (void **)&pbData);
if (pbData)
{
id3v1_1* pTAG;
// do NOT check 'qbForceRescan' here as an opt, because we need to actually fill in 'pTAG' if there is one...
//
qboolean qbTagNeedsUpdating = (/* qbForceRescan || */ !MP3_ReadSpecialTagInfo(pbData, iSize, &pTAG))?qtrue:qfalse;
if (pTAG == NULL || qbTagNeedsUpdating || qbForceRescan)
{
Com_Printf(" ( Updating )\n");
// I need to scan this file to get the volume...
//
// For EF1 I used a temp sfx_t struct, but I can't do that now with this new alloc scheme,
// I have to ask for it legally, so I'll keep re-using one, and restoring it's name after use.
// (slightly dodgy, but works ok if no-one else changes stuff)
//
//sfx_t SFX = {0};
extern sfx_t *S_FindName( const char *name );
//
static sfx_t *pSFX = NULL;
const char sReservedSFXEntrynameForMP3[] = "reserved_for_mp3"; // ( strlen() < MAX_QPATH )
if (pSFX == NULL) // once only
{
pSFX = S_FindName(sReservedSFXEntrynameForMP3); // always returns, else ERR_FATAL
}
if (MP3_IsValid(sFilename,pbData, iSize, qbForceStereo))
{
wavinfo_t info;
int iRawPCMDataSize = MP3_GetUnpackedSize(sFilename, pbData, iSize, qtrue, qbForceStereo);
if (iRawPCMDataSize) // should always be true, unless file is f****d, in which case, stop this conversion process
{
float fMaxVol = 128; // any old default
int iActualUnpackedSize = iRawPCMDataSize; // default, override later if not doing music
if (!qbForceStereo) // no point for stereo files, which are for music and therefore no lip-sync
{
byte *pbUnpackBuffer = (byte *) Z_Malloc ( iRawPCMDataSize+10, TAG_TEMP_WORKSPACE ); // won't return if fails
iActualUnpackedSize = MP3_UnpackRawPCM( sFilename, pbData, iSize, pbUnpackBuffer );
if (iActualUnpackedSize != iRawPCMDataSize)
{
Com_Error(ERR_DROP, "******* Whoah! MP3 %s unpacked to %d bytes, but size calc said %d!\n",sFilename,iActualUnpackedSize,iRawPCMDataSize);
}
// fake up a WAV structure so I can use the other post-load sound code such as volume calc for lip-synching
//
MP3_FakeUpWAVInfo( sFilename, pbData, iSize, iActualUnpackedSize,
// these params are all references...
info.format, info.rate, info.width, info.channels, info.samples, info.dataofs
);
extern void S_LoadSound_Finalize(wavinfo_t *info, sfx_t *sfx, byte *data);
S_LoadSound_Finalize(&info, pSFX, pbUnpackBuffer); // all this just for lipsynch. Oh well.
fMaxVol = pSFX->fVolRange;
// free sfx->data...
//
{
// Hunk_FreeTempMemory( SFX.data ); // this will have been allocated inside S_LoadSound_Finalise()
//
// I want a big thankyou from the Mac guys for providing this define... :-) -ste
//
// #ifndef INT_MIN
// #define INT_MIN (-2147483647 - 1) /* minimum (signed) int value */
// #endif
//
pSFX->iLastTimeUsed = INT_MIN; // force this to be oldest sound file, therefore disposable...
pSFX->bInMemory = qtrue;
SND_FreeOldestSound(); // ... and do the disposal
// now set our temp SFX struct back to default name so nothing else accidentally uses it...
//
strcpy(pSFX->sSoundName, sReservedSFXEntrynameForMP3);
pSFX->bDefaultSound = qfalse;
}
// other stuff...
//
Z_Free(pbUnpackBuffer);
}
// well, time to update the file now...
//
fileHandle_t f = FS_FOpenFileWrite( sFilename );
if (f)
{
// write the file back out, but omitting the tag if there was one...
//
int iWritten = FS_Write(pbData, iSize-(pTAG?sizeof(*pTAG):0), f);
if (iWritten)
{
// make up a new tag if we didn't find one in the original file...
//
id3v1_1 TAG;
if (!pTAG)
{
pTAG = &TAG;
memset(&TAG,0,sizeof(TAG));
strncpy(pTAG->id,"TAG",3);
}
strncpy(pTAG->title, Filename_WithoutPath(Filename_WithoutExt(sFilename)), sizeof(pTAG->title));
strncpy(pTAG->artist, "Raven Software", sizeof(pTAG->artist) );
strncpy(pTAG->year, "2001", sizeof(pTAG->year) );
strncpy(pTAG->comment, va("%s %g",sKEY_MAXVOL,fMaxVol), sizeof(pTAG->comment) );
strncpy(pTAG->album, va("%s %d",sKEY_UNCOMP,iActualUnpackedSize),sizeof(pTAG->album) );
if (FS_Write( pTAG, sizeof(*pTAG), f )) // NZ = success
{
iFilesUpdated++;
}
else
{
Com_Printf("*********** Failed write to file!\n");
iErrors++;
}
}
else
{
Com_Printf("*********** Failed write to file!\n");
iErrors++;
}
FS_FCloseFile( f );
}
else
{
Com_Printf("*********** Failed to re-open for write!\n");
iErrors++;
}
}
else
{
Com_Error(ERR_DROP, "******* This MP3 should be deleted: %s\n",sFilename);
}
}
else
{
Com_Printf("*********** File was not a valid MP3!\n");
iErrors++;
}
}
else
{
Com_Printf(" ( OK )\n");
}
FS_FreeFile( pbData );
}
}
FS_FreeFileList( sysFiles );
FS_FreeFileList( dirFiles );
}
char *ExportGhoul2FromMD3(LPCSTR psFullPathedFilename, int iNumLODs, int iNumSurfaces, int iNumTags
// ,LPCSTR *ppsFullPathedNameGLA /* = NULL */
)
{
char *psErrorMess = NULL;
giNumLODs = iNumLODs;
giNumSurfaces = iNumSurfaces;
giNumTags = iNumTags;
CreatePath(psFullPathedFilename); // this has already been done earlier in q3data, but wtf?
// new, we need to work out if this file is to be an output, or a LOD append (ie are we "<modelname>_1.glm") ?
//
bool bAppending = false;
char sTemp[2048];
strcpy(sTemp, Filename_WithoutExt( psFullPathedFilename ));
char *psSuffixPos = &sTemp[strlen(sTemp)-2];
if (psSuffixPos[0] == '_' && isdigit(psSuffixPos[1]))
{
bAppending = true;
// since we're appending, we first of all need to get the data from the file already out there...
//
*psSuffixPos='\0'; // chop off trailing "_1" etc
strcat(sTemp, ".glm");
psErrorMess = ExportGhoul2FromMD3_ImportExisting( sTemp );
if (psErrorMess)
return psErrorMess; // which will cause an app-exit
}
FILE *fhGLM = fopen(bAppending?sTemp:psFullPathedFilename,"wb");
if ( fhGLM)
{
static char sNameGLA[MAX_QPATH];
// strcpy(sNameGLA, Filename_WithoutExt(psFullPathedFilename) );
// strcat(sNameGLA, ".gla");
strcpy(sNameGLA, sDEFAULT_GLA_NAME );
// CreatePath(sNameGLA);
// FILE *fhGLA = fopen(sNameGLA,"wb");
// if ( fhGLA)
{
// if ( ppsFullPathedNameGLA)
// {
// *ppsFullPathedNameGLA = &sNameGLA[0];
// }
psErrorMess = ExportGhoul2FromMD3_Main(fhGLM, /*fhGLA,*/ psFullPathedFilename);
// fclose(fhGLA);
}
// else
// {
// psErrorMess = va("Error: Unable to open file '%s'!\n");
// }
fclose(fhGLM);
}
else
{
psErrorMess = va("Error: Unable to open file '%s'!\n");
}
if (bAppending && !psErrorMess)
{
printf("\n( Appended LOD to \"%s\" )\n\n",sTemp);
}
return psErrorMess;
}
// returns true if at least one set of skin data was read, else false...
//
static bool Skins_Read(LPCSTR psModelFilename)
{
LPCSTR psError = NULL;
CWaitCursor;
LPCSTR psSkinsPath = Skins_ModelNameToSkinPath(psModelFilename); // eg "models/characters/skins"
if (psSkinsPath)
{
string strThisModelBaseName(String_ToLower(Filename_WithoutExt(Filename_WithoutPath(psModelFilename))));
char **ppsSkinFiles;
int iSkinFiles;
// scan for skin files...
//
ppsSkinFiles = //ri.FS_ListFiles( "shaders", ".shader", &iSkinFiles );
Sys_ListFiles( va("%s%s",gamedir,psSkinsPath),// const char *directory,
".g2skin", // const char *extension,
NULL, // char *filter,
&iSkinFiles,// int *numfiles,
qfalse // qboolean wantsubs
);
if ( !ppsSkinFiles || !iSkinFiles )
{
CurrentSkins.clear();
CurrentSkinsSurfacePrefs.clear();
return false;
}
if ( iSkinFiles > MAX_SKIN_FILES )
{
WarningBox(va("%d skin files found, capping to %d\n\n(tell me if this ever happens -Ste)", iSkinFiles, MAX_SKIN_FILES ));
iSkinFiles = MAX_SKIN_FILES;
}
// load and parse skin files...
//
// for now, I just scan each file and if it's out of date then I invalidate it's model-prefs info...
//
extern bool GetFileTime(LPCSTR psFileName, FILETIME &ft);
for (int i=0; i<iSkinFiles; i++)
{
bool bReParseThisFile = false;
char sFileName[MAX_QPATH];
LPCSTR psFileName = ppsSkinFiles[i];
Com_sprintf( sFileName, sizeof( sFileName ), "%s/%s", psSkinsPath, psFileName );
psFileName = &sFileName[0];
// have a go at getting this time/date stamp if not already present...
//
if (!SkinFileTimeDates[psFileName].bValid)
{
FILETIME ft;
if (GetFileTime(psFileName, ft))
{
SkinFileTimeDates[psFileName].ft = ft;
SkinFileTimeDates[psFileName].bValid = true;
}
}
// now see if there's a valid time-stamp, and use it if so, else give up and re-scan all files...
//
if (SkinFileTimeDates[psFileName].bValid)
{
FILETIME ft;
if (GetFileTime(psFileName, ft))
{
LONG l = CompareFileTime( &SkinFileTimeDates[psFileName].ft, &ft);
bReParseThisFile = (l<0);
}
else
{
bReParseThisFile = true;
}
}
else
{
bReParseThisFile = true;
}
if (bReParseThisFile)
{
G2SkinModelPrefs[sFileName].clear();
}
}
if (1)//bReParseSkinFiles || !CurrentSkins.size())
{
CurrentSkins.clear();
CurrentSkinsSurfacePrefs.clear();
char *buffers[MAX_SKIN_FILES]={0};
// long iTotalBytesLoaded = 0;
for ( int i=0; i<iSkinFiles && !psError; i++ )
{
char sFileName[MAX_QPATH];
string strThisSkinFile(ppsSkinFiles[i]);
Com_sprintf( sFileName, sizeof( sFileName ), "%s/%s", psSkinsPath, strThisSkinFile.c_str() );
StatusMessage( va("Scanning skin %d/%d: \"%s\"...",i+1,iSkinFiles,sFileName));
//ri.Printf( PRINT_ALL, "...loading '%s'\n", sFileName );
bool _bDiskLoadOccured = false; // debug use only, but wtf?
#define LOAD_SKIN_FILE \
/*iTotalBytesLoaded += */ ri.FS_ReadFile( sFileName, (void **)&buffers[i] ); \
if ( !buffers[i] ) \
{ \
CurrentSkins.clear(); \
CurrentSkinsSurfacePrefs.clear(); \
\
ri.Error( ERR_DROP, "Couldn't load %s", sFileName );\
} \
_bDiskLoadOccured = true;
// see if we should pay attention to the contents of this file...
//
CGPGroup *pFileGroup = NULL;
CGPGroup *pParseGroup_Prefs = NULL;
CGenericParser2 SkinParser;
//
bool bParseThisFile = false;
//
// if we have any information about this skin file as regards what models it refers to, use the info...
//
if (G2SkinModelPrefs[sFileName].size())
{
map<string, int>::iterator it = G2SkinModelPrefs[sFileName].find( strThisModelBaseName );
if (it != G2SkinModelPrefs[sFileName].end())
{
// this skin file contains this entry, so just check that we can setup the parse groups ok...
//
LOAD_SKIN_FILE;
char *psDataPtr = buffers[i];
if (SkinParser.Parse(&psDataPtr, true))
{
pFileGroup = SkinParser.GetBaseParseGroup();
if (pFileGroup)
{
pParseGroup_Prefs = pFileGroup->FindSubGroup(sSKINKEYWORD_PREFS);//, true);
if (pParseGroup_Prefs)
{
bParseThisFile = true;
}
}
}
else
{
ErrorBox(va("{} - Brace mismatch error in file \"%s\"!",sFileName));
}
}
}
else
{
// no size info for this file, so check it manually...
//
LOAD_SKIN_FILE;
if (Skins_ParseThisFile(SkinParser, buffers[i], strThisModelBaseName, pFileGroup, pParseGroup_Prefs,
sFileName, G2SkinModelPrefs)
)
{
bParseThisFile = true;
}
}
if (bParseThisFile)
{
psError = Skins_Parse( strThisSkinFile, pFileGroup, pParseGroup_Prefs);
if (psError)
{
ErrorBox(va("Skins_Read(): Error reading file \"%s\"!\n\n( Skins will be ignored for this model )\n\nError was:\n\n",sFileName,psError));
}
}
else
{
//OutputDebugString(va("Skipping parse of file \"%s\" %s\n",sFileName, _bDiskLoadOccured?"":"( and no load! )"));
}
}
//
// free loaded skin files...
//
for ( i=0; i<iSkinFiles; i++ )
{
if (buffers[i])
{
ri.FS_FreeFile( buffers[i] );
}
}
}
StatusMessage(NULL);
Sys_FreeFileList( ppsSkinFiles );
}
else
{
CurrentSkins.clear();
CurrentSkinsSurfacePrefs.clear();
}
if (psError)
{
return false;
}
return !!(CurrentSkins.size());
}
/*
====================
RE_RegisterModel
Loads in a model for the given name
Zero will be returned if the model fails to load.
An entry will be retained for failed models as an
optimization to prevent disk rescanning if they are
asked for again.
====================
*/
static qhandle_t RE_RegisterModel_Actual( const char *name )
{
model_t *mod;
unsigned *buf;
int lod;
int ident;
qboolean loaded;
// qhandle_t hModel;
int numLoaded;
/*
Ghoul2 Insert Start
*/
int hash;
modelHash_t *mh;
/*
Ghoul2 Insert End
*/
if ( !name || !name[0] ) {
ri.Printf( PRINT_WARNING, "RE_RegisterModel: NULL name\n" );
return 0;
}
if ( strlen( name ) >= MAX_QPATH ) {
ri.Printf( PRINT_DEVELOPER, "Model name exceeds MAX_QPATH\n" );
return 0;
}
/*
Ghoul2 Insert Start
*/
// if (!tr.registered) {
// ri.Printf( PRINT_WARNING, "RE_RegisterModel (%s) called before ready!\n",name );
// return 0;
// }
//
// search the currently loaded models
//
hash = generateHashValue(name, FILE_HASH_SIZE);
//
// see if the model is already loaded
//
for (mh=mhHashTable[hash]; mh; mh=mh->next) {
if (Q_stricmp(mh->name, name) == 0) {
if (tr.models[mh->handle]->type == MOD_BAD)
{
return 0;
}
return mh->handle;
}
}
// for ( hModel = 1 ; hModel < tr.numModels; hModel++ ) {
// mod = tr.models[hModel];
// if ( !strcmp( mod->name, name ) ) {
// if( mod->type == MOD_BAD ) {
// return 0;
// }
// return hModel;
// }
// }
/*
Ghoul2 Insert End
*/
// allocate a new model_t
if ( ( mod = R_AllocModel() ) == NULL ) {
ri.Printf( PRINT_WARNING, "RE_RegisterModel: R_AllocModel() failed for '%s'\n", name);
return 0;
}
// only set the name after the model has been successfully loaded
Q_strncpyz( mod->name, name, sizeof( mod->name ) );
#ifdef _NPATCH
// Make sure we don't n-patch unless explicitly specified
/*
mod->npatchable = qfalse;
for ( int i = 0; npatchableModels[i]; i++ )
{
if ( stricmp(name, npatchableModels[i]) == 0 )
{
mod->npatchable = qtrue;
break;
}
}
*/
// new version, npatching is no controlled by the existance of a "*.npatch" file in the same place as *.glm
extern cvar_t *r_ATI_NPATCH_available;
if (r_ATI_NPATCH_available && r_ATI_NPATCH_available->integer && strstr(name,".glm"))
{
extern char *Filename_WithoutExt(const char *psFilename);
fileHandle_t f;
FS_FOpenFileRead( va("%s.npatch",Filename_WithoutExt(name)),&f, qtrue ); // qtrue = dup handle, so I can close it ok later
mod->npatchable = !!f;
if (f)
{
FS_FCloseFile(f);
}
}
#endif // _NPATCH
// make sure the render thread is stopped
R_SyncRenderThread();
int iLODStart = 0;
if (strstr (name, ".md3")) {
iLODStart = MD3_MAX_LODS-1; //this loads the md3s in reverse so they can be biased
}
mod->numLods = 0;
//
// load the files
//
numLoaded = 0;
for ( lod = iLODStart; lod >= 0 ; lod-- ) {
char filename[1024];
strcpy( filename, name );
if ( lod != 0 ) {
char namebuf[80];
if ( strrchr( filename, '.' ) ) {
*strrchr( filename, '.' ) = 0;
}
sprintf( namebuf, "_%d.md3", lod );
strcat( filename, namebuf );
}
qboolean bAlreadyCached = qfalse;
if (!RE_RegisterModels_GetDiskFile(filename, (void **)&buf, &bAlreadyCached))
{
continue;
}
//loadmodel = mod; // this seems to be fairly pointless
// important that from now on we pass 'filename' instead of 'name' to all model load functions,
// because 'filename' accounts for any LOD mangling etc so guarantees unique lookups for yet more
// internal caching...
//
ident = *(unsigned *)buf;
if (!bAlreadyCached)
{
ident = LittleLong(ident);
}
switch (ident)
{
// if you add any new types of model load in this switch-case, tell me,
// or copy what I've done with the cache scheme (-ste).
//
case MD4_IDENT:
loaded = R_LoadMD4( mod, buf, filename, bAlreadyCached );
break;
case MDXA_IDENT:
loaded = R_LoadMDXA( mod, buf, filename, bAlreadyCached );
break;
case MDXM_IDENT:
loaded = R_LoadMDXM( mod, buf, filename, bAlreadyCached );
break;
case MD3_IDENT:
loaded = R_LoadMD3( mod, lod, buf, filename, bAlreadyCached );
break;
default:
ri.Printf (PRINT_WARNING,"RE_RegisterModel: unknown fileid for %s\n", filename);
goto fail;
}
if (!bAlreadyCached){ // important to check!!
ri.FS_FreeFile (buf);
}
if ( !loaded ) {
if ( lod == 0 ) {
goto fail;
} else {
break;
}
} else {
mod->numLods++;
numLoaded++;
// if we have a valid model and are biased
// so that we won't see any higher detail ones,
// stop loading them
if ( lod <= r_lodbias->integer ) {
break;
}
}
}
if ( numLoaded ) {
// duplicate into higher lod spots that weren't
// loaded, in case the user changes r_lodbias on the fly
for ( lod-- ; lod >= 0 ; lod-- ) {
mod->numLods++;
mod->md3[lod] = mod->md3[lod+1];
}
/*
Ghoul2 Insert Start
*/
RE_InsertModelIntoHash(name, mod);
return mod->index;
/*
Ghoul2 Insert End
*/
}
fail:
// we still keep the model_t around, so if the model name is asked for
// again, we won't bother scanning the filesystem
mod->type = MOD_BAD;
RE_InsertModelIntoHash(name, mod);
return 0;
}