//========= Copyright Valve Corporation, All rights reserved. ============// // // The copyright to the contents herein is the property of Valve, L.L.C. // The contents may be used and/or copied only with the written permission of // Valve, L.L.C., or in accordance with the terms and conditions stipulated in // the agreement/contract under which the contents have been supplied. // // model loading and caching // //===========================================================================// #include #include "tier0/vprof.h" #include "tier0/icommandline.h" #include "tier1/utllinkedlist.h" #include "tier1/utlmap.h" #include "datacache/imdlcache.h" #include "istudiorender.h" #include "filesystem.h" #include "optimize.h" #include "materialsystem/imaterialsystemhardwareconfig.h" #include "materialsystem/imesh.h" #include "datacache/idatacache.h" #include "studio.h" #include "vcollide.h" #include "utldict.h" #include "convar.h" #include "datacache_common.h" #include "mempool.h" #include "vphysics_interface.h" #include "phyfile.h" #include "studiobyteswap.h" #include "tier2/fileutils.h" #include "filesystem/IQueuedLoader.h" #include "tier1/lzmaDecoder.h" #include "functors.h" // XXX remove this later. (henryg) #if 0 && defined(_DEBUG) && defined(_WIN32) && !defined(_X360) typedef struct LARGE_INTEGER { unsigned long long QuadPart; } LARGE_INTEGER; extern "C" void __stdcall OutputDebugStringA( const char *lpOutputString ); extern "C" long __stdcall QueryPerformanceCounter( LARGE_INTEGER *lpPerformanceCount ); extern "C" long __stdcall QueryPerformanceFrequency( LARGE_INTEGER *lpPerformanceCount ); namespace { class CDebugMicroTimer { public: CDebugMicroTimer(const char* n) : name(n) { QueryPerformanceCounter(&start); } ~CDebugMicroTimer() { LARGE_INTEGER end; char outbuf[128]; QueryPerformanceCounter(&end); if (!freq) QueryPerformanceFrequency((LARGE_INTEGER*)&freq); V_snprintf(outbuf, 128, "%s %6d us\n", name, (int)((end.QuadPart - start.QuadPart) * 1000000 / freq)); OutputDebugStringA(outbuf); } LARGE_INTEGER start; const char* name; static long long freq; }; long long CDebugMicroTimer::freq = 0; } #define DEBUG_SCOPE_TIMER(name) CDebugMicroTimer dbgLocalTimer(#name) #else #define DEBUG_SCOPE_TIMER(name) (void)0 #endif #ifdef _RETAIL #define NO_LOG_MDLCACHE 1 #endif #ifdef NO_LOG_MDLCACHE #define LogMdlCache() 0 #else #define LogMdlCache() mod_trace_load.GetBool() #endif #define MdlCacheMsg if ( !LogMdlCache() ) ; else Msg #define MdlCacheWarning if ( !LogMdlCache() ) ; else Warning #if defined( _X360 ) #define AsyncMdlCache() 0 // Explicitly OFF for 360 (incompatible) #else #define AsyncMdlCache() 0 #endif #define ERROR_MODEL "models/error.mdl" #define IDSTUDIOHEADER (('T'<<24)+('S'<<16)+('D'<<8)+'I') #define MakeCacheID( handle, type ) ( ( (uint)(handle) << 16 ) | (uint)(type) ) #define HandleFromCacheID( id) ( (MDLHandle_t)((id) >> 16) ) #define TypeFromCacheID( id ) ( (MDLCacheDataType_t)((id) & 0xffff) ) enum { STUDIODATA_FLAGS_STUDIOMESH_LOADED = 0x0001, STUDIODATA_FLAGS_VCOLLISION_LOADED = 0x0002, STUDIODATA_ERROR_MODEL = 0x0004, STUDIODATA_FLAGS_NO_STUDIOMESH = 0x0008, STUDIODATA_FLAGS_NO_VERTEX_DATA = 0x0010, STUDIODATA_FLAGS_VCOLLISION_SHARED = 0x0020, STUDIODATA_FLAGS_LOCKED_MDL = 0x0040, }; // only models with type "mod_studio" have this data struct studiodata_t { // The .mdl file DataCacheHandle_t m_MDLCache; // the vphysics.dll collision model vcollide_t m_VCollisionData; studiohwdata_t m_HardwareData; #if defined( USE_HARDWARE_CACHE ) DataCacheHandle_t m_HardwareDataCache; #endif unsigned short m_nFlags; short m_nRefCount; // pointer to the virtual version of the model virtualmodel_t *m_pVirtualModel; // array of cache handles to demand loaded virtual model data int m_nAnimBlockCount; DataCacheHandle_t *m_pAnimBlock; unsigned int *m_iFakeAnimBlockStall; // vertex data is usually compressed to save memory (model decal code only needs some data) DataCacheHandle_t m_VertexCache; bool m_VertexDataIsCompressed; int m_nAutoplaySequenceCount; unsigned short *m_pAutoplaySequenceList; void *m_pUserData; DECLARE_FIXEDSIZE_ALLOCATOR_MT( studiodata_t ); }; DEFINE_FIXEDSIZE_ALLOCATOR_MT( studiodata_t, 128, CUtlMemoryPool::GROW_SLOW ); // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" class CTempAllocHelper { public: CTempAllocHelper() { m_pData = NULL; } ~CTempAllocHelper() { Free(); } void *Get() { return m_pData; } void Alloc( int nSize ) { m_pData = malloc( nSize ); } void Free() { if ( m_pData ) { free( m_pData ); m_pData = NULL; } } private: void *m_pData; }; //----------------------------------------------------------------------------- // ConVars //----------------------------------------------------------------------------- static ConVar r_rootlod( "r_rootlod", "0", FCVAR_ARCHIVE ); static ConVar mod_forcedata( "mod_forcedata", ( AsyncMdlCache() ) ? "0" : "1", 0, "Forces all model file data into cache on model load." ); static ConVar mod_test_not_available( "mod_test_not_available", "0", FCVAR_CHEAT ); static ConVar mod_test_mesh_not_available( "mod_test_mesh_not_available", "0", FCVAR_CHEAT ); static ConVar mod_test_verts_not_available( "mod_test_verts_not_available", "0", FCVAR_CHEAT ); static ConVar mod_load_mesh_async( "mod_load_mesh_async", ( AsyncMdlCache() ) ? "1" : "0" ); static ConVar mod_load_anims_async( "mod_load_anims_async", ( IsX360() || AsyncMdlCache() ) ? "1" : "0" ); static ConVar mod_load_vcollide_async( "mod_load_vcollide_async", ( AsyncMdlCache() ) ? "1" : "0" ); static ConVar mod_trace_load( "mod_trace_load", "0" ); static ConVar mod_lock_mdls_on_load( "mod_lock_mdls_on_load", ( IsX360() ) ? "1" : "0" ); static ConVar mod_load_fakestall( "mod_load_fakestall", "0", 0, "Forces all ANI file loading to stall for specified ms\n"); //----------------------------------------------------------------------------- // Utility functions //----------------------------------------------------------------------------- #if defined( USE_HARDWARE_CACHE ) unsigned ComputeHardwareDataSize( studiohwdata_t *pData ) { unsigned size = 0; for ( int i = pData->m_RootLOD; i < pData->m_NumLODs; i++ ) { studioloddata_t *pLOD = &pData->m_pLODs[i]; for ( int j = 0; j < pData->m_NumStudioMeshes; j++ ) { studiomeshdata_t *pMeshData = &pLOD->m_pMeshData[j]; for ( int k = 0; k < pMeshData->m_NumGroup; k++ ) { size += pMeshData->m_pMeshGroup[k].m_pMesh->ComputeMemoryUsed(); } } } return size; } #endif //----------------------------------------------------------------------------- // Async support //----------------------------------------------------------------------------- #define MDLCACHE_NONE ((MDLCacheDataType_t)-1) struct AsyncInfo_t { AsyncInfo_t() : hControl( NULL ), hModel( MDLHANDLE_INVALID ), type( MDLCACHE_NONE ), iAnimBlock( 0 ) {} FSAsyncControl_t hControl; MDLHandle_t hModel; MDLCacheDataType_t type; int iAnimBlock; }; const intp NO_ASYNC = CUtlFixedLinkedList< AsyncInfo_t >::InvalidIndex(); //------------------------------------- CUtlMap g_AsyncInfoMap( DefLessFunc( int ) ); CThreadFastMutex g_AsyncInfoMapMutex; inline int MakeAsyncInfoKey( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock ) { Assert( type <= 7 && iAnimBlock < 8*1024 ); return ( ( ( (int)hModel) << 16 ) | ( (int)type << 13 ) | iAnimBlock ); } inline intp GetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock = 0 ) { AUTO_LOCK( g_AsyncInfoMapMutex ); int key = MakeAsyncInfoKey( hModel, type, iAnimBlock ); int i = g_AsyncInfoMap.Find( key ); if ( i == g_AsyncInfoMap.InvalidIndex() ) { return NO_ASYNC; } return g_AsyncInfoMap[i]; } inline intp SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock, intp index ) { AUTO_LOCK( g_AsyncInfoMapMutex ); Assert( index == NO_ASYNC || GetAsyncInfoIndex( hModel, type, iAnimBlock ) == NO_ASYNC ); int key = MakeAsyncInfoKey( hModel, type, iAnimBlock ); if ( index == NO_ASYNC ) { g_AsyncInfoMap.Remove( key ); } else { g_AsyncInfoMap.Insert( key, index ); } return index; } inline intp SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, intp index ) { return SetAsyncInfoIndex( hModel, type, 0, index ); } //----------------------------------------------------------------------------- // QUEUED LOADING // Populates the cache by pushing expected MDL's (and all of their data). // The Model cache i/o behavior is unchanged during gameplay, ideally the cache // should yield miss free behaviour. //----------------------------------------------------------------------------- struct ModelParts_t { enum BufferType_t { BUFFER_MDL = 0, BUFFER_VTX = 1, BUFFER_VVD = 2, BUFFER_PHY = 3, BUFFER_MAXPARTS, }; ModelParts_t() { nLoadedParts = 0; nExpectedParts = 0; hMDL = MDLHANDLE_INVALID; hFileCache = 0; bHeaderLoaded = false; bMaterialsPending = false; bTexturesPending = false; } // thread safe, only one thread will get a positive result bool DoFinalProcessing() { // indicates that all buffers have arrived // when all parts are present, returns true ( guaranteed once ), and marked as completed return nLoadedParts.AssignIf( nExpectedParts, nExpectedParts | 0x80000000 ); } CUtlBuffer Buffers[BUFFER_MAXPARTS]; MDLHandle_t hMDL; // async material loading on PC FileCacheHandle_t hFileCache; bool bHeaderLoaded; bool bMaterialsPending; bool bTexturesPending; CUtlVector< IMaterial* > Materials; // bit flags CInterlockedInt nLoadedParts; int nExpectedParts; private: ModelParts_t(const ModelParts_t&); // no impl ModelParts_t& operator=(const ModelParts_t&); // no impl }; struct CleanupModelParts_t { FileCacheHandle_t hFileCache; CUtlVector< IMaterial* > Materials; }; //----------------------------------------------------------------------------- // Implementation of the simple studio data cache (no caching) //----------------------------------------------------------------------------- class CMDLCache : public CTier3AppSystem< IMDLCache >, public IStudioDataCache, public CDefaultDataCacheClient { typedef CTier3AppSystem< IMDLCache > BaseClass; public: CMDLCache(); // Inherited from IAppSystem virtual bool Connect( CreateInterfaceFn factory ); virtual void Disconnect(); virtual void *QueryInterface( const char *pInterfaceName ); virtual InitReturnVal_t Init(); virtual void Shutdown(); // Inherited from IStudioDataCache bool VerifyHeaders( studiohdr_t *pStudioHdr ); vertexFileHeader_t *CacheVertexData( studiohdr_t *pStudioHdr ); // Inherited from IMDLCache virtual MDLHandle_t FindMDL( const char *pMDLRelativePath ); virtual int AddRef( MDLHandle_t handle ); virtual int Release( MDLHandle_t handle ); virtual int GetRef( MDLHandle_t handle ); virtual void MarkAsLoaded(MDLHandle_t handle); virtual studiohdr_t *GetStudioHdr( MDLHandle_t handle ); virtual studiohwdata_t *GetHardwareData( MDLHandle_t handle ); virtual vcollide_t *GetVCollide( MDLHandle_t handle ) { return GetVCollideEx( handle, true); } virtual vcollide_t *GetVCollideEx( MDLHandle_t handle, bool synchronousLoad = true ); virtual unsigned char *GetAnimBlock( MDLHandle_t handle, int nBlock ); virtual virtualmodel_t *GetVirtualModel( MDLHandle_t handle ); virtual virtualmodel_t *GetVirtualModelFast( const studiohdr_t *pStudioHdr, MDLHandle_t handle ); virtual int GetAutoplayList( MDLHandle_t handle, unsigned short **pOut ); virtual void TouchAllData( MDLHandle_t handle ); virtual void SetUserData( MDLHandle_t handle, void* pData ); virtual void *GetUserData( MDLHandle_t handle ); virtual bool IsErrorModel( MDLHandle_t handle ); virtual void SetCacheNotify( IMDLCacheNotify *pNotify ); virtual vertexFileHeader_t *GetVertexData( MDLHandle_t handle ); virtual void Flush( MDLCacheFlush_t nFlushFlags = MDLCACHE_FLUSH_ALL ); virtual void Flush( MDLHandle_t handle, int nFlushFlags = MDLCACHE_FLUSH_ALL ); virtual const char *GetModelName( MDLHandle_t handle ); IDataCacheSection *GetCacheSection( MDLCacheDataType_t type ) { switch ( type ) { case MDLCACHE_STUDIOHWDATA: case MDLCACHE_VERTEXES: // meshes and vertexes are isolated to their own section return m_pMeshCacheSection; case MDLCACHE_ANIMBLOCK: // anim blocks have their own section return m_pAnimBlockCacheSection; default: // everybody else return m_pModelCacheSection; } } void *AllocData( MDLCacheDataType_t type, int size ); void FreeData( MDLCacheDataType_t type, void *pData ); void CacheData( DataCacheHandle_t *c, void *pData, int size, const char *name, MDLCacheDataType_t type, DataCacheClientID_t id = (DataCacheClientID_t)-1 ); void *CheckData( DataCacheHandle_t c, MDLCacheDataType_t type ); void *CheckDataNoTouch( DataCacheHandle_t c, MDLCacheDataType_t type ); void UncacheData( DataCacheHandle_t c, MDLCacheDataType_t type, bool bLockedOk = false ); void DisableAsync() { mod_load_mesh_async.SetValue( 0 ); mod_load_anims_async.SetValue( 0 ); } virtual void BeginLock(); virtual void EndLock(); virtual int *GetFrameUnlockCounterPtrOLD(); virtual int *GetFrameUnlockCounterPtr( MDLCacheDataType_t type ); virtual void FinishPendingLoads(); // Task switch void ReleaseMaterialSystemObjects(); void RestoreMaterialSystemObjects( int nChangeFlags ); virtual bool GetVCollideSize( MDLHandle_t handle, int *pVCollideSize ); virtual void BeginMapLoad(); virtual void EndMapLoad(); virtual void InitPreloadData( bool rebuild ); virtual void ShutdownPreloadData(); virtual bool IsDataLoaded( MDLHandle_t handle, MDLCacheDataType_t type ); virtual studiohdr_t *LockStudioHdr( MDLHandle_t handle ); virtual void UnlockStudioHdr( MDLHandle_t handle ); virtual bool PreloadModel( MDLHandle_t handle ); virtual void ResetErrorModelStatus( MDLHandle_t handle ); virtual void MarkFrame(); // Queued loading void ProcessQueuedData( ModelParts_t *pModelParts, bool bHeaderOnly = false ); static void QueuedLoaderCallback_MDL( void *pContext, void *pContext2, const void *pData, int nSize, LoaderError_t loaderError ); static void ProcessDynamicLoad( ModelParts_t *pModelParts ); static void CleanupDynamicLoad( CleanupModelParts_t *pCleanup ); private: // Inits, shuts downs studiodata_t void InitStudioData( MDLHandle_t handle ); void ShutdownStudioData( MDLHandle_t handle ); // Returns the *actual* name of the model (could be an error model if the requested model didn't load) const char *GetActualModelName( MDLHandle_t handle ); // Constructs a filename based on a model handle void MakeFilename( MDLHandle_t handle, const char *pszExtension, char *pszFileName, int nMaxLength ); // Inform filesystem that we unloaded a particular file void NotifyFileUnloaded( MDLHandle_t handle, const char *pszExtension ); // Attempts to load a MDL file, validates that it's ok. bool ReadMDLFile( MDLHandle_t handle, const char *pMDLFileName, CUtlBuffer &buf ); // Unserializes the VCollide file associated w/ models (the vphysics representation) void UnserializeVCollide( MDLHandle_t handle, bool synchronousLoad ); // Destroys the VCollide associated w/ models void DestroyVCollide( MDLHandle_t handle ); // Unserializes the MDL studiohdr_t *UnserializeMDL( MDLHandle_t handle, void *pData, int nDataSize, bool bDataValid ); // Unserializes an animation block from disk unsigned char *UnserializeAnimBlock( MDLHandle_t handle, int nBlock ); // Allocates/frees the anim blocks void AllocateAnimBlocks( studiodata_t *pStudioData, int nCount ); void FreeAnimBlocks( MDLHandle_t handle ); // Allocates/frees the virtual model void AllocateVirtualModel( MDLHandle_t handle ); void FreeVirtualModel( MDLHandle_t handle ); // Purpose: Pulls all submodels/.ani file models into the cache void UnserializeAllVirtualModelsAndAnimBlocks( MDLHandle_t handle ); // Loads/unloads the static meshes bool LoadHardwareData( MDLHandle_t handle ); // returns false if not ready void UnloadHardwareData( MDLHandle_t handle, bool bCacheRemove = true, bool bLockedOk = false ); // Allocates/frees autoplay sequence list void AllocateAutoplaySequences( studiodata_t *pStudioData, int nCount ); void FreeAutoplaySequences( studiodata_t *pStudioData ); FSAsyncStatus_t LoadData( const char *pszFilename, const char *pszPathID, bool bAsync, FSAsyncControl_t *pControl ) { return LoadData( pszFilename, pszPathID, NULL, 0, 0, bAsync, pControl ); } FSAsyncStatus_t LoadData( const char *pszFilename, const char *pszPathID, void *pDest, int nBytes, int nOffset, bool bAsync, FSAsyncControl_t *pControl ); vertexFileHeader_t *LoadVertexData( studiohdr_t *pStudioHdr ); vertexFileHeader_t *BuildAndCacheVertexData( studiohdr_t *pStudioHdr, vertexFileHeader_t *pRawVvdHdr ); bool BuildHardwareData( MDLHandle_t handle, studiodata_t *pStudioData, studiohdr_t *pStudioHdr, OptimizedModel::FileHeader_t *pVtxHdr ); void ConvertFlexData( studiohdr_t *pStudioHdr ); int ProcessPendingAsync( intp iAsync ); void ProcessPendingAsyncs( MDLCacheDataType_t type = MDLCACHE_NONE ); bool ClearAsync( MDLHandle_t handle, MDLCacheDataType_t type, int iAnimBlock, bool bAbort = false ); const char *GetVTXExtension(); virtual bool HandleCacheNotification( const DataCacheNotification_t ¬ification ); virtual bool GetItemName( DataCacheClientID_t clientId, const void *pItem, char *pDest, unsigned nMaxLen ); virtual bool GetAsyncLoad( MDLCacheDataType_t type ); virtual bool SetAsyncLoad( MDLCacheDataType_t type, bool bAsync ); // Creates the 360 file if it doesn't exist or is out of date int UpdateOrCreate( studiohdr_t *pHdr, const char *pFilename, char *pX360Filename, int maxLen, const char *pPathID, bool bForce = false ); // Attempts to read the platform native file - on 360 it can read and swap Win32 file as a fallback bool ReadFileNative( char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes = 0, MDLCacheDataType_t type = MDLCACHE_NONE ); // Creates a thin cache entry (to be used for model decals) from fat vertex data vertexFileHeader_t * CreateThinVertexes( vertexFileHeader_t * originalData, const studiohdr_t * pStudioHdr, int * cacheLength ); // Processes raw data (from an I/O source) into the cache. Sets the cache state as expected for bad data. bool ProcessDataIntoCache( MDLHandle_t handle, MDLCacheDataType_t type, int iAnimBlock, void *pData, int nDataSize, bool bDataValid ); void BreakFrameLock( bool bModels = true, bool bMesh = true ); void RestoreFrameLock(); private: IDataCacheSection *m_pModelCacheSection; IDataCacheSection *m_pMeshCacheSection; IDataCacheSection *m_pAnimBlockCacheSection; int m_nModelCacheFrameLocks; int m_nMeshCacheFrameLocks; CUtlDict< studiodata_t*, MDLHandle_t > m_MDLDict; IMDLCacheNotify *m_pCacheNotify; CUtlFixedLinkedList< AsyncInfo_t > m_PendingAsyncs; CThreadFastMutex m_QueuedLoadingMutex; CThreadFastMutex m_AsyncMutex; bool m_bLostVideoMemory : 1; bool m_bConnected : 1; bool m_bInitialized : 1; }; //----------------------------------------------------------------------------- // Singleton interface //----------------------------------------------------------------------------- static CMDLCache g_MDLCache; EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CMDLCache, IMDLCache, MDLCACHE_INTERFACE_VERSION, g_MDLCache ); EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CMDLCache, IStudioDataCache, STUDIO_DATA_CACHE_INTERFACE_VERSION, g_MDLCache ); //----------------------------------------------------------------------------- // Task switch //----------------------------------------------------------------------------- static void ReleaseMaterialSystemObjects( ) { g_MDLCache.ReleaseMaterialSystemObjects(); } static void RestoreMaterialSystemObjects( int nChangeFlags ) { g_MDLCache.RestoreMaterialSystemObjects( nChangeFlags ); } //----------------------------------------------------------------------------- // Constructor //----------------------------------------------------------------------------- CMDLCache::CMDLCache() : BaseClass( false ) { m_bLostVideoMemory = false; m_bConnected = false; m_bInitialized = false; m_pCacheNotify = NULL; m_pModelCacheSection = NULL; m_pMeshCacheSection = NULL; m_pAnimBlockCacheSection = NULL; m_nModelCacheFrameLocks = 0; m_nMeshCacheFrameLocks = 0; } //----------------------------------------------------------------------------- // Connect, disconnect //----------------------------------------------------------------------------- bool CMDLCache::Connect( CreateInterfaceFn factory ) { // Connect can be called twice, because this inherits from 2 appsystems. if ( m_bConnected ) return true; if ( !BaseClass::Connect( factory ) ) return false; if ( !g_pMaterialSystemHardwareConfig || !g_pPhysicsCollision || !g_pStudioRender || !g_pMaterialSystem ) return false; m_bConnected = true; if( g_pMaterialSystem ) { g_pMaterialSystem->AddReleaseFunc( ::ReleaseMaterialSystemObjects ); g_pMaterialSystem->AddRestoreFunc( ::RestoreMaterialSystemObjects ); } return true; } void CMDLCache::Disconnect() { if ( g_pMaterialSystem && m_bConnected ) { g_pMaterialSystem->RemoveReleaseFunc( ::ReleaseMaterialSystemObjects ); g_pMaterialSystem->RemoveRestoreFunc( ::RestoreMaterialSystemObjects ); m_bConnected = false; } BaseClass::Disconnect(); } //----------------------------------------------------------------------------- // Query Interface //----------------------------------------------------------------------------- void *CMDLCache::QueryInterface( const char *pInterfaceName ) { if (!Q_strncmp( pInterfaceName, STUDIO_DATA_CACHE_INTERFACE_VERSION, Q_strlen(STUDIO_DATA_CACHE_INTERFACE_VERSION) + 1)) return (IStudioDataCache*)this; if (!Q_strncmp( pInterfaceName, MDLCACHE_INTERFACE_VERSION, Q_strlen(MDLCACHE_INTERFACE_VERSION) + 1)) return (IMDLCache*)this; return NULL; } //----------------------------------------------------------------------------- // Init/Shutdown //----------------------------------------------------------------------------- #define MODEL_CACHE_MODEL_SECTION_NAME "ModelData" #define MODEL_CACHE_MESH_SECTION_NAME "ModelMesh" #define MODEL_CACHE_ANIMBLOCK_SECTION_NAME "AnimBlock" // #define ENABLE_CACHE_WATCH 1 #if defined( ENABLE_CACHE_WATCH ) static ConVar cache_watch( "cache_watch", "", 0 ); static void CacheLog( const char *fileName, const char *accessType ) { if ( Q_stristr( fileName, cache_watch.GetString() ) ) { Msg( "%s access to %s\n", accessType, fileName ); } } #endif InitReturnVal_t CMDLCache::Init() { // Can be called twice since it inherits from 2 appsystems if ( m_bInitialized ) return INIT_OK; InitReturnVal_t nRetVal = BaseClass::Init(); if ( nRetVal != INIT_OK ) return nRetVal; if ( !m_pModelCacheSection ) { m_pModelCacheSection = g_pDataCache->AddSection( this, MODEL_CACHE_MODEL_SECTION_NAME ); } if ( !m_pMeshCacheSection ) { unsigned int meshLimit = (unsigned)-1; DataCacheLimits_t limits( meshLimit, (unsigned)-1, 0, 0 ); m_pMeshCacheSection = g_pDataCache->AddSection( this, MODEL_CACHE_MESH_SECTION_NAME, limits ); } if ( !m_pAnimBlockCacheSection ) { // 360 tuned to worst case, ep_outland_12a, less than 6 MB is not a viable working set unsigned int animBlockLimit = IsX360() ? 6*1024*1024 : (unsigned)-1; DataCacheLimits_t limits( animBlockLimit, (unsigned)-1, 0, 0 ); m_pAnimBlockCacheSection = g_pDataCache->AddSection( this, MODEL_CACHE_ANIMBLOCK_SECTION_NAME, limits ); } if ( IsX360() ) { // By default, source data is assumed to be non-native to the 360. StudioByteSwap::ActivateByteSwapping( true ); StudioByteSwap::SetCollisionInterface( g_pPhysicsCollision ); } m_bLostVideoMemory = false; m_bInitialized = true; #if defined( ENABLE_CACHE_WATCH ) g_pFullFileSystem->AddLoggingFunc( &CacheLog ); #endif return INIT_OK; } void CMDLCache::Shutdown() { if ( !m_bInitialized ) return; #if defined( ENABLE_CACHE_WATCH ) g_pFullFileSystem->RemoveLoggingFunc( CacheLog ); #endif m_bInitialized = false; if ( m_pModelCacheSection || m_pMeshCacheSection ) { // Free all MDLs that haven't been cleaned up MDLHandle_t i = m_MDLDict.First(); while ( i != m_MDLDict.InvalidIndex() ) { ShutdownStudioData( i ); i = m_MDLDict.Next( i ); } m_MDLDict.Purge(); if ( m_pModelCacheSection ) { g_pDataCache->RemoveSection( MODEL_CACHE_MODEL_SECTION_NAME ); m_pModelCacheSection = NULL; } if ( m_pMeshCacheSection ) { g_pDataCache->RemoveSection( MODEL_CACHE_MESH_SECTION_NAME ); m_pMeshCacheSection = NULL; } } if ( m_pAnimBlockCacheSection ) { g_pDataCache->RemoveSection( MODEL_CACHE_ANIMBLOCK_SECTION_NAME ); m_pAnimBlockCacheSection = NULL; } BaseClass::Shutdown(); } //----------------------------------------------------------------------------- // Flushes an MDLHandle_t //----------------------------------------------------------------------------- void CMDLCache::Flush( MDLHandle_t handle, int nFlushFlags ) { studiodata_t *pStudioData = m_MDLDict[handle]; Assert( pStudioData != NULL ); bool bIgnoreLock = ( nFlushFlags & MDLCACHE_FLUSH_IGNORELOCK ) != 0; // release the hardware portion if ( nFlushFlags & MDLCACHE_FLUSH_STUDIOHWDATA ) { if ( ClearAsync( handle, MDLCACHE_STUDIOHWDATA, 0, true ) ) { m_pMeshCacheSection->Unlock( pStudioData->m_VertexCache ); } UnloadHardwareData( handle, true, bIgnoreLock ); } // free collision if ( nFlushFlags & MDLCACHE_FLUSH_VCOLLIDE ) { DestroyVCollide( handle ); } // Free animations if ( nFlushFlags & MDLCACHE_FLUSH_VIRTUALMODEL ) { FreeVirtualModel( handle ); } if ( nFlushFlags & MDLCACHE_FLUSH_ANIMBLOCK ) { FreeAnimBlocks( handle ); } if ( nFlushFlags & MDLCACHE_FLUSH_AUTOPLAY ) { // Free autoplay sequences FreeAutoplaySequences( pStudioData ); } if ( nFlushFlags & MDLCACHE_FLUSH_STUDIOHDR ) { MdlCacheMsg( "MDLCache: Free studiohdr %s\n", GetModelName( handle ) ); if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_LOCKED_MDL ) { GetCacheSection( MDLCACHE_STUDIOHDR )->Unlock( pStudioData->m_MDLCache ); pStudioData->m_nFlags &= ~STUDIODATA_FLAGS_LOCKED_MDL; } UncacheData( pStudioData->m_MDLCache, MDLCACHE_STUDIOHDR, bIgnoreLock ); pStudioData->m_MDLCache = NULL; } if ( nFlushFlags & MDLCACHE_FLUSH_VERTEXES ) { MdlCacheMsg( "MDLCache: Free VVD %s\n", GetModelName( handle ) ); ClearAsync( handle, MDLCACHE_VERTEXES, 0, true ); UncacheData( pStudioData->m_VertexCache, MDLCACHE_VERTEXES, bIgnoreLock ); pStudioData->m_VertexCache = NULL; } // Now check whatever files are not loaded, make sure file system knows // that we don't have them loaded. if ( !IsDataLoaded( handle, MDLCACHE_STUDIOHDR ) ) NotifyFileUnloaded( handle, ".mdl" ); if ( !IsDataLoaded( handle, MDLCACHE_STUDIOHWDATA ) ) NotifyFileUnloaded( handle, GetVTXExtension() ); if ( !IsDataLoaded( handle, MDLCACHE_VERTEXES ) ) NotifyFileUnloaded( handle, ".vvd" ); if ( !IsDataLoaded( handle, MDLCACHE_VCOLLIDE ) ) NotifyFileUnloaded( handle, ".phy" ); } //----------------------------------------------------------------------------- // Inits, shuts downs studiodata_t //----------------------------------------------------------------------------- void CMDLCache::InitStudioData( MDLHandle_t handle ) { Assert( m_MDLDict[handle] == NULL ); studiodata_t *pStudioData = new studiodata_t; m_MDLDict[handle] = pStudioData; memset( pStudioData, 0, sizeof( studiodata_t ) ); } void CMDLCache::ShutdownStudioData( MDLHandle_t handle ) { Flush( handle ); studiodata_t *pStudioData = m_MDLDict[handle]; Assert( pStudioData != NULL ); delete pStudioData; m_MDLDict[handle] = NULL; } //----------------------------------------------------------------------------- // Sets the cache notify //----------------------------------------------------------------------------- void CMDLCache::SetCacheNotify( IMDLCacheNotify *pNotify ) { m_pCacheNotify = pNotify; } //----------------------------------------------------------------------------- // Returns the name of the model //----------------------------------------------------------------------------- const char *CMDLCache::GetModelName( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) return ERROR_MODEL; return m_MDLDict.GetElementName( handle ); } //----------------------------------------------------------------------------- // Returns the *actual* name of the model (could be an error model) //----------------------------------------------------------------------------- const char *CMDLCache::GetActualModelName( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) return ERROR_MODEL; if ( m_MDLDict[handle]->m_nFlags & STUDIODATA_ERROR_MODEL ) return ERROR_MODEL; return m_MDLDict.GetElementName( handle ); } //----------------------------------------------------------------------------- // Constructs a filename based on a model handle //----------------------------------------------------------------------------- void CMDLCache::MakeFilename( MDLHandle_t handle, const char *pszExtension, char *pszFileName, int nMaxLength ) { Q_strncpy( pszFileName, GetActualModelName( handle ), nMaxLength ); Q_SetExtension( pszFileName, pszExtension, nMaxLength ); Q_FixSlashes( pszFileName ); #ifdef POSIX Q_strlower( pszFileName ); #endif } //----------------------------------------------------------------------------- void CMDLCache::NotifyFileUnloaded( MDLHandle_t handle, const char *pszExtension ) { if ( handle == MDLHANDLE_INVALID ) return; if ( !m_MDLDict.IsValidIndex( handle ) ) return; char szFilename[MAX_PATH]; V_strcpy_safe( szFilename, m_MDLDict.GetElementName( handle ) ); V_SetExtension( szFilename, pszExtension, sizeof(szFilename) ); V_FixSlashes( szFilename ); g_pFullFileSystem->NotifyFileUnloaded( szFilename, "game" ); } //----------------------------------------------------------------------------- // Finds an MDL //----------------------------------------------------------------------------- MDLHandle_t CMDLCache::FindMDL( const char *pMDLRelativePath ) { // can't trust provided path // ensure provided path correctly resolves (Dictionary is case-insensitive) char szFixedName[MAX_PATH]; V_strncpy( szFixedName, pMDLRelativePath, sizeof( szFixedName ) ); V_RemoveDotSlashes( szFixedName, '/' ); MDLHandle_t handle = m_MDLDict.Find( szFixedName ); if ( handle == m_MDLDict.InvalidIndex() ) { handle = m_MDLDict.Insert( szFixedName, NULL ); InitStudioData( handle ); } AddRef( handle ); return handle; } //----------------------------------------------------------------------------- // Reference counting //----------------------------------------------------------------------------- int CMDLCache::AddRef( MDLHandle_t handle ) { return ++m_MDLDict[handle]->m_nRefCount; } int CMDLCache::Release( MDLHandle_t handle ) { // Deal with shutdown order issues (i.e. datamodel shutting down after mdlcache) if ( !m_bInitialized ) return 0; // NOTE: It can be null during shutdown because multiple studiomdls // could be referencing the same virtual model if ( !m_MDLDict[handle] ) return 0; Assert( m_MDLDict[handle]->m_nRefCount > 0 ); int nRefCount = --m_MDLDict[handle]->m_nRefCount; if ( nRefCount <= 0 ) { ShutdownStudioData( handle ); m_MDLDict.RemoveAt( handle ); } return nRefCount; } int CMDLCache::GetRef( MDLHandle_t handle ) { if ( !m_bInitialized ) return 0; if ( !m_MDLDict[handle] ) return 0; return m_MDLDict[handle]->m_nRefCount; } //----------------------------------------------------------------------------- // Unserializes the PHY file associated w/ models (the vphysics representation) //----------------------------------------------------------------------------- void CMDLCache::UnserializeVCollide( MDLHandle_t handle, bool synchronousLoad ) { VPROF( "CMDLCache::UnserializeVCollide" ); // FIXME: Should the vcollde be played into cacheable memory? studiodata_t *pStudioData = m_MDLDict[handle]; intp iAsync = GetAsyncInfoIndex( handle, MDLCACHE_VCOLLIDE ); if ( iAsync == NO_ASYNC ) { // clear existing data pStudioData->m_nFlags &= ~STUDIODATA_FLAGS_VCOLLISION_LOADED; memset( &pStudioData->m_VCollisionData, 0, sizeof( pStudioData->m_VCollisionData ) ); #if 0 // FIXME: ywb // If we don't ask for the virtual model to load, then we can get a hitch later on after startup // Should we async load the sub .mdls during startup assuming they'll all be resident by the time the level can actually // start drawing? if ( pStudioData->m_pVirtualModel || synchronousLoad ) #endif { virtualmodel_t *pVirtualModel = GetVirtualModel( handle ); if ( pVirtualModel ) { for ( int i = 1; i < pVirtualModel->m_group.Count(); i++ ) { MDLHandle_t sharedHandle = VoidPtrToMDLHandle(pVirtualModel->m_group[i].cache); studiodata_t *pData = m_MDLDict[sharedHandle]; if ( !(pData->m_nFlags & STUDIODATA_FLAGS_VCOLLISION_LOADED) ) { UnserializeVCollide( sharedHandle, synchronousLoad ); } if ( pData->m_VCollisionData.solidCount > 0 ) { pStudioData->m_VCollisionData = pData->m_VCollisionData; pStudioData->m_nFlags |= STUDIODATA_FLAGS_VCOLLISION_SHARED; return; } } } } char pFileName[MAX_PATH]; MakeFilename( handle, ".phy", pFileName, sizeof(pFileName) ); if ( IsX360() ) { char pX360Filename[MAX_PATH]; UpdateOrCreate( NULL, pFileName, pX360Filename, sizeof( pX360Filename ), "GAME" ); Q_strncpy( pFileName, pX360Filename, sizeof(pX360Filename) ); } bool bAsyncLoad = mod_load_vcollide_async.GetBool() && !synchronousLoad; MdlCacheMsg( "MDLCache: %s load vcollide %s\n", bAsyncLoad ? "Async" : "Sync", GetModelName( handle ) ); AsyncInfo_t info; if ( IsDebug() ) { memset( &info, 0xdd, sizeof( AsyncInfo_t ) ); } info.hModel = handle; info.type = MDLCACHE_VCOLLIDE; info.iAnimBlock = 0; info.hControl = NULL; LoadData( pFileName, "GAME", bAsyncLoad, &info.hControl ); { AUTO_LOCK( m_AsyncMutex ); iAsync = SetAsyncInfoIndex( handle, MDLCACHE_VCOLLIDE, m_PendingAsyncs.AddToTail( info ) ); } } else if ( synchronousLoad ) { AsyncInfo_t *pInfo; { AUTO_LOCK( m_AsyncMutex ); pInfo = &m_PendingAsyncs[iAsync]; } if ( pInfo->hControl ) { g_pFullFileSystem->AsyncFinish( pInfo->hControl, true ); } } ProcessPendingAsync( iAsync ); } //----------------------------------------------------------------------------- // Free model's collision data //----------------------------------------------------------------------------- void CMDLCache::DestroyVCollide( MDLHandle_t handle ) { studiodata_t *pStudioData = m_MDLDict[handle]; if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_VCOLLISION_SHARED ) return; if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_VCOLLISION_LOADED ) { pStudioData->m_nFlags &= ~STUDIODATA_FLAGS_VCOLLISION_LOADED; if ( pStudioData->m_VCollisionData.solidCount ) { if ( m_pCacheNotify ) { m_pCacheNotify->OnDataUnloaded( MDLCACHE_VCOLLIDE, handle ); } MdlCacheMsg("MDLCache: Unload vcollide %s\n", GetModelName( handle ) ); g_pPhysicsCollision->VCollideUnload( &pStudioData->m_VCollisionData ); } } } //----------------------------------------------------------------------------- // Unserializes the PHY file associated w/ models (the vphysics representation) //----------------------------------------------------------------------------- vcollide_t *CMDLCache::GetVCollideEx( MDLHandle_t handle, bool synchronousLoad /*= true*/ ) { if ( mod_test_not_available.GetBool() ) return NULL; if ( handle == MDLHANDLE_INVALID ) return NULL; studiodata_t *pStudioData = m_MDLDict[handle]; if ( ( pStudioData->m_nFlags & STUDIODATA_FLAGS_VCOLLISION_LOADED ) == 0 ) { UnserializeVCollide( handle, synchronousLoad ); } // We've loaded an empty collision file or no file was found, so return NULL if ( !pStudioData->m_VCollisionData.solidCount ) return NULL; return &pStudioData->m_VCollisionData; } bool CMDLCache::GetVCollideSize( MDLHandle_t handle, int *pVCollideSize ) { *pVCollideSize = 0; studiodata_t *pStudioData = m_MDLDict[handle]; if ( ( pStudioData->m_nFlags & STUDIODATA_FLAGS_VCOLLISION_LOADED ) == 0 ) return false; vcollide_t *pCollide = &pStudioData->m_VCollisionData; for ( int j = 0; j < pCollide->solidCount; j++ ) { *pVCollideSize += g_pPhysicsCollision->CollideSize( pCollide->solids[j] ); } *pVCollideSize += pCollide->descSize; return true; } //----------------------------------------------------------------------------- // Allocates/frees the anim blocks //----------------------------------------------------------------------------- void CMDLCache::AllocateAnimBlocks( studiodata_t *pStudioData, int nCount ) { Assert( pStudioData->m_pAnimBlock == NULL ); pStudioData->m_nAnimBlockCount = nCount; pStudioData->m_pAnimBlock = new DataCacheHandle_t[pStudioData->m_nAnimBlockCount]; memset( pStudioData->m_pAnimBlock, 0, sizeof(DataCacheHandle_t) * pStudioData->m_nAnimBlockCount ); pStudioData->m_iFakeAnimBlockStall = new unsigned int [pStudioData->m_nAnimBlockCount]; memset( pStudioData->m_iFakeAnimBlockStall, 0, sizeof( unsigned int ) * pStudioData->m_nAnimBlockCount ); } void CMDLCache::FreeAnimBlocks( MDLHandle_t handle ) { studiodata_t *pStudioData = m_MDLDict[handle]; if ( pStudioData->m_pAnimBlock ) { for (int i = 0; i < pStudioData->m_nAnimBlockCount; ++i ) { MdlCacheMsg( "MDLCache: Free Anim block: %d\n", i ); ClearAsync( handle, MDLCACHE_ANIMBLOCK, i, true ); if ( pStudioData->m_pAnimBlock[i] ) { UncacheData( pStudioData->m_pAnimBlock[i], MDLCACHE_ANIMBLOCK, true ); } } delete[] pStudioData->m_pAnimBlock; pStudioData->m_pAnimBlock = NULL; delete[] pStudioData->m_iFakeAnimBlockStall; pStudioData->m_iFakeAnimBlockStall = NULL; } pStudioData->m_nAnimBlockCount = 0; } //----------------------------------------------------------------------------- // Unserializes an animation block from disk //----------------------------------------------------------------------------- unsigned char *CMDLCache::UnserializeAnimBlock( MDLHandle_t handle, int nBlock ) { VPROF( "CMDLCache::UnserializeAnimBlock" ); if ( IsX360() && g_pQueuedLoader->IsMapLoading() ) { // anim block i/o is not allowed at this stage return NULL; } // Block 0 is never used!!! Assert( nBlock > 0 ); studiodata_t *pStudioData = m_MDLDict[handle]; intp iAsync = GetAsyncInfoIndex( handle, MDLCACHE_ANIMBLOCK, nBlock ); if ( iAsync == NO_ASYNC ) { studiohdr_t *pStudioHdr = GetStudioHdr( handle ); // FIXME: For consistency, the block name maybe shouldn't have 'model' in it. char const *pModelName = pStudioHdr->pszAnimBlockName(); mstudioanimblock_t *pBlock = pStudioHdr->pAnimBlock( nBlock ); int nSize = pBlock->dataend - pBlock->datastart; if ( nSize == 0 ) return NULL; // allocate space in the cache pStudioData->m_pAnimBlock[nBlock] = NULL; char pFileName[MAX_PATH]; Q_strncpy( pFileName, pModelName, sizeof(pFileName) ); Q_FixSlashes( pFileName ); #ifdef POSIX Q_strlower( pFileName ); #endif if ( IsX360() ) { char pX360Filename[MAX_PATH]; UpdateOrCreate( pStudioHdr, pFileName, pX360Filename, sizeof( pX360Filename ), "GAME" ); Q_strncpy( pFileName, pX360Filename, sizeof(pX360Filename) ); } MdlCacheMsg( "MDLCache: Begin load Anim Block %s (block %i)\n", GetModelName( handle ), nBlock ); AsyncInfo_t info; if ( IsDebug() ) { memset( &info, 0xdd, sizeof( AsyncInfo_t ) ); } info.hModel = handle; info.type = MDLCACHE_ANIMBLOCK; info.iAnimBlock = nBlock; info.hControl = NULL; LoadData( pFileName, "GAME", NULL, nSize, pBlock->datastart, mod_load_anims_async.GetBool(), &info.hControl ); { AUTO_LOCK( m_AsyncMutex ); iAsync = SetAsyncInfoIndex( handle, MDLCACHE_ANIMBLOCK, nBlock, m_PendingAsyncs.AddToTail( info ) ); } } ProcessPendingAsync( iAsync ); return ( unsigned char * )CheckData( pStudioData->m_pAnimBlock[nBlock], MDLCACHE_ANIMBLOCK ); } //----------------------------------------------------------------------------- // Gets at an animation block associated with an MDL //----------------------------------------------------------------------------- unsigned char *CMDLCache::GetAnimBlock( MDLHandle_t handle, int nBlock ) { if ( mod_test_not_available.GetBool() ) return NULL; if ( handle == MDLHANDLE_INVALID ) return NULL; // Allocate animation blocks if we don't have them yet studiodata_t *pStudioData = m_MDLDict[handle]; if ( pStudioData->m_pAnimBlock == NULL ) { studiohdr_t *pStudioHdr = GetStudioHdr( handle ); AllocateAnimBlocks( pStudioData, pStudioHdr->numanimblocks ); } // check for request being in range if ( nBlock < 0 || nBlock >= pStudioData->m_nAnimBlockCount) return NULL; // Check the cache to see if the animation is in memory unsigned char *pData = ( unsigned char * )CheckData( pStudioData->m_pAnimBlock[nBlock], MDLCACHE_ANIMBLOCK ); if ( !pData ) { pStudioData->m_pAnimBlock[nBlock] = NULL; // It's not in memory, read it off of disk pData = UnserializeAnimBlock( handle, nBlock ); } if (mod_load_fakestall.GetInt()) { unsigned int t = Plat_MSTime(); if (pStudioData->m_iFakeAnimBlockStall[nBlock] == 0 || pStudioData->m_iFakeAnimBlockStall[nBlock] > t) { pStudioData->m_iFakeAnimBlockStall[nBlock] = t; } if ((int)(t - pStudioData->m_iFakeAnimBlockStall[nBlock]) < mod_load_fakestall.GetInt()) { return NULL; } } return pData; } //----------------------------------------------------------------------------- // Allocates/frees autoplay sequence list //----------------------------------------------------------------------------- void CMDLCache::AllocateAutoplaySequences( studiodata_t *pStudioData, int nCount ) { FreeAutoplaySequences( pStudioData ); pStudioData->m_nAutoplaySequenceCount = nCount; pStudioData->m_pAutoplaySequenceList = new unsigned short[nCount]; } void CMDLCache::FreeAutoplaySequences( studiodata_t *pStudioData ) { if ( pStudioData->m_pAutoplaySequenceList ) { delete[] pStudioData->m_pAutoplaySequenceList; pStudioData->m_pAutoplaySequenceList = NULL; } pStudioData->m_nAutoplaySequenceCount = 0; } //----------------------------------------------------------------------------- // Gets the autoplay list //----------------------------------------------------------------------------- int CMDLCache::GetAutoplayList( MDLHandle_t handle, unsigned short **pAutoplayList ) { if ( pAutoplayList ) { *pAutoplayList = NULL; } if ( handle == MDLHANDLE_INVALID ) return 0; virtualmodel_t *pVirtualModel = GetVirtualModel( handle ); if ( pVirtualModel ) { if ( pAutoplayList && pVirtualModel->m_autoplaySequences.Count() ) { *pAutoplayList = pVirtualModel->m_autoplaySequences.Base(); } return pVirtualModel->m_autoplaySequences.Count(); } // FIXME: Should we cache autoplay info here on demand instead of in unserializeMDL? studiodata_t *pStudioData = m_MDLDict[handle]; if ( pAutoplayList ) { *pAutoplayList = pStudioData->m_pAutoplaySequenceList; } return pStudioData->m_nAutoplaySequenceCount; } //----------------------------------------------------------------------------- // Allocates/frees the virtual model //----------------------------------------------------------------------------- void CMDLCache::AllocateVirtualModel( MDLHandle_t handle ) { studiodata_t *pStudioData = m_MDLDict[handle]; Assert( pStudioData->m_pVirtualModel == NULL ); pStudioData->m_pVirtualModel = new virtualmodel_t; // FIXME: The old code slammed these; could have leaked memory? Assert( pStudioData->m_nAnimBlockCount == 0 ); Assert( pStudioData->m_pAnimBlock == NULL ); } void CMDLCache::FreeVirtualModel( MDLHandle_t handle ) { studiodata_t *pStudioData = m_MDLDict[handle]; if ( pStudioData && pStudioData->m_pVirtualModel ) { int nGroupCount = pStudioData->m_pVirtualModel->m_group.Count(); Assert( (nGroupCount >= 1) && pStudioData->m_pVirtualModel->m_group[0].cache == MDLHandleToVirtual(handle) ); // NOTE: Start at *1* here because the 0th element contains a reference to *this* handle for ( int i = 1; i < nGroupCount; ++i ) { MDLHandle_t h = VoidPtrToMDLHandle( pStudioData->m_pVirtualModel->m_group[i].cache ); FreeVirtualModel( h ); Release( h ); } delete pStudioData->m_pVirtualModel; pStudioData->m_pVirtualModel = NULL; } } //----------------------------------------------------------------------------- // Returns the virtual model //----------------------------------------------------------------------------- virtualmodel_t *CMDLCache::GetVirtualModel( MDLHandle_t handle ) { if ( mod_test_not_available.GetBool() ) return NULL; if ( handle == MDLHANDLE_INVALID ) return NULL; studiohdr_t *pStudioHdr = GetStudioHdr( handle ); if ( pStudioHdr == NULL ) return NULL; return GetVirtualModelFast( pStudioHdr, handle ); } virtualmodel_t *CMDLCache::GetVirtualModelFast( const studiohdr_t *pStudioHdr, MDLHandle_t handle ) { if (pStudioHdr->numincludemodels == 0) return NULL; studiodata_t *pStudioData = m_MDLDict[handle]; if ( !pStudioData ) return NULL; if ( !pStudioData->m_pVirtualModel ) { DevMsg( 2, "Loading virtual model for %s\n", pStudioHdr->pszName() ); CMDLCacheCriticalSection criticalSection( this ); AllocateVirtualModel( handle ); // MoeMod : added pStudioHdr->SetVirtualModel( MDLHandleToVirtual( handle ) ); // Group has to be zero to ensure refcounting is correct int nGroup = pStudioData->m_pVirtualModel->m_group.AddToTail( ); Assert( nGroup == 0 ); pStudioData->m_pVirtualModel->m_group[nGroup].cache = MDLHandleToVirtual(handle); // Add all dependent data pStudioData->m_pVirtualModel->AppendModels( 0, pStudioHdr ); } return pStudioData->m_pVirtualModel; } //----------------------------------------------------------------------------- // Purpose: Pulls all submodels/.ani file models into the cache // to avoid runtime hitches and load animations at load time, set mod_forcedata to be 1 //----------------------------------------------------------------------------- void CMDLCache::UnserializeAllVirtualModelsAndAnimBlocks( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) return; // might be re-loading, discard old virtualmodel to force rebuild // unfortunately, the virtualmodel does build data into the cacheable studiohdr FreeVirtualModel( handle ); if ( IsX360() && g_pQueuedLoader->IsMapLoading() ) { // queued loading has to do it return; } // don't load the submodel data if ( !mod_forcedata.GetBool() ) return; // if not present, will instance and load the submodels GetVirtualModel( handle ); if ( IsX360() ) { // 360 does not drive the anims into its small cache section return; } // Note that the animblocks start at 1!!! studiohdr_t *pStudioHdr = GetStudioHdr( handle ); for ( int i = 1 ; i < (int)pStudioHdr->numanimblocks; ++i ) { GetAnimBlock( handle, i ); } ProcessPendingAsyncs( MDLCACHE_ANIMBLOCK ); } //----------------------------------------------------------------------------- // Loads the static meshes //----------------------------------------------------------------------------- bool CMDLCache::LoadHardwareData( MDLHandle_t handle ) { Assert( handle != MDLHANDLE_INVALID ); // Don't try to load VTX files if we don't have focus... if ( m_bLostVideoMemory ) return false; studiodata_t *pStudioData = m_MDLDict[handle]; CMDLCacheCriticalSection criticalSection( this ); // Load up the model studiohdr_t *pStudioHdr = GetStudioHdr( handle ); if ( !pStudioHdr || !pStudioHdr->numbodyparts ) { pStudioData->m_nFlags |= STUDIODATA_FLAGS_NO_STUDIOMESH; return true; } if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_NO_STUDIOMESH ) { return false; } if ( LogMdlCache() && GetAsyncInfoIndex( handle, MDLCACHE_STUDIOHWDATA ) == NO_ASYNC && GetAsyncInfoIndex( handle, MDLCACHE_VERTEXES ) == NO_ASYNC ) { MdlCacheMsg( "MDLCache: Begin load studiomdl %s\n", GetModelName( handle ) ); } // Vertex data is required to call LoadModel(), so make sure that's ready if ( !GetVertexData( handle ) ) { if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_NO_VERTEX_DATA ) { pStudioData->m_nFlags |= STUDIODATA_FLAGS_NO_STUDIOMESH; } return false; } intp iAsync = GetAsyncInfoIndex( handle, MDLCACHE_STUDIOHWDATA ); if ( iAsync == NO_ASYNC ) { m_pMeshCacheSection->Lock( pStudioData->m_VertexCache ); // load and persist the vtx file // use model name for correct path char pFileName[MAX_PATH]; MakeFilename( handle, GetVTXExtension(), pFileName, sizeof(pFileName) ); if ( IsX360() ) { char pX360Filename[MAX_PATH]; UpdateOrCreate( pStudioHdr, pFileName, pX360Filename, sizeof( pX360Filename ), "GAME" ); Q_strncpy( pFileName, pX360Filename, sizeof(pX360Filename) ); } MdlCacheMsg("MDLCache: Begin load VTX %s\n", GetModelName( handle ) ); AsyncInfo_t info; if ( IsDebug() ) { memset( &info, 0xdd, sizeof( AsyncInfo_t ) ); } info.hModel = handle; info.type = MDLCACHE_STUDIOHWDATA; info.iAnimBlock = 0; info.hControl = NULL; LoadData( pFileName, "GAME", mod_load_mesh_async.GetBool(), &info.hControl ); { AUTO_LOCK( m_AsyncMutex ); iAsync = SetAsyncInfoIndex( handle, MDLCACHE_STUDIOHWDATA, m_PendingAsyncs.AddToTail( info ) ); } } if ( ProcessPendingAsync( iAsync ) > 0 ) { if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_NO_STUDIOMESH ) { return false; } return ( pStudioData->m_HardwareData.m_NumStudioMeshes != 0 ); } return false; } void CMDLCache::ConvertFlexData( studiohdr_t *pStudioHdr ) { float flVertAnimFixedPointScale = pStudioHdr->VertAnimFixedPointScale(); for ( int i = 0; i < pStudioHdr->numbodyparts; i++ ) { mstudiobodyparts_t *pBody = pStudioHdr->pBodypart( i ); for ( int j = 0; j < pBody->nummodels; j++ ) { mstudiomodel_t *pModel = pBody->pModel( j ); for ( int k = 0; k < pModel->nummeshes; k++ ) { mstudiomesh_t *pMesh = pModel->pMesh( k ); for ( int l = 0; l < pMesh->numflexes; l++ ) { mstudioflex_t *pFlex = pMesh->pFlex( l ); bool bIsWrinkleAnim = ( pFlex->vertanimtype == STUDIO_VERT_ANIM_WRINKLE ); for ( int m = 0; m < pFlex->numverts; m++ ) { mstudiovertanim_t *pVAnim = bIsWrinkleAnim ? pFlex->pVertanimWrinkle( m ) : pFlex->pVertanim( m ); pVAnim->ConvertToFixed( flVertAnimFixedPointScale ); } } } } } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- bool CMDLCache::BuildHardwareData( MDLHandle_t handle, studiodata_t *pStudioData, studiohdr_t *pStudioHdr, OptimizedModel::FileHeader_t *pVtxHdr ) { if ( pVtxHdr ) { MdlCacheMsg("MDLCache: Alloc VTX %s\n", pStudioHdr->pszName() ); // check header if ( pVtxHdr->version != OPTIMIZED_MODEL_FILE_VERSION ) { Warning( "Error Index File for '%s' version %d should be %d\n", pStudioHdr->pszName(), pVtxHdr->version, OPTIMIZED_MODEL_FILE_VERSION ); pVtxHdr = NULL; } else if ( pVtxHdr->checkSum != pStudioHdr->checksum ) { Warning( "Error Index File for '%s' checksum %d should be %d\n", pStudioHdr->pszName(), pVtxHdr->checkSum, pStudioHdr->checksum ); pVtxHdr = NULL; } } if ( !pVtxHdr ) { pStudioData->m_nFlags |= STUDIODATA_FLAGS_NO_STUDIOMESH; return false; } CTempAllocHelper pOriginalData; if ( IsX360() ) { unsigned char *pInputData = (unsigned char *)pVtxHdr + sizeof( OptimizedModel::FileHeader_t ); if ( CLZMA::IsCompressed( pInputData ) ) { // vtx arrives compressed, decode and cache the results unsigned int nOriginalSize = CLZMA::GetActualSize( pInputData ); pOriginalData.Alloc( sizeof( OptimizedModel::FileHeader_t ) + nOriginalSize ); V_memcpy( pOriginalData.Get(), pVtxHdr, sizeof( OptimizedModel::FileHeader_t ) ); unsigned int nOutputSize = CLZMA::Uncompress( pInputData, sizeof( OptimizedModel::FileHeader_t ) + (unsigned char *)pOriginalData.Get() ); if ( nOutputSize != nOriginalSize ) { // decoder failure return false; } pVtxHdr = (OptimizedModel::FileHeader_t *)pOriginalData.Get(); } } MdlCacheMsg( "MDLCache: Load studiomdl %s\n", pStudioHdr->pszName() ); Assert( GetVertexData( handle ) ); BeginLock(); bool bLoaded = g_pStudioRender->LoadModel( pStudioHdr, pVtxHdr, &pStudioData->m_HardwareData ); EndLock(); if ( bLoaded ) { pStudioData->m_nFlags |= STUDIODATA_FLAGS_STUDIOMESH_LOADED; } else { pStudioData->m_nFlags |= STUDIODATA_FLAGS_NO_STUDIOMESH; } if ( m_pCacheNotify ) { m_pCacheNotify->OnDataLoaded( MDLCACHE_STUDIOHWDATA, handle ); } #if defined( USE_HARDWARE_CACHE ) GetCacheSection( MDLCACHE_STUDIOHWDATA )->Add( MakeCacheID( handle, MDLCACHE_STUDIOHWDATA ), &pStudioData->m_HardwareData, ComputeHardwareDataSize( &pStudioData->m_HardwareData ), &pStudioData->m_HardwareDataCache ); #endif return true; } //----------------------------------------------------------------------------- // Loads the static meshes //----------------------------------------------------------------------------- void CMDLCache::UnloadHardwareData( MDLHandle_t handle, bool bCacheRemove, bool bLockedOk ) { if ( handle == MDLHANDLE_INVALID ) return; // Don't load it if it's loaded studiodata_t *pStudioData = m_MDLDict[handle]; if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_STUDIOMESH_LOADED ) { #if defined( USE_HARDWARE_CACHE ) if ( bCacheRemove ) { if ( GetCacheSection( MDLCACHE_STUDIOHWDATA )->BreakLock( pStudioData->m_HardwareDataCache ) && !bLockedOk ) { DevMsg( "Warning: freed a locked resource\n" ); Assert( 0 ); } GetCacheSection( MDLCACHE_STUDIOHWDATA )->Remove( pStudioData->m_HardwareDataCache ); } #endif if ( m_pCacheNotify ) { m_pCacheNotify->OnDataUnloaded( MDLCACHE_STUDIOHWDATA, handle ); } MdlCacheMsg("MDLCache: Unload studiomdl %s\n", GetModelName( handle ) ); g_pStudioRender->UnloadModel( &pStudioData->m_HardwareData ); memset( &pStudioData->m_HardwareData, 0, sizeof( pStudioData->m_HardwareData ) ); pStudioData->m_nFlags &= ~STUDIODATA_FLAGS_STUDIOMESH_LOADED; NotifyFileUnloaded( handle, ".mdl" ); } } //----------------------------------------------------------------------------- // Returns the hardware data associated with an MDL //----------------------------------------------------------------------------- studiohwdata_t *CMDLCache::GetHardwareData( MDLHandle_t handle ) { if ( mod_test_not_available.GetBool() ) return NULL; if ( mod_test_mesh_not_available.GetBool() ) return NULL; studiodata_t *pStudioData = m_MDLDict[handle]; m_pMeshCacheSection->LockMutex(); if ( ( pStudioData->m_nFlags & (STUDIODATA_FLAGS_STUDIOMESH_LOADED | STUDIODATA_FLAGS_NO_STUDIOMESH) ) == 0 ) { m_pMeshCacheSection->UnlockMutex(); if ( !LoadHardwareData( handle ) ) { return NULL; } } else { #if defined( USE_HARDWARE_CACHE ) CheckData( pStudioData->m_HardwareDataCache, MDLCACHE_STUDIOHWDATA ); #endif m_pMeshCacheSection->UnlockMutex(); } // didn't load, don't return an empty pointer if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_NO_STUDIOMESH ) return NULL; return &pStudioData->m_HardwareData; } //----------------------------------------------------------------------------- // Task switch //----------------------------------------------------------------------------- void CMDLCache::ReleaseMaterialSystemObjects() { Assert( !m_bLostVideoMemory ); m_bLostVideoMemory = true; BreakFrameLock( false ); // Free all hardware data MDLHandle_t i = m_MDLDict.First(); while ( i != m_MDLDict.InvalidIndex() ) { UnloadHardwareData( i ); i = m_MDLDict.Next( i ); } RestoreFrameLock(); } void CMDLCache::RestoreMaterialSystemObjects( int nChangeFlags ) { Assert( m_bLostVideoMemory ); m_bLostVideoMemory = false; BreakFrameLock( false ); // Restore all hardware data MDLHandle_t i = m_MDLDict.First(); while ( i != m_MDLDict.InvalidIndex() ) { studiodata_t *pStudioData = m_MDLDict[i]; bool bIsMDLInMemory = GetCacheSection( MDLCACHE_STUDIOHDR )->IsPresent( pStudioData->m_MDLCache ); // If the vertex format changed, we have to free the data because we may be using different .vtx files. if ( nChangeFlags & MATERIAL_RESTORE_VERTEX_FORMAT_CHANGED ) { MdlCacheMsg( "MDLCache: Free studiohdr\n" ); MdlCacheMsg( "MDLCache: Free VVD\n" ); MdlCacheMsg( "MDLCache: Free VTX\n" ); // FIXME: Do we have to free m_MDLCache + m_VertexCache? // Certainly we have to free m_IndexCache, cause that's a dx-level specific vtx file. ClearAsync( i, MDLCACHE_STUDIOHWDATA, 0, true ); Flush( i, MDLCACHE_FLUSH_VERTEXES ); } // Only restore the hardware data of those studiohdrs which are currently in memory if ( bIsMDLInMemory ) { GetHardwareData( i ); } i = m_MDLDict.Next( i ); } RestoreFrameLock(); } void CMDLCache::MarkAsLoaded(MDLHandle_t handle) { if ( mod_lock_mdls_on_load.GetBool() ) { g_MDLCache.GetStudioHdr(handle); if ( !( m_MDLDict[handle]->m_nFlags & STUDIODATA_FLAGS_LOCKED_MDL ) ) { m_MDLDict[handle]->m_nFlags |= STUDIODATA_FLAGS_LOCKED_MDL; GetCacheSection( MDLCACHE_STUDIOHDR )->Lock( m_MDLDict[handle]->m_MDLCache ); } } } //----------------------------------------------------------------------------- // Callback for UpdateOrCreate utility function - swaps any studiomdl file type. //----------------------------------------------------------------------------- static bool MdlcacheCreateCallback( const char *pSourceName, const char *pTargetName, const char *pPathID, void *pHdr ) { // Missing studio files are permissible and not spewed as errors bool retval = false; CUtlBuffer sourceBuf; bool bOk = g_pFullFileSystem->ReadFile( pSourceName, NULL, sourceBuf ); if ( bOk ) { CUtlBuffer targetBuf; targetBuf.EnsureCapacity( sourceBuf.TellPut() + BYTESWAP_ALIGNMENT_PADDING ); int bytes = StudioByteSwap::ByteswapStudioFile( pTargetName, targetBuf.Base(), sourceBuf.Base(), sourceBuf.TellPut(), (studiohdr_t*)pHdr ); if ( bytes ) { // If the file was an .mdl, attempt to swap the .ani as well if ( Q_stristr( pSourceName, ".mdl" ) ) { char szANISourceName[ MAX_PATH ]; Q_StripExtension( pSourceName, szANISourceName, sizeof( szANISourceName ) ); Q_strncat( szANISourceName, ".ani", sizeof( szANISourceName ), COPY_ALL_CHARACTERS ); UpdateOrCreate( szANISourceName, NULL, 0, pPathID, MdlcacheCreateCallback, true, targetBuf.Base() ); } targetBuf.SeekPut( CUtlBuffer::SEEK_HEAD, bytes ); g_pFullFileSystem->WriteFile( pTargetName, pPathID, targetBuf ); retval = true; } else { Warning( "Failed to create %s\n", pTargetName ); } } return retval; } //----------------------------------------------------------------------------- // Calls utility function to create .360 version of a file. //----------------------------------------------------------------------------- int CMDLCache::UpdateOrCreate( studiohdr_t *pHdr, const char *pSourceName, char *pTargetName, int targetLen, const char *pPathID, bool bForce ) { return ::UpdateOrCreate( pSourceName, pTargetName, targetLen, pPathID, MdlcacheCreateCallback, bForce, pHdr ); } //----------------------------------------------------------------------------- // Purpose: Attempts to read a file native to the current platform //----------------------------------------------------------------------------- bool CMDLCache::ReadFileNative( char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes, MDLCacheDataType_t type ) { bool bOk = false; if ( IsX360() ) { // Read the 360 version char pX360Filename[ MAX_PATH ]; UpdateOrCreate( NULL, pFileName, pX360Filename, sizeof( pX360Filename ), pPath ); bOk = g_pFullFileSystem->ReadFile( pX360Filename, pPath, buf, nMaxBytes ); } else { // Read the PC version bOk = g_pFullFileSystem->ReadFile( pFileName, pPath, buf, nMaxBytes ); if( bOk && type == MDLCACHE_STUDIOHDR ) { studiohdr_t* pStudioHdr = ( studiohdr_t* ) buf.PeekGet(); if ( pStudioHdr->studiohdr2index == 0 ) { // We always need this now, so make room for it in the buffer now. int bufferContentsEnd = buf.TellMaxPut(); int maskBits = VALIGNOF( studiohdr2_t ) - 1; int offsetStudiohdr2 = ( bufferContentsEnd + maskBits ) & ~maskBits; int sizeIncrease = ( offsetStudiohdr2 - bufferContentsEnd ) + sizeof( studiohdr2_t ); buf.SeekPut( CUtlBuffer::SEEK_CURRENT, sizeIncrease ); // Re-get the pointer after resizing, because it has probably moved. pStudioHdr = ( studiohdr_t* ) buf.Base(); studiohdr2_t* pStudioHdr2 = ( studiohdr2_t* ) ( ( byte * ) pStudioHdr + offsetStudiohdr2 ); memset( pStudioHdr2, 0, sizeof( studiohdr2_t ) ); pStudioHdr2->flMaxEyeDeflection = 0.866f; // Matches studio.h. pStudioHdr->studiohdr2index = offsetStudiohdr2; // Also make sure the structure knows about the extra bytes // we've added so they get copied around. pStudioHdr->length += sizeIncrease; } } } return bOk; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- studiohdr_t *CMDLCache::UnserializeMDL( MDLHandle_t handle, void *pData, int nDataSize, bool bDataValid ) { if ( !bDataValid || nDataSize <= 0 || pData == NULL) { return NULL; } CTempAllocHelper pOriginalData; if ( IsX360() ) { if ( CLZMA::IsCompressed( (unsigned char *)pData ) ) { // mdl arrives compressed, decode and cache the results unsigned int nOriginalSize = CLZMA::GetActualSize( (unsigned char *)pData ); pOriginalData.Alloc( nOriginalSize ); unsigned int nOutputSize = CLZMA::Uncompress( (unsigned char *)pData, (unsigned char *)pOriginalData.Get() ); if ( nOutputSize != nOriginalSize ) { // decoder failure return NULL; } pData = pOriginalData.Get(); nDataSize = nOriginalSize; } } studiohdr_t *pStudioHdrIn = (studiohdr_t *)pData; if ( r_rootlod.GetInt() > 0 ) { // raw data is already setup for lod 0, override otherwise Studio_SetRootLOD( pStudioHdrIn, r_rootlod.GetInt() ); } // critical! store a back link to our data // this is fetched when re-establishing dependent cached data (vtx/vvd) pStudioHdrIn->SetVirtualModel( MDLHandleToVirtual( handle ) ); MdlCacheMsg( "MDLCache: Alloc studiohdr %s\n", GetModelName( handle ) ); // allocate cache space MemAlloc_PushAllocDbgInfo( "Models:StudioHdr", 0); studiohdr_t *pHdr = (studiohdr_t *)AllocData( MDLCACHE_STUDIOHDR, pStudioHdrIn->length ); MemAlloc_PopAllocDbgInfo(); if ( !pHdr ) return NULL; CacheData( &m_MDLDict[handle]->m_MDLCache, pHdr, pStudioHdrIn->length, GetModelName( handle ), MDLCACHE_STUDIOHDR, MakeCacheID( handle, MDLCACHE_STUDIOHDR) ); if ( mod_lock_mdls_on_load.GetBool() ) { GetCacheSection( MDLCACHE_STUDIOHDR )->Lock( m_MDLDict[handle]->m_MDLCache ); m_MDLDict[handle]->m_nFlags |= STUDIODATA_FLAGS_LOCKED_MDL; } // FIXME: Is there any way we can compute the size to load *before* loading in // and read directly into cache memory? It would be nice to reduce cache overhead here. // move the complete, relocatable model to the cache memcpy( pHdr, pStudioHdrIn, pStudioHdrIn->length ); // On first load, convert the flex deltas from fp16 to 16-bit fixed-point if ( (pHdr->flags & STUDIOHDR_FLAGS_FLEXES_CONVERTED) == 0 ) { ConvertFlexData( pHdr ); // Mark as converted so it only happens once pHdr->flags |= STUDIOHDR_FLAGS_FLEXES_CONVERTED; } if ( m_pCacheNotify ) { m_pCacheNotify->OnDataLoaded( MDLCACHE_STUDIOHDR, handle ); } return pHdr; } //----------------------------------------------------------------------------- // Attempts to load a MDL file, validates that it's ok. //----------------------------------------------------------------------------- bool CMDLCache::ReadMDLFile( MDLHandle_t handle, const char *pMDLFileName, CUtlBuffer &buf ) { VPROF( "CMDLCache::ReadMDLFile" ); char pFileName[ MAX_PATH ]; Q_strncpy( pFileName, pMDLFileName, sizeof( pFileName ) ); Q_FixSlashes( pFileName ); #ifdef POSIX Q_strlower( pFileName ); #endif MdlCacheMsg( "MDLCache: Load studiohdr %s\n", pFileName ); MEM_ALLOC_CREDIT(); bool bOk = ReadFileNative( pFileName, "GAME", buf, 0, MDLCACHE_STUDIOHDR ); if ( !bOk ) { DevWarning( "Failed to load %s!\n", pMDLFileName ); return false; } if ( IsX360() ) { if ( CLZMA::IsCompressed( (unsigned char *)buf.PeekGet() ) ) { // mdl arrives compressed, decode and cache the results unsigned int nOriginalSize = CLZMA::GetActualSize( (unsigned char *)buf.PeekGet() ); void *pOriginalData = malloc( nOriginalSize ); unsigned int nOutputSize = CLZMA::Uncompress( (unsigned char *)buf.PeekGet(), (unsigned char *)pOriginalData ); if ( nOutputSize != nOriginalSize ) { // decoder failure free( pOriginalData ); return false; } // replace caller's buffer buf.Purge(); buf.Put( pOriginalData, nOriginalSize ); free( pOriginalData ); } } if ( buf.Size() < sizeof(studiohdr_t) ) { DevWarning( "Empty model %s\n", pMDLFileName ); return false; } studiohdr_t *pStudioHdr = (studiohdr_t*)buf.PeekGet(); if ( !pStudioHdr ) { DevWarning( "Failed to read model %s from buffer!\n", pMDLFileName ); return false; } if ( pStudioHdr->id != IDSTUDIOHEADER ) { DevWarning( "Model %s not a .MDL format file!\n", pMDLFileName ); return false; } // critical! store a back link to our data // this is fetched when re-establishing dependent cached data (vtx/vvd) pStudioHdr->SetVirtualModel( MDLHandleToVirtual( handle ) ); // Make sure all dependent files are valid if ( !VerifyHeaders( pStudioHdr ) ) { DevWarning( "Model %s has mismatched .vvd + .vtx files!\n", pMDLFileName ); return false; } return true; } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- studiohdr_t *CMDLCache::LockStudioHdr( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) { return NULL; } CMDLCacheCriticalSection cacheCriticalSection( this ); studiohdr_t *pStdioHdr = GetStudioHdr( handle ); // @TODO (toml 9/12/2006) need this?: AddRef( handle ); if ( !pStdioHdr ) { return NULL; } GetCacheSection( MDLCACHE_STUDIOHDR )->Lock( m_MDLDict[handle]->m_MDLCache ); return pStdioHdr; } void CMDLCache::UnlockStudioHdr( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) { return; } CMDLCacheCriticalSection cacheCriticalSection( this ); studiohdr_t *pStdioHdr = GetStudioHdr( handle ); if ( pStdioHdr ) { GetCacheSection( MDLCACHE_STUDIOHDR )->Unlock( m_MDLDict[handle]->m_MDLCache ); } // @TODO (toml 9/12/2006) need this?: Release( handle ); } //----------------------------------------------------------------------------- // Loading the data in //----------------------------------------------------------------------------- studiohdr_t *CMDLCache::GetStudioHdr( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) return NULL; // Returning a pointer to data inside the cache when it's unlocked is just a bad idea. // It's technically legal, but the pointer can get invalidated if anything else looks at the cache. // Don't do that. // Assert( m_pModelCacheSection->IsFrameLocking() ); // Assert( m_pMeshCacheSection->IsFrameLocking() ); studiodata_t *pStudioData = m_MDLDict[handle]; if( !pStudioData ) return NULL; #if _DEBUG VPROF_INCREMENT_COUNTER( "GetStudioHdr", 1 ); #endif studiohdr_t *pHdr = (studiohdr_t*)CheckData( m_MDLDict[handle]->m_MDLCache, MDLCACHE_STUDIOHDR ); if ( !pHdr ) { m_MDLDict[handle]->m_MDLCache = NULL; CMDLCacheCriticalSection cacheCriticalSection( this ); // load the file const char *pModelName = GetActualModelName( handle ); if ( developer.GetInt() > 1 ) { DevMsg( "Loading %s\n", pModelName ); } // Load file to temporary space CUtlBuffer buf; if ( !ReadMDLFile( handle, pModelName, buf ) ) { bool bOk = false; if ( ( m_MDLDict[handle]->m_nFlags & STUDIODATA_ERROR_MODEL ) == 0 ) { buf.Clear(); // clear buffer for next file read m_MDLDict[handle]->m_nFlags |= STUDIODATA_ERROR_MODEL; bOk = ReadMDLFile( handle, ERROR_MODEL, buf ); } if ( !bOk ) { if (IsOSX()) { // rbarris wants this to go somewhere like the console.log prior to crashing, which is what the Error call will do next printf("\n ##### Model %s not found and %s couldn't be loaded", pModelName, ERROR_MODEL ); fflush( stdout ); } Error( "Model %s not found and %s couldn't be loaded", pModelName, ERROR_MODEL ); return NULL; } } // put it in the cache if ( ProcessDataIntoCache( handle, MDLCACHE_STUDIOHDR, 0, buf.Base(), buf.TellMaxPut(), true ) ) { pHdr = (studiohdr_t*)CheckData( m_MDLDict[handle]->m_MDLCache, MDLCACHE_STUDIOHDR ); } } return pHdr; } //----------------------------------------------------------------------------- // Gets/sets user data associated with the MDL //----------------------------------------------------------------------------- void CMDLCache::SetUserData( MDLHandle_t handle, void* pData ) { if ( handle == MDLHANDLE_INVALID ) return; m_MDLDict[handle]->m_pUserData = pData; } void *CMDLCache::GetUserData( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) return NULL; return m_MDLDict[handle]->m_pUserData; } //----------------------------------------------------------------------------- // Polls information about a particular mdl //----------------------------------------------------------------------------- bool CMDLCache::IsErrorModel( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) return false; return (m_MDLDict[handle]->m_nFlags & STUDIODATA_ERROR_MODEL) != 0; } //----------------------------------------------------------------------------- // Brings all data associated with an MDL into memory //----------------------------------------------------------------------------- void CMDLCache::TouchAllData( MDLHandle_t handle ) { studiohdr_t *pStudioHdr = GetStudioHdr( handle ); virtualmodel_t *pVModel = GetVirtualModel( handle ); if ( pVModel ) { // skip self, start at children // ensure all sub models are cached for ( int i=1; im_group.Count(); ++i ) { MDLHandle_t childHandle = VoidPtrToMDLHandle( pVModel->m_group[i].cache ); if ( childHandle != MDLHANDLE_INVALID ) { // FIXME: Should this be calling TouchAllData on the child? GetStudioHdr( childHandle ); } } } if ( !IsX360() ) { // cache the anims // Note that the animblocks start at 1!!! for ( int i=1; i< (int)pStudioHdr->numanimblocks; ++i ) { pStudioHdr->GetAnimBlock( i ); } } // cache the vertexes if ( pStudioHdr->numbodyparts ) { CacheVertexData( pStudioHdr ); GetHardwareData( handle ); } } //----------------------------------------------------------------------------- // Flushes all data //----------------------------------------------------------------------------- void CMDLCache::Flush( MDLCacheFlush_t nFlushFlags ) { // Free all MDLs that haven't been cleaned up MDLHandle_t i = m_MDLDict.First(); while ( i != m_MDLDict.InvalidIndex() ) { Flush( i, nFlushFlags ); i = m_MDLDict.Next( i ); } } //----------------------------------------------------------------------------- // Cache handlers //----------------------------------------------------------------------------- static const char *g_ppszTypes[] = { "studiohdr", // MDLCACHE_STUDIOHDR "studiohwdata", // MDLCACHE_STUDIOHWDATA "vcollide", // MDLCACHE_VCOLLIDE "animblock", // MDLCACHE_ANIMBLOCK "virtualmodel", // MDLCACHE_VIRTUALMODEL "vertexes", // MDLCACHE_VERTEXES }; bool CMDLCache::HandleCacheNotification( const DataCacheNotification_t ¬ification ) { switch ( notification.type ) { case DC_AGE_DISCARD: case DC_FLUSH_DISCARD: case DC_REMOVED: { MdlCacheMsg( "MDLCache: Data cache discard %s %s\n", g_ppszTypes[TypeFromCacheID( notification.clientId )], GetModelName( HandleFromCacheID( notification.clientId ) ) ); if ( (DataCacheClientID_t)(intp)notification.pItemData == notification.clientId || TypeFromCacheID(notification.clientId) != MDLCACHE_STUDIOHWDATA ) { Assert( notification.pItemData ); FreeData( TypeFromCacheID(notification.clientId), (void *)notification.pItemData ); } else { UnloadHardwareData( HandleFromCacheID( notification.clientId ), false ); } return true; } } return CDefaultDataCacheClient::HandleCacheNotification( notification ); } bool CMDLCache::GetItemName( DataCacheClientID_t clientId, const void *pItem, char *pDest, unsigned nMaxLen ) { if ( (DataCacheClientID_t)(uintp)pItem == clientId ) { return false; } MDLHandle_t handle = HandleFromCacheID( clientId ); MDLCacheDataType_t type = TypeFromCacheID( clientId ); Q_snprintf( pDest, nMaxLen, "%s - %s", g_ppszTypes[type], GetModelName( handle ) ); return false; } //----------------------------------------------------------------------------- // Flushes all data //----------------------------------------------------------------------------- void CMDLCache::BeginLock() { m_pModelCacheSection->BeginFrameLocking(); m_pMeshCacheSection->BeginFrameLocking(); } //----------------------------------------------------------------------------- // Flushes all data //----------------------------------------------------------------------------- void CMDLCache::EndLock() { m_pModelCacheSection->EndFrameLocking(); m_pMeshCacheSection->EndFrameLocking(); } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CMDLCache::BreakFrameLock( bool bModels, bool bMesh ) { if ( bModels ) { if ( m_pModelCacheSection->IsFrameLocking() ) { Assert( !m_nModelCacheFrameLocks ); m_nModelCacheFrameLocks = 0; do { m_nModelCacheFrameLocks++; } while ( m_pModelCacheSection->EndFrameLocking() ); } } if ( bMesh ) { if ( m_pMeshCacheSection->IsFrameLocking() ) { Assert( !m_nMeshCacheFrameLocks ); m_nMeshCacheFrameLocks = 0; do { m_nMeshCacheFrameLocks++; } while ( m_pMeshCacheSection->EndFrameLocking() ); } } } void CMDLCache::RestoreFrameLock() { while ( m_nModelCacheFrameLocks ) { m_pModelCacheSection->BeginFrameLocking(); m_nModelCacheFrameLocks--; } while ( m_nMeshCacheFrameLocks ) { m_pMeshCacheSection->BeginFrameLocking(); m_nMeshCacheFrameLocks--; } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- int *CMDLCache::GetFrameUnlockCounterPtrOLD() { return GetCacheSection( MDLCACHE_STUDIOHDR )->GetFrameUnlockCounterPtr(); } int *CMDLCache::GetFrameUnlockCounterPtr( MDLCacheDataType_t type ) { return GetCacheSection( type )->GetFrameUnlockCounterPtr(); } //----------------------------------------------------------------------------- // Completes all pending async operations //----------------------------------------------------------------------------- void CMDLCache::FinishPendingLoads() { if ( !ThreadInMainThread() ) { return; } AUTO_LOCK( m_AsyncMutex ); // finish just our known jobs intp iAsync = m_PendingAsyncs.Head(); while ( iAsync != m_PendingAsyncs.InvalidIndex() ) { AsyncInfo_t &info = m_PendingAsyncs[iAsync]; if ( info.hControl ) { g_pFullFileSystem->AsyncFinish( info.hControl, true ); } iAsync = m_PendingAsyncs.Next( iAsync ); } ProcessPendingAsyncs(); } //----------------------------------------------------------------------------- // Notify map load has started //----------------------------------------------------------------------------- void CMDLCache::BeginMapLoad() { BreakFrameLock(); studiodata_t *pStudioData; // Unlock prior map MDLs prior to load MDLHandle_t i = m_MDLDict.First(); while ( i != m_MDLDict.InvalidIndex() ) { pStudioData = m_MDLDict[i]; if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_LOCKED_MDL ) { GetCacheSection( MDLCACHE_STUDIOHDR )->Unlock( pStudioData->m_MDLCache ); pStudioData->m_nFlags &= ~STUDIODATA_FLAGS_LOCKED_MDL; } i = m_MDLDict.Next( i ); } } //----------------------------------------------------------------------------- // Notify map load is complete //----------------------------------------------------------------------------- void CMDLCache::EndMapLoad() { FinishPendingLoads(); // Remove all stray MDLs not referenced during load if ( mod_lock_mdls_on_load.GetBool() ) { studiodata_t *pStudioData; MDLHandle_t i = m_MDLDict.First(); while ( i != m_MDLDict.InvalidIndex() ) { pStudioData = m_MDLDict[i]; if ( !(pStudioData->m_nFlags & STUDIODATA_FLAGS_LOCKED_MDL) ) { Flush( i, MDLCACHE_FLUSH_STUDIOHDR ); } i = m_MDLDict.Next( i ); } } RestoreFrameLock(); } //----------------------------------------------------------------------------- // Is a particular part of the model data loaded? //----------------------------------------------------------------------------- bool CMDLCache::IsDataLoaded( MDLHandle_t handle, MDLCacheDataType_t type ) { if ( handle == MDLHANDLE_INVALID || !m_MDLDict.IsValidIndex( handle ) ) return false; studiodata_t *pData = m_MDLDict[ handle ]; switch( type ) { case MDLCACHE_STUDIOHDR: return GetCacheSection( MDLCACHE_STUDIOHDR )->IsPresent( pData->m_MDLCache ); case MDLCACHE_STUDIOHWDATA: return ( pData->m_nFlags & STUDIODATA_FLAGS_STUDIOMESH_LOADED ) != 0; case MDLCACHE_VCOLLIDE: return ( pData->m_nFlags & STUDIODATA_FLAGS_VCOLLISION_LOADED ) != 0; case MDLCACHE_ANIMBLOCK: { if ( !pData->m_pAnimBlock ) return false; for (int i = 0; i < pData->m_nAnimBlockCount; ++i ) { if ( !pData->m_pAnimBlock[i] ) return false; if ( !GetCacheSection( type )->IsPresent( pData->m_pAnimBlock[i] ) ) return false; } return true; } case MDLCACHE_VIRTUALMODEL: return ( pData->m_pVirtualModel != 0 ); case MDLCACHE_VERTEXES: return m_pMeshCacheSection->IsPresent( pData->m_VertexCache ); } return false; } //----------------------------------------------------------------------------- // Get the correct extension for our dx //----------------------------------------------------------------------------- const char *CMDLCache::GetVTXExtension() { if ( IsPC() ) { if ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 90 ) { return ".dx90.vtx"; } else if ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 80 ) { return ".dx80.vtx"; } else { return ".sw.vtx"; } } return ".dx90.vtx"; } //----------------------------------------------------------------------------- // Minimal presence and header validation, no data loads // Return true if successful, false otherwise. //----------------------------------------------------------------------------- bool CMDLCache::VerifyHeaders( studiohdr_t *pStudioHdr ) { VPROF( "CMDLCache::VerifyHeaders" ); if ( developer.GetInt() < 2 ) { return true; } // model has no vertex data if ( !pStudioHdr->numbodyparts ) { // valid return true; } char pFileName[ MAX_PATH ]; MDLHandle_t handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() ); MakeFilename( handle, ".vvd", pFileName, sizeof(pFileName) ); MdlCacheMsg("MDLCache: Load VVD (verify) %s\n", pFileName ); // vvd header only CUtlBuffer vvdHeader( 0, sizeof(vertexFileHeader_t) ); if ( !ReadFileNative( pFileName, "GAME", vvdHeader, sizeof(vertexFileHeader_t) ) ) { return false; } vertexFileHeader_t *pVertexHdr = (vertexFileHeader_t*)vvdHeader.PeekGet(); // check if (( pVertexHdr->id != MODEL_VERTEX_FILE_ID ) || ( pVertexHdr->version != MODEL_VERTEX_FILE_VERSION ) || ( pVertexHdr->checksum != pStudioHdr->checksum )) { return false; } // load the VTX file // use model name for correct path MakeFilename( handle, GetVTXExtension(), pFileName, sizeof(pFileName) ); MdlCacheMsg("MDLCache: Load VTX (verify) %s\n", pFileName ); // vtx header only CUtlBuffer vtxHeader( 0, sizeof(OptimizedModel::FileHeader_t) ); if ( !ReadFileNative( pFileName, "GAME", vtxHeader, sizeof(OptimizedModel::FileHeader_t) ) ) { return false; } // check OptimizedModel::FileHeader_t *pVtxHdr = (OptimizedModel::FileHeader_t*)vtxHeader.PeekGet(); if (( pVtxHdr->version != OPTIMIZED_MODEL_FILE_VERSION ) || ( pVtxHdr->checkSum != pStudioHdr->checksum )) { return false; } // valid return true; } //----------------------------------------------------------------------------- // Cache model's specified dynamic data //----------------------------------------------------------------------------- vertexFileHeader_t *CMDLCache::CacheVertexData( studiohdr_t *pStudioHdr ) { VPROF( "CMDLCache::CacheVertexData" ); vertexFileHeader_t *pVvdHdr; MDLHandle_t handle; Assert( pStudioHdr ); handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() ); Assert( handle != MDLHANDLE_INVALID ); pVvdHdr = (vertexFileHeader_t *)CheckData( m_MDLDict[handle]->m_VertexCache, MDLCACHE_VERTEXES ); if ( pVvdHdr ) { return pVvdHdr; } m_MDLDict[handle]->m_VertexCache = NULL; return LoadVertexData( pStudioHdr ); } //----------------------------------------------------------------------------- // Start an async transfer //----------------------------------------------------------------------------- FSAsyncStatus_t CMDLCache::LoadData( const char *pszFilename, const char *pszPathID, void *pDest, int nBytes, int nOffset, bool bAsync, FSAsyncControl_t *pControl ) { if ( !*pControl ) { if ( IsX360() && g_pQueuedLoader->IsMapLoading() ) { DevWarning( "CMDLCache: Non-Optimal loading path for %s\n", pszFilename ); } FileAsyncRequest_t asyncRequest; asyncRequest.pszFilename = pszFilename; asyncRequest.pszPathID = pszPathID; asyncRequest.pData = pDest; asyncRequest.nBytes = nBytes; asyncRequest.nOffset = nOffset; if ( !pDest ) { asyncRequest.flags = FSASYNC_FLAGS_ALLOCNOFREE; } if ( !bAsync ) { asyncRequest.flags |= FSASYNC_FLAGS_SYNC; } MEM_ALLOC_CREDIT(); return g_pFullFileSystem->AsyncRead( asyncRequest, pControl ); } return FSASYNC_ERR_FAILURE; } //----------------------------------------------------------------------------- // Determine the maximum number of 'real' bone influences used by any vertex in a model // (100% binding to bone zero doesn't count) //----------------------------------------------------------------------------- int ComputeMaxRealBoneInfluences( vertexFileHeader_t * vertexFile, int lod ) { const mstudiovertex_t * verts = vertexFile->GetVertexData(); int numVerts = vertexFile->numLODVertexes[ lod ]; Assert(verts); int maxWeights = 0; for (int i = 0;i < numVerts;i++) { if ( verts[i].m_BoneWeights.numbones > 0 ) { int numWeights = 0; for (int j = 0;j < MAX_NUM_BONES_PER_VERT;j++) { if ( verts[i].m_BoneWeights.weight[j] > 0 ) numWeights = j + 1; } if ( ( numWeights == 1 ) && ( verts[i].m_BoneWeights.bone[0] == 0 ) ) { // 100% binding to first bone - not really skinned (the first bone is just the model transform) numWeights = 0; } maxWeights = max( numWeights, maxWeights ); } } return maxWeights; } //----------------------------------------------------------------------------- // Generate thin vertices (containing just the data needed to do model decals) //----------------------------------------------------------------------------- vertexFileHeader_t * CMDLCache::CreateThinVertexes( vertexFileHeader_t * originalData, const studiohdr_t * pStudioHdr, int * cacheLength ) { int rootLod = min( (int)pStudioHdr->rootLOD, ( originalData->numLODs - 1 ) ); int numVerts = originalData->numLODVertexes[ rootLod ] + 1; // Add 1 vert to support prefetch during array access int numBoneInfluences = ComputeMaxRealBoneInfluences( originalData, rootLod ); // Only store (N-1) weights (all N weights sum to 1, so we can re-compute the Nth weight later) int numStoredWeights = max( 0, ( numBoneInfluences - 1 ) ); int vertexSize = 2*sizeof( Vector ) + numBoneInfluences*sizeof( unsigned char ) + numStoredWeights*sizeof( float ); *cacheLength = sizeof( vertexFileHeader_t ) + sizeof( thinModelVertices_t ) + numVerts*vertexSize; // Allocate cache space for the thin data MemAlloc_PushAllocDbgInfo( "Models:Vertex data", 0); vertexFileHeader_t * pNewVvdHdr = (vertexFileHeader_t *)AllocData( MDLCACHE_VERTEXES, *cacheLength ); MemAlloc_PopAllocDbgInfo(); Assert( pNewVvdHdr ); if ( pNewVvdHdr ) { // Copy the header and set it up to hold thin vertex data memcpy( (void *)pNewVvdHdr, (void *)originalData, sizeof( vertexFileHeader_t ) ); pNewVvdHdr->id = MODEL_VERTEX_FILE_THIN_ID; pNewVvdHdr->numFixups = 0; pNewVvdHdr->fixupTableStart = 0; pNewVvdHdr->tangentDataStart = 0; pNewVvdHdr->vertexDataStart = sizeof( vertexFileHeader_t ); // Set up the thin vertex structure thinModelVertices_t * pNewThinVerts = (thinModelVertices_t *)( pNewVvdHdr + 1 ); Vector * pPositions = (Vector *)( pNewThinVerts + 1 ); float * pBoneWeights = (float *)( pPositions + numVerts ); // Alloc the (short) normals here to avoid mis-aligning the float data unsigned short * pNormals = (unsigned short *)( pBoneWeights + numVerts*numStoredWeights ); // Alloc the (char) indices here to avoid mis-aligning the float/short data char * pBoneIndices = (char *)( pNormals + numVerts ); if ( numStoredWeights == 0 ) pBoneWeights = NULL; if ( numBoneInfluences == 0 ) pBoneIndices = NULL; pNewThinVerts->Init( numBoneInfluences, pPositions, pNormals, pBoneWeights, pBoneIndices ); // Copy over the original data const mstudiovertex_t * srcVertexData = originalData->GetVertexData(); for ( int i = 0; i < numVerts; i++ ) { pNewThinVerts->SetPosition( i, srcVertexData[ i ].m_vecPosition ); pNewThinVerts->SetNormal( i, srcVertexData[ i ].m_vecNormal ); if ( numBoneInfluences > 0 ) { mstudioboneweight_t boneWeights; boneWeights.numbones = numBoneInfluences; for ( int j = 0; j < numStoredWeights; j++ ) { boneWeights.weight[ j ] = srcVertexData[ i ].m_BoneWeights.weight[ j ]; } for ( int j = 0; j < numBoneInfluences; j++ ) { boneWeights.bone[ j ] = srcVertexData[ i ].m_BoneWeights.bone[ j ]; } pNewThinVerts->SetBoneWeights( i, boneWeights ); } } } return pNewVvdHdr; } //----------------------------------------------------------------------------- // Process the provided raw data into the cache. Distributes to low level // unserialization or build methods. //----------------------------------------------------------------------------- bool CMDLCache::ProcessDataIntoCache( MDLHandle_t handle, MDLCacheDataType_t type, int iAnimBlock, void *pData, int nDataSize, bool bDataValid ) { studiohdr_t *pStudioHdrCurrent = NULL; if ( type != MDLCACHE_STUDIOHDR ) { // can only get the studiohdr once the header has been processed successfully into the cache // causes a ProcessDataIntoCache() with the studiohdr data pStudioHdrCurrent = GetStudioHdr( handle ); if ( !pStudioHdrCurrent ) { return false; } } studiodata_t *pStudioDataCurrent = m_MDLDict[handle]; if ( !pStudioDataCurrent ) { return false; } switch ( type ) { case MDLCACHE_STUDIOHDR: { pStudioHdrCurrent = UnserializeMDL( handle, pData, nDataSize, bDataValid ); if ( !pStudioHdrCurrent ) { return false; } if (!Studio_ConvertStudioHdrToNewVersion( pStudioHdrCurrent )) { Warning( "MDLCache: %s needs to be recompiled\n", pStudioHdrCurrent->pszName() ); } if ( pStudioHdrCurrent->numincludemodels == 0 ) { // perf optimization, calculate once and cache off the autoplay sequences int nCount = pStudioHdrCurrent->CountAutoplaySequences(); if ( nCount ) { AllocateAutoplaySequences( m_MDLDict[handle], nCount ); pStudioHdrCurrent->CopyAutoplaySequences( m_MDLDict[handle]->m_pAutoplaySequenceList, nCount ); } } // Load animations UnserializeAllVirtualModelsAndAnimBlocks( handle ); break; } case MDLCACHE_VERTEXES: { if ( bDataValid ) { BuildAndCacheVertexData( pStudioHdrCurrent, (vertexFileHeader_t *)pData ); } else { pStudioDataCurrent->m_nFlags |= STUDIODATA_FLAGS_NO_VERTEX_DATA; if ( pStudioHdrCurrent->numbodyparts ) { // expected data not valid Warning( "MDLCache: Failed load of .VVD data for %s\n", pStudioHdrCurrent->pszName() ); return false; } } break; } case MDLCACHE_STUDIOHWDATA: { if ( bDataValid ) { BuildHardwareData( handle, pStudioDataCurrent, pStudioHdrCurrent, (OptimizedModel::FileHeader_t *)pData ); } else { pStudioDataCurrent->m_nFlags |= STUDIODATA_FLAGS_NO_STUDIOMESH; if ( pStudioHdrCurrent->numbodyparts ) { // expected data not valid Warning( "MDLCache: Failed load of .VTX data for %s\n", pStudioHdrCurrent->pszName() ); return false; } } m_pMeshCacheSection->Unlock( pStudioDataCurrent->m_VertexCache ); m_pMeshCacheSection->Age( pStudioDataCurrent->m_VertexCache ); // FIXME: thin VVD data on PC too (have to address alt-tab, various DX8/DX7/debug software paths in studiorender, tools, etc) static bool bCompressedVVDs = CommandLine()->CheckParm( "-no_compressed_vvds" ) == NULL; if ( IsX360() && !( pStudioDataCurrent->m_nFlags & STUDIODATA_FLAGS_NO_STUDIOMESH ) && bCompressedVVDs ) { // Replace the cached vertex data with a thin version (used for model decals). // Flexed meshes require the fat data to remain, for CPU mesh anim. if ( pStudioHdrCurrent->numflexdesc == 0 ) { vertexFileHeader_t *originalVertexData = GetVertexData( handle ); Assert( originalVertexData ); if ( originalVertexData ) { int thinVertexDataSize = 0; vertexFileHeader_t *thinVertexData = CreateThinVertexes( originalVertexData, pStudioHdrCurrent, &thinVertexDataSize ); Assert( thinVertexData && ( thinVertexDataSize > 0 ) ); if ( thinVertexData && ( thinVertexDataSize > 0 ) ) { // Remove the original cache entry (and free it) Flush( handle, MDLCACHE_FLUSH_VERTEXES | MDLCACHE_FLUSH_IGNORELOCK ); // Add the new one CacheData( &pStudioDataCurrent->m_VertexCache, thinVertexData, thinVertexDataSize, pStudioHdrCurrent->pszName(), MDLCACHE_VERTEXES, MakeCacheID( handle, MDLCACHE_VERTEXES) ); } } } } break; } case MDLCACHE_ANIMBLOCK: { MEM_ALLOC_CREDIT_( __FILE__ ": Anim Blocks" ); if ( bDataValid ) { MdlCacheMsg( "MDLCache: Finish load anim block %s (block %i)\n", pStudioHdrCurrent->pszName(), iAnimBlock ); char pCacheName[MAX_PATH]; Q_snprintf( pCacheName, MAX_PATH, "%s (block %i)", pStudioHdrCurrent->pszName(), iAnimBlock ); if ( IsX360() ) { if ( CLZMA::IsCompressed( (unsigned char *)pData ) ) { // anim block arrives compressed, decode and cache the results unsigned int nOriginalSize = CLZMA::GetActualSize( (unsigned char *)pData ); // get a "fake" (not really aligned) optimal read buffer, as expected by the free logic void *pOriginalData = g_pFullFileSystem->AllocOptimalReadBuffer( FILESYSTEM_INVALID_HANDLE, nOriginalSize, 0 ); unsigned int nOutputSize = CLZMA::Uncompress( (unsigned char *)pData, (unsigned char *)pOriginalData ); if ( nOutputSize != nOriginalSize ) { // decoder failure g_pFullFileSystem->FreeOptimalReadBuffer( pOriginalData ); return false; } // input i/o buffer is now unused g_pFullFileSystem->FreeOptimalReadBuffer( pData ); // datacache will now own the data pData = pOriginalData; nDataSize = nOriginalSize; } } CacheData( &pStudioDataCurrent->m_pAnimBlock[iAnimBlock], pData, nDataSize, pCacheName, MDLCACHE_ANIMBLOCK, MakeCacheID( handle, MDLCACHE_ANIMBLOCK) ); } else { MdlCacheMsg( "MDLCache: Failed load anim block %s (block %i)\n", pStudioHdrCurrent->pszName(), iAnimBlock ); if ( pStudioDataCurrent->m_pAnimBlock ) { pStudioDataCurrent->m_pAnimBlock[iAnimBlock] = NULL; } return false; } break; } case MDLCACHE_VCOLLIDE: { // always marked as loaded, vcollides are not present for every model pStudioDataCurrent->m_nFlags |= STUDIODATA_FLAGS_VCOLLISION_LOADED; if ( bDataValid ) { MdlCacheMsg( "MDLCache: Finish load vcollide for %s\n", pStudioHdrCurrent->pszName() ); CTempAllocHelper pOriginalData; if ( IsX360() ) { if ( CLZMA::IsCompressed( (unsigned char *)pData ) ) { // phy arrives compressed, decode and cache the results unsigned int nOriginalSize = CLZMA::GetActualSize( (unsigned char *)pData ); pOriginalData.Alloc( nOriginalSize ); unsigned int nOutputSize = CLZMA::Uncompress( (unsigned char *)pData, (unsigned char *)pOriginalData.Get() ); if ( nOutputSize != nOriginalSize ) { // decoder failure return NULL; } pData = pOriginalData.Get(); nDataSize = nOriginalSize; } } CUtlBuffer buf( pData, nDataSize, CUtlBuffer::READ_ONLY ); buf.SeekPut( CUtlBuffer::SEEK_HEAD, nDataSize ); phyheader_t header; buf.Get( &header, sizeof( phyheader_t ) ); if ( ( header.size == sizeof( header ) ) && header.solidCount > 0 ) { int nBufSize = buf.TellMaxPut() - buf.TellGet(); vcollide_t *pCollide = &pStudioDataCurrent->m_VCollisionData; g_pPhysicsCollision->VCollideLoad( pCollide, header.solidCount, (const char*)buf.PeekGet(), nBufSize ); if ( m_pCacheNotify ) { m_pCacheNotify->OnDataLoaded( MDLCACHE_VCOLLIDE, handle ); } } } else { MdlCacheWarning( "MDLCache: Failed load of .PHY data for %s\n", pStudioHdrCurrent->pszName() ); return false; } break; } default: Assert( 0 ); } // success return true; } //----------------------------------------------------------------------------- // Returns: // <0: indeterminate at this time // =0: pending // >0: completed //----------------------------------------------------------------------------- int CMDLCache::ProcessPendingAsync( intp iAsync ) { if ( !ThreadInMainThread() ) { return -1; } ASSERT_NO_REENTRY(); void *pData = NULL; int nBytesRead = 0; AsyncInfo_t *pInfo; { AUTO_LOCK( m_AsyncMutex ); pInfo = &m_PendingAsyncs[iAsync]; } Assert( pInfo->hControl ); FSAsyncStatus_t status = g_pFullFileSystem->AsyncGetResult( pInfo->hControl, &pData, &nBytesRead ); if ( status == FSASYNC_STATUS_PENDING ) { return 0; } AsyncInfo_t info = *pInfo; pInfo = &info; ClearAsync( pInfo->hModel, pInfo->type, pInfo->iAnimBlock ); switch ( pInfo->type ) { case MDLCACHE_VERTEXES: case MDLCACHE_STUDIOHWDATA: case MDLCACHE_VCOLLIDE: { ProcessDataIntoCache( pInfo->hModel, pInfo->type, 0, pData, nBytesRead, status == FSASYNC_OK ); g_pFullFileSystem->FreeOptimalReadBuffer( pData ); break; } case MDLCACHE_ANIMBLOCK: { // cache assumes ownership of valid async'd data if ( !ProcessDataIntoCache( pInfo->hModel, MDLCACHE_ANIMBLOCK, pInfo->iAnimBlock, pData, nBytesRead, status == FSASYNC_OK ) ) { g_pFullFileSystem->FreeOptimalReadBuffer( pData ); } break; } default: Assert( 0 ); } return 1; } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CMDLCache::ProcessPendingAsyncs( MDLCacheDataType_t type ) { if ( !ThreadInMainThread() ) { return; } if ( !m_PendingAsyncs.Count() ) { return; } static bool bReentering; if ( bReentering ) { return; } bReentering = true; AUTO_LOCK( m_AsyncMutex ); // Process all of the completed loads that were requested before a new one. This ensures two // things -- the LRU is in correct order, and it catches precached items lurking // in the async queue that have only been requested once (thus aren't being cached // and might lurk forever, e.g., wood gibs in the citadel) intp current = m_PendingAsyncs.Head(); while ( current != m_PendingAsyncs.InvalidIndex() ) { intp next = m_PendingAsyncs.Next( current ); if ( type == MDLCACHE_NONE || m_PendingAsyncs[current].type == type ) { // process, also removes from list if ( ProcessPendingAsync( current ) <= 0 ) { // indeterminate or pending break; } } current = next; } bReentering = false; } //----------------------------------------------------------------------------- // Cache model's specified dynamic data //----------------------------------------------------------------------------- bool CMDLCache::ClearAsync( MDLHandle_t handle, MDLCacheDataType_t type, int iAnimBlock, bool bAbort ) { intp iAsyncInfo = GetAsyncInfoIndex( handle, type, iAnimBlock ); if ( iAsyncInfo != NO_ASYNC ) { AsyncInfo_t *pInfo; { AUTO_LOCK( m_AsyncMutex ); pInfo = &m_PendingAsyncs[iAsyncInfo]; } if ( pInfo->hControl ) { if ( bAbort ) { g_pFullFileSystem->AsyncAbort( pInfo->hControl ); void *pData; int ignored; if ( g_pFullFileSystem->AsyncGetResult( pInfo->hControl, &pData, &ignored ) == FSASYNC_OK ) { g_pFullFileSystem->FreeOptimalReadBuffer( pData ); } } g_pFullFileSystem->AsyncRelease( pInfo->hControl ); pInfo->hControl = NULL; } SetAsyncInfoIndex( handle, type, iAnimBlock, NO_ASYNC ); { AUTO_LOCK( m_AsyncMutex ); m_PendingAsyncs.Remove( iAsyncInfo ); } return true; } return false; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CMDLCache::GetAsyncLoad( MDLCacheDataType_t type ) { switch ( type ) { case MDLCACHE_STUDIOHDR: return false; case MDLCACHE_STUDIOHWDATA: return mod_load_mesh_async.GetBool(); case MDLCACHE_VCOLLIDE: return mod_load_vcollide_async.GetBool(); case MDLCACHE_ANIMBLOCK: return mod_load_anims_async.GetBool(); case MDLCACHE_VIRTUALMODEL: return false; case MDLCACHE_VERTEXES: return mod_load_mesh_async.GetBool(); } return false; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- bool CMDLCache::SetAsyncLoad( MDLCacheDataType_t type, bool bAsync ) { bool bRetVal = false; switch ( type ) { case MDLCACHE_STUDIOHDR: break; case MDLCACHE_STUDIOHWDATA: bRetVal = mod_load_mesh_async.GetBool(); mod_load_mesh_async.SetValue( bAsync ); break; case MDLCACHE_VCOLLIDE: bRetVal = mod_load_vcollide_async.GetBool(); mod_load_vcollide_async.SetValue( bAsync ); break; case MDLCACHE_ANIMBLOCK: bRetVal = mod_load_anims_async.GetBool(); mod_load_anims_async.SetValue( bAsync ); break; case MDLCACHE_VIRTUALMODEL: return false; break; case MDLCACHE_VERTEXES: bRetVal = mod_load_mesh_async.GetBool(); mod_load_mesh_async.SetValue( bAsync ); break; } return bRetVal; } //----------------------------------------------------------------------------- // Cache model's specified dynamic data //----------------------------------------------------------------------------- vertexFileHeader_t *CMDLCache::BuildAndCacheVertexData( studiohdr_t *pStudioHdr, vertexFileHeader_t *pRawVvdHdr ) { MDLHandle_t handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() ); vertexFileHeader_t *pVvdHdr; MdlCacheMsg( "MDLCache: Load VVD for %s\n", pStudioHdr->pszName() ); Assert( pRawVvdHdr ); // check header if ( pRawVvdHdr->id != MODEL_VERTEX_FILE_ID ) { Warning( "Error Vertex File for '%s' id %d should be %d\n", pStudioHdr->pszName(), pRawVvdHdr->id, MODEL_VERTEX_FILE_ID ); return NULL; } if ( pRawVvdHdr->version != MODEL_VERTEX_FILE_VERSION ) { Warning( "Error Vertex File for '%s' version %d should be %d\n", pStudioHdr->pszName(), pRawVvdHdr->version, MODEL_VERTEX_FILE_VERSION ); return NULL; } if ( pRawVvdHdr->checksum != pStudioHdr->checksum ) { Warning( "Error Vertex File for '%s' checksum %d should be %d\n", pStudioHdr->pszName(), pRawVvdHdr->checksum, pStudioHdr->checksum ); return NULL; } Assert( pRawVvdHdr->numLODs ); if ( !pRawVvdHdr->numLODs ) { return NULL; } CTempAllocHelper pOriginalData; if ( IsX360() ) { unsigned char *pInput = (unsigned char *)pRawVvdHdr + sizeof( vertexFileHeader_t ); if ( CLZMA::IsCompressed( pInput ) ) { // vvd arrives compressed, decode and cache the results unsigned int nOriginalSize = CLZMA::GetActualSize( pInput ); pOriginalData.Alloc( sizeof( vertexFileHeader_t ) + nOriginalSize ); V_memcpy( pOriginalData.Get(), pRawVvdHdr, sizeof( vertexFileHeader_t ) ); unsigned int nOutputSize = CLZMA::Uncompress( pInput, sizeof( vertexFileHeader_t ) + (unsigned char *)pOriginalData.Get() ); if ( nOutputSize != nOriginalSize ) { // decoder failure return NULL; } pRawVvdHdr = (vertexFileHeader_t *)pOriginalData.Get(); } } bool bNeedsTangentS = IsX360() || (g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 80); int rootLOD = min( (int)pStudioHdr->rootLOD, pRawVvdHdr->numLODs - 1 ); // determine final cache footprint, possibly truncated due to lod int cacheLength = Studio_VertexDataSize( pRawVvdHdr, rootLOD, bNeedsTangentS ); MdlCacheMsg("MDLCache: Alloc VVD %s\n", GetModelName( handle ) ); // allocate cache space MemAlloc_PushAllocDbgInfo( "Models:Vertex data", 0); pVvdHdr = (vertexFileHeader_t *)AllocData( MDLCACHE_VERTEXES, cacheLength ); MemAlloc_PopAllocDbgInfo(); GetCacheSection( MDLCACHE_VERTEXES )->BeginFrameLocking(); CacheData( &m_MDLDict[handle]->m_VertexCache, pVvdHdr, cacheLength, pStudioHdr->pszName(), MDLCACHE_VERTEXES, MakeCacheID( handle, MDLCACHE_VERTEXES) ); // expected 32 byte alignment Assert( ((int64)pVvdHdr & 0x1F) == 0 ); // load minimum vertexes and fixup Studio_LoadVertexes( pRawVvdHdr, pVvdHdr, rootLOD, bNeedsTangentS ); GetCacheSection( MDLCACHE_VERTEXES )->EndFrameLocking(); return pVvdHdr; } //----------------------------------------------------------------------------- // Load and cache model's specified dynamic data //----------------------------------------------------------------------------- vertexFileHeader_t *CMDLCache::LoadVertexData( studiohdr_t *pStudioHdr ) { char pFileName[MAX_PATH]; MDLHandle_t handle; Assert( pStudioHdr ); handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() ); Assert( !m_MDLDict[handle]->m_VertexCache ); studiodata_t *pStudioData = m_MDLDict[handle]; if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_NO_VERTEX_DATA ) { return NULL; } intp iAsync = GetAsyncInfoIndex( handle, MDLCACHE_VERTEXES ); if ( iAsync == NO_ASYNC ) { // load the VVD file // use model name for correct path MakeFilename( handle, ".vvd", pFileName, sizeof(pFileName) ); if ( IsX360() ) { char pX360Filename[MAX_PATH]; UpdateOrCreate( pStudioHdr, pFileName, pX360Filename, sizeof( pX360Filename ), "GAME" ); Q_strncpy( pFileName, pX360Filename, sizeof(pX360Filename) ); } MdlCacheMsg( "MDLCache: Begin load VVD %s\n", pFileName ); AsyncInfo_t info; if ( IsDebug() ) { memset( &info, 0xdd, sizeof( AsyncInfo_t ) ); } info.hModel = handle; info.type = MDLCACHE_VERTEXES; info.iAnimBlock = 0; info.hControl = NULL; LoadData( pFileName, "GAME", mod_load_mesh_async.GetBool(), &info.hControl ); { AUTO_LOCK( m_AsyncMutex ); iAsync = SetAsyncInfoIndex( handle, MDLCACHE_VERTEXES, m_PendingAsyncs.AddToTail( info ) ); } } ProcessPendingAsync( iAsync ); return (vertexFileHeader_t *)CheckData( m_MDLDict[handle]->m_VertexCache, MDLCACHE_VERTEXES ); } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- vertexFileHeader_t *CMDLCache::GetVertexData( MDLHandle_t handle ) { if ( mod_test_not_available.GetBool() ) return NULL; if ( mod_test_verts_not_available.GetBool() ) return NULL; return CacheVertexData( GetStudioHdr( handle ) ); } //----------------------------------------------------------------------------- // Allocates a cacheable item //----------------------------------------------------------------------------- void *CMDLCache::AllocData( MDLCacheDataType_t type, int size ) { void *pData = _aligned_malloc( size, 32 ); if ( !pData ) { Error( "CMDLCache:: Out of memory" ); return NULL; } return pData; } //----------------------------------------------------------------------------- // Caches an item //----------------------------------------------------------------------------- void CMDLCache::CacheData( DataCacheHandle_t *c, void *pData, int size, const char *name, MDLCacheDataType_t type, DataCacheClientID_t id ) { if ( !pData ) { return; } if ( id == (DataCacheClientID_t)-1 ) id = (DataCacheClientID_t)(intp)pData; GetCacheSection( type )->Add(id, pData, size, c ); } //----------------------------------------------------------------------------- // returns the cached data, and moves to the head of the LRU list // if present, otherwise returns NULL //----------------------------------------------------------------------------- void *CMDLCache::CheckData( DataCacheHandle_t c, MDLCacheDataType_t type ) { return GetCacheSection( type )->Get( c, true ); } //----------------------------------------------------------------------------- // returns the cached data, if present, otherwise returns NULL //----------------------------------------------------------------------------- void *CMDLCache::CheckDataNoTouch( DataCacheHandle_t c, MDLCacheDataType_t type ) { return GetCacheSection( type )->GetNoTouch( c, true ); } //----------------------------------------------------------------------------- // Frees a cache item //----------------------------------------------------------------------------- void CMDLCache::UncacheData( DataCacheHandle_t c, MDLCacheDataType_t type, bool bLockedOk ) { if ( c == DC_INVALID_HANDLE ) return; if ( !GetCacheSection( type )->IsPresent( c ) ) return; if ( GetCacheSection( type )->BreakLock( c ) && !bLockedOk ) { DevMsg( "Warning: freed a locked resource\n" ); Assert( 0 ); } const void *pItemData; GetCacheSection( type )->Remove( c, &pItemData ); FreeData( type, (void *)pItemData ); } //----------------------------------------------------------------------------- // Frees memory for an item //----------------------------------------------------------------------------- void CMDLCache::FreeData( MDLCacheDataType_t type, void *pData ) { if ( type != MDLCACHE_ANIMBLOCK ) { _aligned_free( (void *)pData ); } else { g_pFullFileSystem->FreeOptimalReadBuffer( pData ); } } void CMDLCache::InitPreloadData( bool rebuild ) { } void CMDLCache::ShutdownPreloadData() { } //----------------------------------------------------------------------------- // Work function for processing a model delivered by the queued loader. // ProcessDataIntoCache() is invoked for each MDL datum. //----------------------------------------------------------------------------- void CMDLCache::ProcessQueuedData( ModelParts_t *pModelParts, bool bHeaderOnly ) { void *pData; int nSize; // the studiohdr is critical, ensure it's setup as expected MDLHandle_t handle = pModelParts->hMDL; studiohdr_t *pStudioHdr = NULL; if ( !pModelParts->bHeaderLoaded && ( pModelParts->nLoadedParts & ( 1 << ModelParts_t::BUFFER_MDL ) ) ) { DEBUG_SCOPE_TIMER(mdl); pData = pModelParts->Buffers[ModelParts_t::BUFFER_MDL].Base(); nSize = pModelParts->Buffers[ModelParts_t::BUFFER_MDL].TellMaxPut(); ProcessDataIntoCache( handle, MDLCACHE_STUDIOHDR, 0, pData, nSize, nSize != 0 ); LockStudioHdr( handle ); g_pFullFileSystem->FreeOptimalReadBuffer( pData ); pModelParts->bHeaderLoaded = true; } if ( bHeaderOnly ) { return; } bool bAbort = false; pStudioHdr = (studiohdr_t *)CheckDataNoTouch( m_MDLDict[handle]->m_MDLCache, MDLCACHE_STUDIOHDR ); if ( !pStudioHdr ) { // The header is expected to be loaded and locked, everything depends on it! // but if the async read fails, we might not have it //Assert( 0 ); DevWarning( "CMDLCache:: Error MDLCACHE_STUDIOHDR not present for '%s'\n", GetModelName( handle ) ); // cannot unravel any of this model's dependant data, abort any further processing bAbort = true; } if ( pModelParts->nLoadedParts & ( 1 << ModelParts_t::BUFFER_PHY ) ) { DEBUG_SCOPE_TIMER(phy); // regardless of error, call job callback so caller can do cleanup of their context pData = pModelParts->Buffers[ModelParts_t::BUFFER_PHY].Base(); nSize = bAbort ? 0 : pModelParts->Buffers[ModelParts_t::BUFFER_PHY].TellMaxPut(); ProcessDataIntoCache( handle, MDLCACHE_VCOLLIDE, 0, pData, nSize, nSize != 0 ); g_pFullFileSystem->FreeOptimalReadBuffer( pData ); } // vvd vertexes before vtx if ( pModelParts->nLoadedParts & ( 1 << ModelParts_t::BUFFER_VVD ) ) { DEBUG_SCOPE_TIMER(vvd); pData = pModelParts->Buffers[ModelParts_t::BUFFER_VVD].Base(); nSize = bAbort ? 0 : pModelParts->Buffers[ModelParts_t::BUFFER_VVD].TellMaxPut(); ProcessDataIntoCache( handle, MDLCACHE_VERTEXES, 0, pData, nSize, nSize != 0 ); g_pFullFileSystem->FreeOptimalReadBuffer( pData ); } // can construct meshes after vvd and vtx vertexes arrive if ( pModelParts->nLoadedParts & ( 1 << ModelParts_t::BUFFER_VTX ) ) { DEBUG_SCOPE_TIMER(vtx); pData = pModelParts->Buffers[ModelParts_t::BUFFER_VTX].Base(); nSize = bAbort ? 0 : pModelParts->Buffers[ModelParts_t::BUFFER_VTX].TellMaxPut(); // ProcessDataIntoCache() will do an unlock, so lock studiodata_t *pStudioData = m_MDLDict[handle]; GetCacheSection( MDLCACHE_STUDIOHWDATA )->Lock( pStudioData->m_VertexCache ); { // constructing the static meshes isn't thread safe AUTO_LOCK( m_QueuedLoadingMutex ); ProcessDataIntoCache( handle, MDLCACHE_STUDIOHWDATA, 0, pData, nSize, nSize != 0 ); } g_pFullFileSystem->FreeOptimalReadBuffer( pData ); } UnlockStudioHdr( handle ); delete pModelParts; } //----------------------------------------------------------------------------- // Journals each of the incoming MDL components until all arrive (or error). // Not all components exist, but that information is not known at job submission. //----------------------------------------------------------------------------- void CMDLCache::QueuedLoaderCallback_MDL( void *pContext, void *pContext2, const void *pData, int nSize, LoaderError_t loaderError ) { // validity is denoted by a nonzero buffer nSize = ( loaderError == LOADERERROR_NONE ) ? nSize : 0; // journal each incoming buffer ModelParts_t *pModelParts = (ModelParts_t *)pContext; ModelParts_t::BufferType_t bufferType = static_cast< ModelParts_t::BufferType_t >((intp)pContext2); pModelParts->Buffers[bufferType].SetExternalBuffer( (void *)pData, nSize, nSize, CUtlBuffer::READ_ONLY ); pModelParts->nLoadedParts += (1 << bufferType); // wait for all components if ( pModelParts->DoFinalProcessing() ) { if ( !IsPC() ) { // now have all components, process the raw data into the cache g_MDLCache.ProcessQueuedData( pModelParts ); } else { // PC background load path. pull in material dependencies on the fly. Assert( ThreadInMainThread() ); g_MDLCache.ProcessQueuedData( pModelParts, true ); // preload all possible paths to VMTs { DEBUG_SCOPE_TIMER(findvmt); MaterialLock_t hMatLock = materials->Lock(); if ( studiohdr_t * pHdr = g_MDLCache.GetStudioHdr( pModelParts->hMDL ) ) { if ( !(pHdr->flags & STUDIOHDR_FLAGS_OBSOLETE) ) { char buf[MAX_PATH]; V_strcpy( buf, "materials/" ); int prefixLen = V_strlen( buf ); for ( int t = 0; t < pHdr->numtextures; ++t ) { // XXX this does not take remaps from vtxdata into account; // right now i am not caring about that. we will hitch if any // LODs remap to materials that are not in the header. (henryg) const char *pTexture = pHdr->pTexture(t)->pszName(); pTexture += ( pTexture[0] == CORRECT_PATH_SEPARATOR || pTexture[0] == INCORRECT_PATH_SEPARATOR ); for ( int cd = 0; cd < pHdr->numcdtextures; ++cd ) { const char *pCdTexture = pHdr->pCdtexture( cd ); pCdTexture += ( pCdTexture[0] == CORRECT_PATH_SEPARATOR || pCdTexture[0] == INCORRECT_PATH_SEPARATOR ); V_ComposeFileName( pCdTexture, pTexture, buf + prefixLen, MAX_PATH - prefixLen ); V_strncat( buf, ".vmt", MAX_PATH, COPY_ALL_CHARACTERS ); pModelParts->bMaterialsPending = true; const char *pbuf = buf; g_pFullFileSystem->AddFilesToFileCache( pModelParts->hFileCache, &pbuf, 1, "GAME" ); if ( materials->IsMaterialLoaded( buf + prefixLen ) ) { // found a loaded one. still cache it in case it unloads, // but we can stop adding more potential paths to the cache // since this one is known to be valid. break; } } } } } materials->Unlock(hMatLock); } // queue functor which will start polling every frame by re-queuing itself g_pQueuedLoader->QueueDynamicLoadFunctor( CreateFunctor( ProcessDynamicLoad, pModelParts ) ); } } } void CMDLCache::ProcessDynamicLoad( ModelParts_t *pModelParts ) { Assert( IsPC() && ThreadInMainThread() ); if ( !g_pFullFileSystem->IsFileCacheLoaded( pModelParts->hFileCache ) ) { // poll again next frame... g_pQueuedLoader->QueueDynamicLoadFunctor( CreateFunctor( ProcessDynamicLoad, pModelParts ) ); return; } if ( pModelParts->bMaterialsPending ) { DEBUG_SCOPE_TIMER(processvmt); pModelParts->bMaterialsPending = false; pModelParts->bTexturesPending = true; MaterialLock_t hMatLock = materials->Lock(); materials->SetAsyncTextureLoadCache( pModelParts->hFileCache ); // Load all the materials studiohdr_t * pHdr = g_MDLCache.GetStudioHdr( pModelParts->hMDL ); if ( pHdr && !(pHdr->flags & STUDIOHDR_FLAGS_OBSOLETE) ) { // build strings inside a buffer that already contains a materials/ prefix char buf[MAX_PATH]; V_strcpy( buf, "materials/" ); int prefixLen = V_strlen( buf ); // XXX this does not take remaps from vtxdata into account; // right now i am not caring about that. we will hitch if any // LODs remap to materials that are not in the header. (henryg) for ( int t = 0; t < pHdr->numtextures; ++t ) { const char *pTexture = pHdr->pTexture(t)->pszName(); pTexture += ( pTexture[0] == CORRECT_PATH_SEPARATOR || pTexture[0] == INCORRECT_PATH_SEPARATOR ); for ( int cd = 0; cd < pHdr->numcdtextures; ++cd ) { const char *pCdTexture = pHdr->pCdtexture( cd ); pCdTexture += ( pCdTexture[0] == CORRECT_PATH_SEPARATOR || pCdTexture[0] == INCORRECT_PATH_SEPARATOR ); V_ComposeFileName( pCdTexture, pTexture, buf + prefixLen, MAX_PATH - prefixLen ); IMaterial* pMaterial = materials->FindMaterial( buf + prefixLen, TEXTURE_GROUP_MODEL, false ); if ( !IsErrorMaterial( pMaterial ) && !pMaterial->IsPrecached() ) { pModelParts->Materials.AddToTail( pMaterial ); pMaterial->IncrementReferenceCount(); // Force texture loads while material system is set to capture // them and redirect to an error texture... this will populate // the file cache with all the requested textures pMaterial->RefreshPreservingMaterialVars(); break; } } } } materials->SetAsyncTextureLoadCache( NULL ); materials->Unlock( hMatLock ); // poll again next frame... dont want to do too much work right now g_pQueuedLoader->QueueDynamicLoadFunctor( CreateFunctor( ProcessDynamicLoad, pModelParts ) ); return; } if ( pModelParts->bTexturesPending ) { DEBUG_SCOPE_TIMER(matrefresh); pModelParts->bTexturesPending = false; // Perform the real material loads now while raw texture files are cached. FOR_EACH_VEC( pModelParts->Materials, i ) { IMaterial* pMaterial = pModelParts->Materials[i]; if ( !IsErrorMaterial( pMaterial ) && pMaterial->IsPrecached() ) { // Do a full reload to get the correct textures and computed flags pMaterial->Refresh(); } } // poll again next frame... dont want to do too much work right now g_pQueuedLoader->QueueDynamicLoadFunctor( CreateFunctor( ProcessDynamicLoad, pModelParts ) ); return; } // done. finish and clean up. Assert( !pModelParts->bTexturesPending && !pModelParts->bMaterialsPending ); // pull out cached items we want to overlap with final processing CleanupModelParts_t *pCleanup = new CleanupModelParts_t; pCleanup->hFileCache = pModelParts->hFileCache; pCleanup->Materials.Swap( pModelParts->Materials ); g_pQueuedLoader->QueueCleanupDynamicLoadFunctor( CreateFunctor( CleanupDynamicLoad, pCleanup ) ); { DEBUG_SCOPE_TIMER(processall); g_MDLCache.ProcessQueuedData( pModelParts ); // pModelParts is deleted here } } void CMDLCache::CleanupDynamicLoad( CleanupModelParts_t *pCleanup ) { Assert( IsPC() && ThreadInMainThread() ); // remove extra material refs, unload cached files FOR_EACH_VEC( pCleanup->Materials, i ) { pCleanup->Materials[i]->DecrementReferenceCount(); } g_pFullFileSystem->DestroyFileCache( pCleanup->hFileCache ); delete pCleanup; } //----------------------------------------------------------------------------- // Build a queued loader job to get the MDL ant all of its components into the cache. //----------------------------------------------------------------------------- bool CMDLCache::PreloadModel( MDLHandle_t handle ) { if ( g_pQueuedLoader->IsDynamic() == false ) { if ( !IsX360() ) { return false; } if ( !g_pQueuedLoader->IsMapLoading() || handle == MDLHANDLE_INVALID ) { return false; } } if ( !g_pQueuedLoader->IsBatching() ) { // batching must be active, following code depends on its behavior DevWarning( "CMDLCache:: Late preload of model '%s'\n", GetModelName( handle ) ); return false; } // determine existing presence // actual necessity is not established here, allowable absent files need their i/o error to occur bool bNeedsMDL = !IsDataLoaded( handle, MDLCACHE_STUDIOHDR ); bool bNeedsVTX = !IsDataLoaded( handle, MDLCACHE_STUDIOHWDATA ); bool bNeedsVVD = !IsDataLoaded( handle, MDLCACHE_VERTEXES ); bool bNeedsPHY = !IsDataLoaded( handle, MDLCACHE_VCOLLIDE ); if ( !bNeedsMDL && !bNeedsVTX && !bNeedsVVD && !bNeedsPHY ) { // nothing to do return true; } char szFilename[MAX_PATH]; char szNameOnDisk[MAX_PATH]; V_strncpy( szFilename, GetActualModelName( handle ), sizeof( szFilename ) ); V_StripExtension( szFilename, szFilename, sizeof( szFilename ) ); // need to gather all model parts (mdl, vtx, vvd, phy, ani) ModelParts_t *pModelParts = new ModelParts_t; pModelParts->hMDL = handle; pModelParts->hFileCache = g_pFullFileSystem->CreateFileCache(); // create multiple loader jobs to perform gathering i/o operations LoaderJob_t loaderJob; loaderJob.m_pPathID = "GAME"; loaderJob.m_pCallback = QueuedLoaderCallback_MDL; loaderJob.m_pContext = (void *)pModelParts; loaderJob.m_Priority = LOADERPRIORITY_DURINGPRELOAD; loaderJob.m_bPersistTargetData = true; if ( bNeedsMDL ) { V_snprintf( szNameOnDisk, sizeof( szNameOnDisk ), "%s%s.mdl", szFilename, GetPlatformExt() ); loaderJob.m_pFilename = szNameOnDisk; loaderJob.m_pContext2 = (void *)ModelParts_t::BUFFER_MDL; g_pQueuedLoader->AddJob( &loaderJob ); pModelParts->nExpectedParts |= 1 << ModelParts_t::BUFFER_MDL; } if ( bNeedsVTX ) { // vtx extensions are .xxx.vtx, need to re-form as, ???.xxx.yyy.vtx char szTempName[MAX_PATH]; V_snprintf( szNameOnDisk, sizeof( szNameOnDisk ), "%s%s", szFilename, GetVTXExtension() ); V_StripExtension( szNameOnDisk, szTempName, sizeof( szTempName ) ); V_snprintf( szNameOnDisk, sizeof( szNameOnDisk ), "%s%s.vtx", szTempName, GetPlatformExt() ); loaderJob.m_pFilename = szNameOnDisk; loaderJob.m_pContext2 = (void *)ModelParts_t::BUFFER_VTX; g_pQueuedLoader->AddJob( &loaderJob ); pModelParts->nExpectedParts |= 1 << ModelParts_t::BUFFER_VTX; } if ( bNeedsVVD ) { V_snprintf( szNameOnDisk, sizeof( szNameOnDisk ), "%s%s.vvd", szFilename, GetPlatformExt() ); loaderJob.m_pFilename = szNameOnDisk; loaderJob.m_pContext2 = (void *)ModelParts_t::BUFFER_VVD; g_pQueuedLoader->AddJob( &loaderJob ); pModelParts->nExpectedParts |= 1 << ModelParts_t::BUFFER_VVD; } if ( bNeedsPHY ) { V_snprintf( szNameOnDisk, sizeof( szNameOnDisk ), "%s%s.phy", szFilename, GetPlatformExt() ); loaderJob.m_pFilename = szNameOnDisk; loaderJob.m_pContext2 = (void *)ModelParts_t::BUFFER_PHY; g_pQueuedLoader->AddJob( &loaderJob ); pModelParts->nExpectedParts |= 1 << ModelParts_t::BUFFER_PHY; } if ( !pModelParts->nExpectedParts ) { g_pFullFileSystem->DestroyFileCache( pModelParts->hFileCache ); delete pModelParts; } return true; } //----------------------------------------------------------------------------- // Purpose: Clear the STUDIODATA_ERROR_MODEL flag. //----------------------------------------------------------------------------- void CMDLCache::ResetErrorModelStatus( MDLHandle_t handle ) { if ( handle == MDLHANDLE_INVALID ) return; m_MDLDict[handle]->m_nFlags &= ~STUDIODATA_ERROR_MODEL; } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void CMDLCache::MarkFrame() { ProcessPendingAsyncs(); } //----------------------------------------------------------------------------- // Purpose: bind studiohdr_t support functions to the mdlcacher //----------------------------------------------------------------------------- const studiohdr_t *studiohdr_t::FindModel( void **cache, char const *pModelName ) const { MDLHandle_t handle = g_MDLCache.FindMDL( pModelName ); *cache = MDLHandleToVirtual(handle); return g_MDLCache.GetStudioHdr( handle ); } virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const { if (numincludemodels == 0) return NULL; return g_MDLCache.GetVirtualModelFast( this, VoidPtrToMDLHandle( VirtualModel() ) ); } byte *studiohdr_t::GetAnimBlock( int i ) const { return g_MDLCache.GetAnimBlock( VoidPtrToMDLHandle( VirtualModel() ), i ); } int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const { return g_MDLCache.GetAutoplayList( VoidPtrToMDLHandle( VirtualModel() ), pOut ); } const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const { return g_MDLCache.GetStudioHdr( VoidPtrToMDLHandle( cache ) ); }