source-engine/datacache/mdlcache.cpp

//========= 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 <memory.h>
#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 long	 	*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 int NO_ASYNC = CUtlLinkedList< AsyncInfo_t >::InvalidIndex();

//-------------------------------------

CUtlMap<int, int> 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 int 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 int SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock, int 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 int SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int 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( int 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 &notification  );
	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 );

	// 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 _LINUX
	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];

	int 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 = (MDLHandle_t) (int)pVirtualModel->m_group[i].cache & 0xffff;
					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 long [pStudioData->m_nAnimBlockCount];
	memset( pStudioData->m_iFakeAnimBlockStall, 0, sizeof( unsigned long ) * 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];

	int 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 _LINUX
		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 == (void*)(uintp)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 = (MDLHandle_t)(int)pStudioData->m_pVirtualModel->m_group[i].cache&0xffff;
			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 );

		// 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 = (void *)(uintp)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;
	}

	int 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 )
{
	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 );
	}

	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->virtualModel = (void *)(uintp)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 _LINUX
	Q_strlower( pFileName );
#endif

	MdlCacheMsg( "MDLCache: Load studiohdr %s\n", pFileName );

	MEM_ALLOC_CREDIT();

	bool bOk = ReadFileNative( pFileName, "GAME", buf );
	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 );
		}
	}

	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->virtualModel = (void*)(uintp)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() );

#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; i<pVModel->m_group.Count(); ++i )
		{
			MDLHandle_t childHandle = (MDLHandle_t)(int)pVModel->m_group[i].cache&0xffff;
			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 &notification  )
{
	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)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)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
	int 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 = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;

	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 = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
	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( int 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)
	int current = m_PendingAsyncs.Head();
	while ( current != m_PendingAsyncs.InvalidIndex() )
	{
		int 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 )
{
	int 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 = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
	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 = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
	Assert( !m_MDLDict[handle]->m_VertexCache );

	studiodata_t *pStudioData = m_MDLDict[handle];

	if ( pStudioData->m_nFlags & STUDIODATA_FLAGS_NO_VERTEX_DATA )
	{
		return NULL;
	}

	int 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)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 >((int)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 = (void*)(uintp)handle;
	return g_MDLCache.GetStudioHdr( handle );
}

virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const
{
	if (numincludemodels == 0)
		return NULL;

	return g_MDLCache.GetVirtualModelFast( this, (MDLHandle_t)(int)virtualModel&0xffff );
}

byte *studiohdr_t::GetAnimBlock( int i ) const
{
	return g_MDLCache.GetAnimBlock( (MDLHandle_t)(int)virtualModel&0xffff, i );
}

int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const
{
	return g_MDLCache.GetAutoplayList( (MDLHandle_t)(int)virtualModel&0xffff, pOut );
}

const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const
{
	return g_MDLCache.GetStudioHdr( (MDLHandle_t)(int)cache&0xffff );
}