|
|
//===== Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose:
//
// $Workfile: $
// $NoKeywords: $
//===========================================================================//
#include "engine/ivmodelinfo.h"
#include "filesystem.h"
#include "gl_model_private.h"
#include "modelloader.h"
#include "l_studio.h"
#include "cmodel_engine.h"
#include "server.h"
#include "r_local.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/imaterial.h"
#include "lightcache.h"
#include "istudiorender.h"
#include "utlhashtable.h"
#include "filesystem_engine.h"
#include "client.h"
#include "sys_dll.h"
#include "gl_rsurf.h"
#include "networkstringtable.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
// Gets the lighting center
//-----------------------------------------------------------------------------
static void R_StudioGetLightingCenter( IClientRenderable *pRenderable, studiohdr_t* pStudioHdr, const Vector& origin, const QAngle &angles, Vector* pLightingOrigin ){ Assert( pLightingOrigin ); matrix3x4_t matrix; AngleMatrix( angles, origin, matrix ); R_ComputeLightingOrigin( pRenderable, pStudioHdr, matrix, *pLightingOrigin );}
static int R_StudioBodyVariations( studiohdr_t *pstudiohdr ){ mstudiobodyparts_t *pbodypart; int i, count;
if ( !pstudiohdr ) return 0;
count = 1; pbodypart = pstudiohdr->pBodypart( 0 );
// Each body part has nummodels variations so there are as many total variations as there
// are in a matrix of each part by each other part
for ( i = 0; i < pstudiohdr->numbodyparts; i++ ) { count = count * pbodypart[i].nummodels; } return count;}
static int ModelFrameCount( model_t *model ){ int count = 1;
if ( !model ) return count;
if ( model->type == mod_sprite ) { return model->sprite.numframes; } else if ( model->type == mod_studio ) { count = R_StudioBodyVariations( ( studiohdr_t * )modelloader->GetExtraData( model ) ); }
if ( count < 1 ) count = 1; return count;}
//-----------------------------------------------------------------------------
// shared implementation of IVModelInfo
//-----------------------------------------------------------------------------
class CModelInfo : public IVModelInfoClient{public: virtual const model_t *FindOrLoadModel( const char *name ) const; virtual const char *GetModelName( const model_t *model ) const; virtual void GetModelBounds( const model_t *model, Vector& mins, Vector& maxs ) const; virtual void GetModelRenderBounds( const model_t *model, Vector& mins, Vector& maxs ) const; virtual int GetModelFrameCount( const model_t *model ) const; virtual int GetModelType( const model_t *model ) const; virtual void *GetModelExtraData( const model_t *model ); virtual bool ModelHasMaterialProxy( const model_t *model ) const; virtual bool IsTranslucent( const model_t *model ) const; virtual bool IsModelVertexLit( const model_t *model ) const; virtual bool UsesEnvCubemap( const model_t *model ) const; virtual bool UsesStaticLighting( const model_t *model ) const; virtual bool IsTranslucentTwoPass( const model_t *model ) const; virtual RenderableTranslucencyType_t ComputeTranslucencyType( const model_t *model, int nSkin, int nBody ); virtual int GetModelMaterialCount( const model_t *model ) const; virtual int GetModelMaterials( const model_t *model, int count, IMaterial** ppMaterials ); virtual void GetIlluminationPoint( const model_t *model, IClientRenderable *pRenderable, const Vector& origin, const QAngle& angles, Vector* pLightingOrigin ); virtual int GetModelContents( int modelIndex ) const; vcollide_t *GetVCollide( const model_t *model ) const; vcollide_t *GetVCollide( int modelIndex ) const;
virtual const char *GetModelKeyValueText( const model_t *model ); virtual bool GetModelKeyValue( const model_t *model, CUtlBuffer &buf ); virtual KeyValues *GetModelKeyValues( const model_t *pModel ); virtual float GetModelRadius( const model_t *model ); virtual studiohdr_t *GetStudiomodel( const model_t *mod ); virtual int GetModelSpriteWidth( const model_t *model ) const; virtual int GetModelSpriteHeight( const model_t *model ) const;
virtual const studiohdr_t *FindModel( const studiohdr_t *pStudioHdr, void **cache, char const *modelname ) const; virtual const studiohdr_t *FindModel( void *cache ) const; virtual virtualmodel_t *GetVirtualModel( const studiohdr_t *pStudioHdr ) const; virtual byte *GetAnimBlock( const studiohdr_t *pStudioHdr, int nBlock, bool bPreloadIfMissing ) const; virtual bool HasAnimBlockBeenPreloaded( const studiohdr_t *pStudioHdr, int nBlock ) const;
byte *LoadAnimBlock( model_t *model, const studiohdr_t *pStudioHdr, int iBlock, cache_user_t *cache ) const;
// NOTE: These aren't in the server version, but putting them here makes this code easier to write
// Sets/gets a map-specified fade range
virtual void SetLevelScreenFadeRange( float flMinSize, float flMaxSize ) {} virtual void GetLevelScreenFadeRange( float *pMinArea, float *pMaxArea ) const { *pMinArea = 0; *pMaxArea = 0; }
// Sets/gets a map-specified per-view fade range
virtual void SetViewScreenFadeRange( float flMinSize, float flMaxSize ) {}
// Computes fade alpha based on distance fade + screen fade
virtual unsigned char ComputeLevelScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale ) const { return 0; } virtual unsigned char ComputeViewScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale ) const { return 0; }
int GetAutoplayList( const studiohdr_t *pStudioHdr, unsigned short **pAutoplayList ) const; CPhysCollide *GetCollideForVirtualTerrain( int index ); virtual int GetSurfacepropsForVirtualTerrain( int index ) { return CM_SurfacepropsForDisp(index); }
virtual bool IsUsingFBTexture( const model_t *model, int nSkin, int nBody, void /*IClientRenderable*/ *pClientRenderable ) const;
virtual MDLHandle_t GetCacheHandle( const model_t *model ) const { return ( model->type == mod_studio ) ? model->studio : MDLHANDLE_INVALID; }
// Returns planes of non-nodraw brush model surfaces
virtual int GetBrushModelPlaneCount( const model_t *model ) const; virtual void GetBrushModelPlane( const model_t *model, int nIndex, cplane_t &plane, Vector *pOrigin ) const;
public: virtual int GetModelIndex( const char *name ) const; virtual int GetModelClientSideIndex( const char *name ) const; virtual int RegisterDynamicModel( const char *name, bool bClientSide ) = 0; virtual int RegisterCombinedDynamicModel( const char *pszName, MDLHandle_t Handle ) = 0; virtual void UpdateCombinedDynamicModel( int nModelIndex, MDLHandle_t Handle ) = 0; virtual int BeginCombinedModel( const char *pszName, bool bReuseExisting ) = 0; virtual bool SetCombineModels( int nModelIndex, const CUtlVector< SCombinerModelInput_t > &vecModelsToCombine ) = 0; virtual bool FinishCombinedModel( int nModelIndex, CombinedModelLoadedCallback pFunc, void *pUserData ) = 0; virtual void ReleaseCombinedModel( int nModelIndex ) = 0; virtual bool IsDynamicModelLoading( int modelIndex ); virtual void AddRefDynamicModel( int modelIndex ); virtual void ReleaseDynamicModel( int modelIndex ); virtual bool RegisterModelLoadCallback( int modelindex, IModelLoadCallback* pCallback, bool bCallImmediatelyIfLoaded = true ); virtual void UnregisterModelLoadCallback( int modelindex, IModelLoadCallback* pCallback ); virtual void OnLevelChange(); virtual void OnDynamicModelStringTableChanged( int nStringIndex, const char *pString, const void *pData ) { Assert(false); }
virtual model_t *ReferenceModel( const char *name ) { return NULL; } virtual void UnreferenceModel( model_t *model ) {} virtual void UnloadUnreferencedModels( void ) {}
protected: static int CLIENTSIDE_TO_MODEL( int i ) { return i >= 0 ? (-2 - (i*2 + 1)) : -1; } static int NETDYNAMIC_TO_MODEL( int i ) { return i >= 0 ? (-2 - (i*2)) : -1; } static int MODEL_TO_CLIENTSIDE( int i ) { return ( i <= -2 && (i & 1) ) ? (-2 - i) >> 1 : -1; } static int MODEL_TO_NETDYNAMIC( int i ) { return ( i <= -2 && !(i & 1) ) ? (-2 - i) >> 1 : -1; }
model_t *LookupDynamicModel( int i );
virtual INetworkStringTable *GetDynamicModelStringTable() const = 0; virtual int LookupPrecachedModelIndex( const char *name ) const = 0;
void GrowNetworkedDynamicModels( int netidx ) { if ( m_NetworkedDynamicModels.Count() <= netidx ) { int origCount = m_NetworkedDynamicModels.Count(); m_NetworkedDynamicModels.SetCountNonDestructively( netidx + 1 ); for ( int i = origCount; i <= netidx; ++i ) { m_NetworkedDynamicModels[i] = NULL; } } }
// Networked dynamic model indices are lookup indices for this vector
CUtlVector< model_t* > m_NetworkedDynamicModels;
public: struct ModelFileHandleHash { uint operator()( model_t *p ) const { return PointerHashFunctor()( p->fnHandle ); } uint operator()( FileNameHandle_t fn ) const { return PointerHashFunctor()( fn ); } }; struct ModelFileHandleEq { bool operator()( model_t *a, model_t *b ) const { return a == b; } bool operator()( model_t *a, FileNameHandle_t b ) const { return a->fnHandle == b; } };protected: // Client-only dynamic model indices are iterators into this struct (only populated by CModelInfoClient subclass)
CUtlStableHashtable< model_t*, empty_t, ModelFileHandleHash, ModelFileHandleEq, int16, FileNameHandle_t > m_ClientDynamicModels;};
const model_t *CModelInfo::FindOrLoadModel( const char *name ) const{ // find the cached model from the server or client
const model_t *pModel = GetModel( GetModelIndex( name ) ); if ( pModel ) return pModel;
// load the model
return modelloader->GetModelForName( name, IModelLoader::FMODELLOADER_CLIENTDLL );}
const char *CModelInfo::GetModelName( const model_t *pModel ) const{ if ( !pModel ) { return "?"; }
return modelloader->GetName( pModel );}
void CModelInfo::GetModelBounds( const model_t *model, Vector& mins, Vector& maxs ) const{ VectorCopy( model->mins, mins ); VectorCopy( model->maxs, maxs );}
void CModelInfo::GetModelRenderBounds( const model_t *model, Vector& mins, Vector& maxs ) const{ if (!model) { mins.Init(0,0,0); maxs.Init(0,0,0); return; }
switch( model->type ) { case mod_studio: { studiohdr_t *pStudioHdr = ( studiohdr_t * )modelloader->GetExtraData( (model_t*)model ); Assert( pStudioHdr );
// NOTE: We're not looking at the sequence box here, although we could
if (!VectorCompare( vec3_origin, pStudioHdr->view_bbmin ) || !VectorCompare( vec3_origin, pStudioHdr->view_bbmax )) { // clipping bounding box
VectorCopy ( pStudioHdr->view_bbmin, mins); VectorCopy ( pStudioHdr->view_bbmax, maxs); } else { // movement bounding box
VectorCopy ( pStudioHdr->hull_min, mins); VectorCopy ( pStudioHdr->hull_max, maxs); } } break;
case mod_brush: VectorCopy( model->mins, mins ); VectorCopy( model->maxs, maxs ); break;
default: mins.Init( 0, 0, 0 ); maxs.Init( 0, 0, 0 ); break; }}
int CModelInfo::GetModelSpriteWidth( const model_t *model ) const{ // We must be a sprite to make this query
if ( model->type != mod_sprite ) return 0;
return model->sprite.width;}
int CModelInfo::GetModelSpriteHeight( const model_t *model ) const{ // We must be a sprite to make this query
if ( model->type != mod_sprite ) return 0;
return model->sprite.height;}
int CModelInfo::GetModelFrameCount( const model_t *model ) const{ return ModelFrameCount( ( model_t *)model );}
int CModelInfo::GetModelType( const model_t *model ) const{ return model ? model->type : -1;}
void *CModelInfo::GetModelExtraData( const model_t *model ){ return modelloader->GetExtraData( (model_t *)model );}
//-----------------------------------------------------------------------------
// Purpose: Translate "cache" pointer into model_t, or lookup model by name
//-----------------------------------------------------------------------------
const studiohdr_t *CModelInfo::FindModel( const studiohdr_t *pStudioHdr, void **cache, char const *modelname ) const{ const model_t *model = (model_t *)*cache;
if (!model) { // FIXME: what do I pass in here?
model = modelloader->GetModelForName( modelname, IModelLoader::FMODELLOADER_SERVER ); *cache = (void *)model; }
return (const studiohdr_t *)modelloader->GetExtraData( (model_t *)model );}
//-----------------------------------------------------------------------------
// Purpose: Translate "cache" pointer into model_t
//-----------------------------------------------------------------------------
const studiohdr_t *CModelInfo::FindModel( void *cache ) const{ return g_pMDLCache->GetStudioHdr( VoidPtrToMDLHandle( cache ) );}
//-----------------------------------------------------------------------------
// Purpose: Return virtualmodel_t block associated with model_t
//-----------------------------------------------------------------------------
virtualmodel_t *CModelInfo::GetVirtualModel( const studiohdr_t *pStudioHdr ) const{ MDLHandle_t handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() ); return g_pMDLCache->GetVirtualModelFast( pStudioHdr, handle );}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
byte *CModelInfo::GetAnimBlock( const studiohdr_t *pStudioHdr, int nBlock, bool bPreloadIfMissing ) const{ MDLHandle_t handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() ); return g_pMDLCache->GetAnimBlock( handle, nBlock, bPreloadIfMissing );}
//-----------------------------------------------------------------------------
// Purpose: Indicates if hte anim block has been preloaded.
//-----------------------------------------------------------------------------
bool CModelInfo::HasAnimBlockBeenPreloaded( const studiohdr_t *pStudioHdr, int nBlock ) const{ MDLHandle_t handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() ); return g_pMDLCache->HasAnimBlockBeenPreloaded( handle, nBlock );}
int CModelInfo::GetAutoplayList( const studiohdr_t *pStudioHdr, unsigned short **pAutoplayList ) const{ MDLHandle_t handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() ); return g_pMDLCache->GetAutoplayList( handle, pAutoplayList );}
//-----------------------------------------------------------------------------
// Purpose: bind studiohdr_t support functions to engine
// FIXME: This should be moved into studio.cpp?
//-----------------------------------------------------------------------------
const studiohdr_t *studiohdr_t::FindModel( void **cache, char const *pModelName ) const{ MDLHandle_t handle = g_pMDLCache->FindMDL( pModelName ); *cache = (void*)(uintp)handle; return g_pMDLCache->GetStudioHdr( handle );}
virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const{ if ( numincludemodels == 0 ) return NULL; return g_pMDLCache->GetVirtualModelFast( this, VoidPtrToMDLHandle( VirtualModel() ) );}
byte *studiohdr_t::GetAnimBlock( int i, bool preloadIfMissing ) const{ return g_pMDLCache->GetAnimBlock( VoidPtrToMDLHandle( VirtualModel() ), i, preloadIfMissing );}
bool studiohdr_t::hasAnimBlockBeenPreloaded( int i ) const{ return g_pMDLCache->HasAnimBlockBeenPreloaded( VoidPtrToMDLHandle( VirtualModel() ), i );}
int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const{ return g_pMDLCache->GetAutoplayList( VoidPtrToMDLHandle( VirtualModel() ), pOut );}
const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const{ return g_pMDLCache->GetStudioHdr( VoidPtrToMDLHandle( cache ) );}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CModelInfo::ModelHasMaterialProxy( const model_t *model ) const{ // Should we add skin & model to this function like IsUsingFBTexture()?
return (model && (model->flags & MODELFLAG_MATERIALPROXY));}
bool CModelInfo::IsTranslucent( const model_t *model ) const{ return (model && (model->flags & MODELFLAG_TRANSLUCENT));}
bool CModelInfo::IsModelVertexLit( const model_t *model ) const{ // Should we add skin & model to this function like IsUsingFBTexture()?
return (model && (model->flags & MODELFLAG_VERTEXLIT));}
bool CModelInfo::UsesEnvCubemap( const model_t *model ) const{ return (model && (model->flags & MODELFLAG_STUDIOHDR_USES_ENV_CUBEMAP ));}
bool CModelInfo::UsesStaticLighting( const model_t *model ) const{ if ( !model || ( model->type != mod_studio ) ) return false;
static ConVarRef r_staticlight_streams("r_staticlight_streams");
bool bIsStaticProp = ( model->flags & MODELFLAG_STUDIOHDR_IS_STATIC_PROP ) != 0; if ( !bIsStaticProp ) return false;
bool bUsesBumpMapping = ( model->flags & MODELFLAG_STUDIOHDR_USES_BUMPMAPPING ) != 0; int numLightingComponents = r_staticlight_streams.GetInt();
// statlight_mode 2 => ignore 3 color streams, revert to non-statically lit for bump mapped props (dynamic lighting only)
static ConVarRef r_staticlight_mode("r_staticlight_mode"); bool bEnableStaticLight3 = r_staticlight_mode.GetInt() != 2;
return ( !bUsesBumpMapping || ((numLightingComponents > 1) && bEnableStaticLight3 ) );}
bool CModelInfo::IsTranslucentTwoPass( const model_t *model ) const{ return (model && (model->flags & MODELFLAG_TRANSLUCENT_TWOPASS));}
bool CModelInfo::IsUsingFBTexture( const model_t *model, int nSkin, int nBody, void /*IClientRenderable*/ *pClientRenderable ) const{ bool bMightUseFbTextureThisFrame = (model && (model->flags & MODELFLAG_STUDIOHDR_USES_FB_TEXTURE));
if ( bMightUseFbTextureThisFrame ) { // Check each material's NeedsPowerOfTwoFrameBufferTexture() virtual func
switch( model->type ) { case mod_brush: { for (int i = 0; i < model->brush.nummodelsurfaces; ++i) { SurfaceHandle_t surfID = SurfaceHandleFromIndex( model->brush.firstmodelsurface+i, model->brush.pShared ); IMaterial* material = MSurf_TexInfo( surfID, model->brush.pShared )->material; if ( material != NULL ) { if ( material->NeedsPowerOfTwoFrameBufferTexture() ) { return true; } } } } break;
case mod_studio: { IMaterial *pMaterials[ 128 ]; int materialCount = g_pStudioRender->GetMaterialListFromBodyAndSkin( model->studio, nSkin, nBody, ARRAYSIZE( pMaterials ), pMaterials ); for ( int i = 0; i < materialCount; i++ ) { if ( pMaterials[i] != NULL ) { // Bind material first so all material proxies execute
CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); pRenderContext->Bind( pMaterials[i], pClientRenderable );
if ( pMaterials[i]->NeedsPowerOfTwoFrameBufferTexture() ) { return true; } } } } break; } }
return false;}
RenderableTranslucencyType_t CModelInfo::ComputeTranslucencyType( const model_t *model, int nSkin, int nBody ){ if ( model != NULL ) return Mod_ComputeTranslucencyType( (model_t *)model, nSkin, nBody ); return RENDERABLE_IS_OPAQUE;}
int CModelInfo::GetModelMaterialCount( const model_t *model ) const{ if (!model) return 0; return Mod_GetMaterialCount( (model_t *)model );}
int CModelInfo::GetModelMaterials( const model_t *model, int count, IMaterial** ppMaterials ){ if (!model) return 0; return Mod_GetModelMaterials( (model_t *)model, count, ppMaterials );}
void CModelInfo::GetIlluminationPoint( const model_t *model, IClientRenderable *pRenderable, const Vector& origin, const QAngle& angles, Vector* pLightingOrigin ){ Assert( model->type == mod_studio ); studiohdr_t* pStudioHdr = (studiohdr_t*)GetModelExtraData(model); if (pStudioHdr) { R_StudioGetLightingCenter( pRenderable, pStudioHdr, origin, angles, pLightingOrigin ); } else { *pLightingOrigin = origin; }}
int CModelInfo::GetModelContents( int modelIndex ) const{ const model_t *pModel = GetModel( modelIndex ); if ( pModel ) { switch( pModel->type ) { case mod_brush: return CM_InlineModelContents( modelIndex-1 ); // BUGBUG: Studio contents?
case mod_studio: return CONTENTS_SOLID; } } return 0;}
extern double g_flAccumulatedModelLoadTimeVCollideSync;
vcollide_t *CModelInfo::GetVCollide( const model_t *pModel ) const{ if ( !pModel ) return NULL;
if ( pModel->type == mod_studio ) { double t1 = Plat_FloatTime(); vcollide_t *col = g_pMDLCache->GetVCollide( pModel->studio ); double t2 = Plat_FloatTime(); g_flAccumulatedModelLoadTimeVCollideSync += ( t2 - t1 ); return col; }
int i = GetModelIndex( GetModelName( pModel ) ); if ( i >= 0 ) { return GetVCollide( i ); }
return NULL;}
vcollide_t *CModelInfo::GetVCollide( int modelIndex ) const{ // First model (index 0 )is is empty
// Second model( index 1 ) is the world, then brushes/submodels, then players, etc.
// So, we must subtract 1 from the model index to map modelindex to CM_ index
// in cmodels, 0 is the world, then brushes, etc.
if ( modelIndex < MAX_MODELS ) { const model_t *pModel = GetModel( modelIndex ); if ( pModel ) { switch( pModel->type ) { case mod_brush: return CM_GetVCollide( modelIndex-1 ); case mod_studio: { double t1 = Plat_FloatTime(); vcollide_t *col = g_pMDLCache->GetVCollide( pModel->studio ); double t2 = Plat_FloatTime(); g_flAccumulatedModelLoadTimeVCollideSync += ( t2 - t1 ); return col; } } } else { // we may have the cmodels loaded and not know the model/mod->type yet
return CM_GetVCollide( modelIndex-1 ); } } return NULL;}
// Client must instantiate a KeyValues, which will be filled by this method
const char *CModelInfo::GetModelKeyValueText( const model_t *model ){ if (!model || model->type != mod_studio) return NULL;
studiohdr_t* pStudioHdr = g_pMDLCache->GetStudioHdr( model->studio ); if (!pStudioHdr) return NULL;
return pStudioHdr->KeyValueText();}
static CThreadFastMutex g_ModelKeyValueMutex;KeyValues *CModelInfo::GetModelKeyValues( const model_t *pModel ){ // in case we enter this from multiple threads
AUTO_LOCK_FM( g_ModelKeyValueMutex ); if ( !pModel->m_pKeyValues ) { const char *pKeyValueText = GetModelKeyValueText( pModel ); KeyValues *pKV = new KeyValues(""); if ( pKV->LoadFromBuffer( GetModelName( pModel ), pKeyValueText ) ) { const_cast<model_t *>(pModel)->m_pKeyValues = pKV; } else { pKV->deleteThis(); } } return pModel->m_pKeyValues;}
bool CModelInfo::GetModelKeyValue( const model_t *model, CUtlBuffer &buf ){ if (!model || model->type != mod_studio) return false;
studiohdr_t* pStudioHdr = g_pMDLCache->GetStudioHdr( model->studio ); if (!pStudioHdr) return false;
if ( pStudioHdr->numincludemodels == 0) { buf.PutString( pStudioHdr->KeyValueText() ); return true; }
virtualmodel_t *pVM = GetVirtualModel( pStudioHdr );
if (pVM) { for (int i = 0; i < pVM->m_group.Count(); i++) { const studiohdr_t* pSubStudioHdr = pVM->m_group[i].GetStudioHdr(); if (pSubStudioHdr && pSubStudioHdr->KeyValueText()) { buf.PutString( pSubStudioHdr->KeyValueText() ); } } } return true;}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *model -
// Output : float
//-----------------------------------------------------------------------------
float CModelInfo::GetModelRadius( const model_t *model ){ if ( !model ) return 0.0f; return model->radius;}
//-----------------------------------------------------------------------------
// Lovely studiohdrs
//-----------------------------------------------------------------------------
studiohdr_t *CModelInfo::GetStudiomodel( const model_t *model ){ if ( model->type == mod_studio ) return g_pMDLCache->GetStudioHdr( model->studio );
return NULL;}
CPhysCollide *CModelInfo::GetCollideForVirtualTerrain( int index ){ return CM_PhysCollideForDisp( index );}
// Returns planes of non-nodraw brush model surfaces
int CModelInfo::GetBrushModelPlaneCount( const model_t *model ) const{ if ( !model || model->type != mod_brush ) return 0;
return R_GetBrushModelPlaneCount( model );}
void CModelInfo::GetBrushModelPlane( const model_t *model, int nIndex, cplane_t &plane, Vector *pOrigin ) const{ if ( !model || model->type != mod_brush ) return;
plane = R_GetBrushModelPlane( model, nIndex, pOrigin );}
int CModelInfo::GetModelIndex( const char *name ) const{ if ( !name ) return -1;
// Order of preference: precached, networked, client-only.
int nIndex = LookupPrecachedModelIndex( name ); if ( nIndex != -1 ) return nIndex;
INetworkStringTable* pTable = GetDynamicModelStringTable(); if ( pTable ) { int netdyn = pTable->FindStringIndex( name ); if ( netdyn != INVALID_STRING_INDEX ) { Assert( !m_NetworkedDynamicModels.IsValidIndex( netdyn ) || V_strcmp( m_NetworkedDynamicModels[netdyn]->szPathName, name ) == 0 ); return NETDYNAMIC_TO_MODEL( netdyn ); } }
return GetModelClientSideIndex( name );}
int CModelInfo::GetModelClientSideIndex( const char *name ) const{ if ( m_ClientDynamicModels.Count() != 0 ) { FileNameHandle_t file = g_pFullFileSystem->FindFileName( name ); if ( file ) { UtlHashHandle_t h = m_ClientDynamicModels.Find( file ); if ( h != m_ClientDynamicModels.InvalidHandle() ) { Assert( V_strcmp( m_ClientDynamicModels[h]->szPathName, name ) == 0 ); return CLIENTSIDE_TO_MODEL( h ); } } }
return -1;}
model_t *CModelInfo::LookupDynamicModel( int i ){ Assert( IsDynamicModelIndex( i ) ); if ( IsClientOnlyModelIndex( i ) ) { UtlHashHandle_t h = (UtlHashHandle_t) MODEL_TO_CLIENTSIDE( i ); return m_ClientDynamicModels.IsValidHandle( h ) ? m_ClientDynamicModels[ h ] : NULL; } else { int netidx = MODEL_TO_NETDYNAMIC( i ); if ( m_NetworkedDynamicModels.IsValidIndex( netidx ) && m_NetworkedDynamicModels[ netidx ] ) return m_NetworkedDynamicModels[ netidx ];
INetworkStringTable *pTable = GetDynamicModelStringTable(); if ( pTable && (uint) netidx < (uint) pTable->GetNumStrings() ) { GrowNetworkedDynamicModels( netidx ); const char *name = pTable->GetString( netidx ); model_t *pModel = modelloader->GetDynamicModel( name, false ); m_NetworkedDynamicModels[ netidx ] = pModel; return pModel; }
return NULL; }}
bool CModelInfo::RegisterModelLoadCallback( int modelIndex, IModelLoadCallback* pCallback, bool bCallImmediatelyIfLoaded ){ const model_t *pModel = GetModel( modelIndex ); Assert( pModel ); if ( pModel && IsDynamicModelIndex( modelIndex ) ) { return modelloader->RegisterModelLoadCallback( const_cast< model_t *>( pModel ), pCallback, bCallImmediatelyIfLoaded ); } else if ( pModel && bCallImmediatelyIfLoaded ) { pCallback->OnModelLoadComplete( pModel ); return true; } return false;}
void CModelInfo::UnregisterModelLoadCallback( int modelIndex, IModelLoadCallback* pCallback ){ if ( modelIndex == -1 ) { modelloader->UnregisterModelLoadCallback( NULL, pCallback ); } else if ( IsDynamicModelIndex( modelIndex ) ) { const model_t *pModel = LookupDynamicModel( modelIndex ); Assert( pModel ); if ( pModel ) { modelloader->UnregisterModelLoadCallback( const_cast< model_t *>( pModel ), pCallback ); } }}
bool CModelInfo::IsDynamicModelLoading( int modelIndex ){ model_t *pModel = LookupDynamicModel( modelIndex ); return pModel && modelloader->IsDynamicModelLoading( pModel );}
void CModelInfo::AddRefDynamicModel( int modelIndex ){ if ( IsDynamicModelIndex( modelIndex ) ) { model_t *pModel = LookupDynamicModel( modelIndex ); Assert( pModel ); if ( pModel ) { modelloader->AddRefDynamicModel( pModel, IsClientOnlyModelIndex( modelIndex ) ); } }}
void CModelInfo::ReleaseDynamicModel( int modelIndex ){ if ( IsDynamicModelIndex( modelIndex ) ) { model_t *pModel = LookupDynamicModel( modelIndex ); Assert( pModel ); if ( pModel ) { modelloader->ReleaseDynamicModel( pModel, IsClientOnlyModelIndex( modelIndex ) ); } }}
void CModelInfo::OnLevelChange(){ // Network string table has reset
m_NetworkedDynamicModels.Purge();
// Force-unload any server-side models
modelloader->ForceUnloadNonClientDynamicModels();}
//-----------------------------------------------------------------------------
// implementation of IVModelInfo for server
//-----------------------------------------------------------------------------
class CModelInfoServer : public CModelInfo{public: virtual const model_t *GetModel( int modelindex ) const; virtual int LookupPrecachedModelIndex( const char *name ) const; virtual void GetModelMaterialColorAndLighting( const model_t *model, const Vector& origin, const QAngle& angles, trace_t* pTrace, Vector& lighting, Vector& matColor );
virtual INetworkStringTable *GetDynamicModelStringTable() const { return sv.m_pDynamicModelTable; } virtual int RegisterDynamicModel( const char *name, bool bClientSide ); virtual int RegisterCombinedDynamicModel( const char *pszName, MDLHandle_t Handle ); virtual void UpdateCombinedDynamicModel( int nModelIndex, MDLHandle_t Handle ); virtual int BeginCombinedModel( const char *pszName, bool bReuseExisting ); virtual bool SetCombineModels( int nModelIndex, const CUtlVector< SCombinerModelInput_t > &vecModelsToCombine ); virtual bool FinishCombinedModel( int nModelIndex, CombinedModelLoadedCallback pFunc, void *pUserData ); virtual void ReleaseCombinedModel( int nModelIndex );
virtual void UpdateViewWeaponModelCache( const char **ppWeaponModels, int nWeaponModels ) {} virtual void TouchWorldWeaponModelCache( const char **ppWeaponModels, int nWeaponModels ) {}};
const model_t *CModelInfoServer::GetModel( int modelindex ) const{ if ( IsDynamicModelIndex( modelindex ) ) return const_cast< CModelInfoServer * >( this )->LookupDynamicModel( modelindex );
return sv.GetModel( modelindex );}
int CModelInfoServer::LookupPrecachedModelIndex( const char *name ) const{ return sv.LookupModelIndex( name );}
void CModelInfoServer::GetModelMaterialColorAndLighting( const model_t *model, const Vector& origin, const QAngle& angles, trace_t* pTrace, Vector& lighting, Vector& matColor ){ Msg( "GetModelMaterialColorAndLighting: Available on client only!\n" );}
int CModelInfoServer::RegisterDynamicModel( const char *name, bool bClientSide ){ // Server should not know about client-side dynamic models!
Assert( !bClientSide ); if ( bClientSide ) return -1;
char buf[256]; V_strncpy( buf, name, ARRAYSIZE(buf) ); V_RemoveDotSlashes( buf, '/' ); name = buf;
Assert( StringHasPrefix( name, "models/" ) && V_strstr( name, ".mdl" ) != NULL );
// Already known? bClientSide should always be false and is asserted above.
int index = GetModelIndex( name ); if ( index != -1 ) return index;
INetworkStringTable *pTable = GetDynamicModelStringTable(); Assert( pTable ); if ( !pTable ) return -1;
// Register this model with the dynamic model string table
Assert( pTable->FindStringIndex( name ) == INVALID_STRING_INDEX ); bool bWasLocked = static_cast< CNetworkStringTable* >( pTable )->Lock( false ); char nIsLoaded = 0; int netidx = pTable->AddString( true, name, 1, &nIsLoaded ); static_cast< CNetworkStringTable* >( pTable )->Lock( bWasLocked );
// And also cache the model_t* pointer at this time
GrowNetworkedDynamicModels( netidx ); m_NetworkedDynamicModels[ netidx ] = modelloader->GetDynamicModel( name, bClientSide );
Assert( MODEL_TO_NETDYNAMIC( ( short ) NETDYNAMIC_TO_MODEL( netidx ) ) == netidx ); return NETDYNAMIC_TO_MODEL( netidx );}
int CModelInfoServer::RegisterCombinedDynamicModel( const char *pszName, MDLHandle_t Handle ){ return -1;}
void CModelInfoServer::UpdateCombinedDynamicModel( int nModelIndex, MDLHandle_t Handle ){
}
int CModelInfoServer::BeginCombinedModel( const char *pszName, bool bReuseExisting ){ return -1;}
bool CModelInfoServer::SetCombineModels( int nModelIndex, const CUtlVector< SCombinerModelInput_t > &vecModelsToCombine ){ return false;}
bool CModelInfoServer::FinishCombinedModel( int nModelIndex, CombinedModelLoadedCallback pFunc, void *pUserData ) { return false;}
void CModelInfoServer::ReleaseCombinedModel( int nModelIndex ){}
static CModelInfoServer g_ModelInfoServer;EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CModelInfoServer, IVModelInfo, VMODELINFO_SERVER_INTERFACE_VERSION, g_ModelInfoServer );
// Expose IVModelInfo to the engine
IVModelInfo *modelinfo = &g_ModelInfoServer;
#ifndef DEDICATED
//-----------------------------------------------------------------------------
// implementation of IVModelInfo for client
//-----------------------------------------------------------------------------
class CModelInfoClient : public CModelInfo{public: // Sets/gets a map-specified fade range
virtual void SetLevelScreenFadeRange( float flMinSize, float flMaxSize ); virtual void GetLevelScreenFadeRange( float *pMinArea, float *pMaxArea ) const;
// Sets/gets a map-specified per-view fade range
virtual void SetViewScreenFadeRange( float flMinSize, float flMaxSize );
// Computes fade alpha based on distance fade + screen fade
virtual unsigned char ComputeLevelScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale ) const; virtual unsigned char ComputeViewScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale ) const;
virtual const model_t *GetModel( int modelindex ) const; virtual int LookupPrecachedModelIndex( const char *name ) const; virtual void GetModelMaterialColorAndLighting( const model_t *model, const Vector& origin, const QAngle& angles, trace_t* pTrace, Vector& lighting, Vector& matColor );
INetworkStringTable *GetDynamicModelStringTable() const { return GetBaseLocalClient().m_pDynamicModelTable; } virtual int RegisterDynamicModel( const char *name, bool bClientSide ); virtual int RegisterCombinedDynamicModel( const char *pszName, MDLHandle_t Handle ); virtual void UpdateCombinedDynamicModel( int nModelIndex, MDLHandle_t Handle ); virtual int BeginCombinedModel( const char *pszName, bool bReuseExisting ); virtual bool SetCombineModels( int nModelIndex, const CUtlVector< SCombinerModelInput_t > &vecModelsToCombine ); virtual bool FinishCombinedModel( int nModelIndex, CombinedModelLoadedCallback pFunc, void *pUserData ); virtual void ReleaseCombinedModel( int nModelIndex ); virtual void OnDynamicModelStringTableChanged( int nStringIndex, const char *pString, const void *pData );
virtual void UpdateViewWeaponModelCache( const char **ppWeaponModels, int nWeaponModels ); virtual void TouchWorldWeaponModelCache( const char **ppWeaponModels, int nWeaponModels );
// Referencing
virtual model_t *ReferenceModel( const char *name ); virtual void UnreferenceModel( model_t *model ); virtual void UnloadUnreferencedModels( void );
private: struct ScreenFadeInfo_t { float m_flMinScreenWidth; float m_flMaxScreenWidth; float m_flFalloffFactor; };
// Sets/gets a map-specified fade range
void SetScreenFadeRange( float flMinSize, float flMaxSize, ScreenFadeInfo_t *pFade ); unsigned char ComputeScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale, const ScreenFadeInfo_t &fade ) const;
ScreenFadeInfo_t m_LevelFade; ScreenFadeInfo_t m_ViewFade;};
const model_t *CModelInfoClient::GetModel( int modelindex ) const{ if ( IsDynamicModelIndex( modelindex ) ) return const_cast< CModelInfoClient * >( this )->LookupDynamicModel( modelindex );
return GetBaseLocalClient().GetModel( modelindex );}
int CModelInfoClient::LookupPrecachedModelIndex( const char *name ) const{ return GetBaseLocalClient().LookupModelIndex( name );}
//-----------------------------------------------------------------------------
// Sets/gets a map-specified fade range
//-----------------------------------------------------------------------------
void CModelInfoClient::SetScreenFadeRange( float flMinSize, float flMaxSize, ScreenFadeInfo_t *pFade ){ pFade->m_flMinScreenWidth = flMinSize; pFade->m_flMaxScreenWidth = flMaxSize; if ( pFade->m_flMaxScreenWidth <= pFade->m_flMinScreenWidth ) { pFade->m_flMaxScreenWidth = pFade->m_flMinScreenWidth; }
if (pFade->m_flMaxScreenWidth != pFade->m_flMinScreenWidth) { pFade->m_flFalloffFactor = 255.0f / (pFade->m_flMaxScreenWidth - pFade->m_flMinScreenWidth); } else { pFade->m_flFalloffFactor = 255.0f; }}
void CModelInfoClient::SetLevelScreenFadeRange( float flMinSize, float flMaxSize ){ SetScreenFadeRange( flMinSize, flMaxSize, &m_LevelFade );}
void CModelInfoClient::GetLevelScreenFadeRange( float *pMinArea, float *pMaxArea ) const{ *pMinArea = m_LevelFade.m_flMinScreenWidth; *pMaxArea = m_LevelFade.m_flMaxScreenWidth;}
//-----------------------------------------------------------------------------
// Sets/gets a map-specified per-view fade range
//-----------------------------------------------------------------------------
void CModelInfoClient::SetViewScreenFadeRange( float flMinSize, float flMaxSize ){ SetScreenFadeRange( flMinSize, flMaxSize, &m_ViewFade );}
//-----------------------------------------------------------------------------
// Computes fade alpha based on distance fade + screen fade
//-----------------------------------------------------------------------------
inline unsigned char CModelInfoClient::ComputeScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale, const ScreenFadeInfo_t &fade ) const{ if ( ( fade.m_flMinScreenWidth <= 0 ) || (flFadeScale <= 0.0f) ) return 255;
CMatRenderContextPtr pRenderContext( materials );
float flPixelWidth = pRenderContext->ComputePixelWidthOfSphere( vecAbsOrigin, flRadius ) / flFadeScale;
unsigned char alpha = 0; if ( flPixelWidth > fade.m_flMinScreenWidth ) { if ( (fade.m_flMaxScreenWidth >= 0) && (flPixelWidth < fade.m_flMaxScreenWidth) ) { int nAlpha = fade.m_flFalloffFactor * (flPixelWidth - fade.m_flMinScreenWidth); alpha = clamp( nAlpha, 0, 255 ); } else { alpha = 255; } }
return alpha;}
unsigned char CModelInfoClient::ComputeLevelScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale ) const{ return ComputeScreenFade( vecAbsOrigin, flRadius, flFadeScale, m_LevelFade );}
unsigned char CModelInfoClient::ComputeViewScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale ) const{ return ComputeScreenFade( vecAbsOrigin, flRadius, flFadeScale, m_ViewFade );}
//-----------------------------------------------------------------------------
// A method to get the material color + texture coordinate
//-----------------------------------------------------------------------------
IMaterial* BrushModel_GetLightingAndMaterial( const Vector &start, const Vector &end, Vector &diffuseLightColor, Vector &baseColor){ float textureS, textureT; IMaterial *material;
// TEMP initialize these values until we can find why R_LightVec is not assigning values to them
textureS = 0; textureT = 0;
SurfaceHandle_t surfID = R_LightVec( start, end, true, diffuseLightColor, &textureS, &textureT ); if( !IS_SURF_VALID( surfID ) || !MSurf_TexInfo( surfID ) ) {// ConMsg( "didn't hit anything\n" );
return 0; } else { material = MSurf_TexInfo( surfID )->material; material->GetLowResColorSample( textureS, textureT, baseColor.Base() );// ConMsg( "%s: diff: %f %f %f base: %f %f %f\n", material->GetName(), diffuseLightColor[0], diffuseLightColor[1], diffuseLightColor[2], baseColor[0], baseColor[1], baseColor[2] );
return material; }}
void CModelInfoClient::GetModelMaterialColorAndLighting( const model_t *model, const Vector & origin, const QAngle & angles, trace_t* pTrace, Vector& lighting, Vector& matColor ){ switch( model->type ) { case mod_brush: { Vector origin_l, delta, delta_l; VectorSubtract( pTrace->endpos, pTrace->startpos, delta );
// subtract origin offset
VectorSubtract (pTrace->startpos, origin, origin_l);
// rotate start and end into the models frame of reference
if (angles[0] || angles[1] || angles[2]) { Vector forward, right, up; AngleVectors (angles, &forward, &right, &up);
// transform the direction into the local space of this entity
delta_l[0] = DotProduct (delta, forward); delta_l[1] = -DotProduct (delta, right); delta_l[2] = DotProduct (delta, up); } else { VectorCopy( delta, delta_l ); }
Vector end_l; VectorMA( origin_l, 1.1f, delta_l, end_l );
R_LightVecUseModel( ( model_t * )model ); BrushModel_GetLightingAndMaterial( origin_l, end_l, lighting, matColor ); R_LightVecUseModel(); return; }
case mod_studio: { // FIXME: Need some way of getting the material!
matColor.Init( 0.5f, 0.5f, 0.5f );
// Get the lighting at the point
LightingState_t lightingState; LightcacheGetDynamic_Stats stats; LightcacheGetDynamic( pTrace->endpos, lightingState, stats, NULL, LIGHTCACHEFLAGS_STATIC|LIGHTCACHEFLAGS_DYNAMIC|LIGHTCACHEFLAGS_LIGHTSTYLE|LIGHTCACHEFLAGS_ALLOWFAST ); // Convert the light parameters into something studiorender can digest
LightDesc_t desc[MAXLOCALLIGHTS]; int count = 0; for (int i = 0; i < lightingState.numlights; ++i) { if (WorldLightToMaterialLight( lightingState.locallight[i], desc[count] )) { ++count; } }
// Ask studiorender to figure out the lighting
g_pStudioRender->ComputeLighting( lightingState.r_boxcolor, count, desc, pTrace->endpos, pTrace->plane.normal, lighting ); return; } }}
int CModelInfoClient::RegisterDynamicModel( const char *name, bool bClientSide ){ // Clients cannot register non-client-side dynamic models!
Assert( bClientSide ); if ( !bClientSide ) return -1;
char buf[256]; V_strncpy( buf, name, ARRAYSIZE(buf) ); V_RemoveDotSlashes( buf, '/' ); name = buf;
Assert( V_strstr( name, ".mdl" ) != NULL );
// Already known? bClientSide should always be true and is asserted above.
int index = GetModelClientSideIndex( name ); if ( index != -1 ) return index;
// Lookup (or create) model_t* and register it to get a stable iterator index
model_t* pModel = modelloader->GetDynamicModel( name, true ); Assert( pModel ); UtlHashHandle_t localidx = m_ClientDynamicModels.Insert( pModel ); Assert( m_ClientDynamicModels.Count() < ((32767 >> 1) - 2) ); Assert( MODEL_TO_CLIENTSIDE( (short) CLIENTSIDE_TO_MODEL( localidx ) ) == (int) localidx ); return CLIENTSIDE_TO_MODEL( localidx );}
int CModelInfoClient::RegisterCombinedDynamicModel( const char *pszName, MDLHandle_t Handle ){ int index = GetModelClientSideIndex( pszName ); if ( index != -1 ) { model_t *pModel = LookupDynamicModel( index );
// pModel->studio = MDLHANDLE_INVALID;
modelloader->UpdateDynamicCombinedModel( pModel, Handle, true );
return index; }
// Lookup (or create) model_t* and register it to get a stable iterator index
model_t* pModel = modelloader->GetDynamicCombinedModel( pszName, true ); pModel->studio = MDLHANDLE_INVALID; modelloader->UpdateDynamicCombinedModel( pModel, Handle, true ); Assert( pModel ); UtlHashHandle_t localidx = m_ClientDynamicModels.Insert( pModel ); Assert( m_ClientDynamicModels.Count() < ((32767 >> 1) - 2) ); Assert( MODEL_TO_CLIENTSIDE( (short) CLIENTSIDE_TO_MODEL( localidx ) ) == (int) localidx ); return CLIENTSIDE_TO_MODEL( localidx );}
void CModelInfoClient::UpdateCombinedDynamicModel( int nModelIndex, MDLHandle_t Handle ){ model_t *pModel = LookupDynamicModel( nModelIndex ); if ( pModel ) { modelloader->UpdateDynamicCombinedModel( pModel, Handle, true ); }}
int CModelInfoClient::BeginCombinedModel( const char *pszName, bool bReuseExisting ){ int iBaseModelIndex = GetModelClientSideIndex( pszName );
if ( iBaseModelIndex == -1 && !bReuseExisting ) { return -1; }
MDLHandle_t hHandle = g_pMDLCache->CreateCombinedModel( pszName ); if ( hHandle == MDLHANDLE_INVALID ) { return -1; }
if ( iBaseModelIndex == -1 ) { iBaseModelIndex = RegisterCombinedDynamicModel( pszName, hHandle ); } else { model_t *pModel = LookupDynamicModel( iBaseModelIndex ); modelloader->UpdateDynamicCombinedModel( pModel, hHandle, true ); }
return iBaseModelIndex;}
bool CModelInfoClient::SetCombineModels( int nModelIndex, const CUtlVector< SCombinerModelInput_t > &vecModelsToCombine ){ model_t *pModel = LookupDynamicModel( nModelIndex );
return modelloader->SetCombineModels( pModel, vecModelsToCombine );}
bool CModelInfoClient::FinishCombinedModel( int nModelIndex, CombinedModelLoadedCallback pFunc, void *pUserData ){ model_t *pModel = LookupDynamicModel( nModelIndex );
return modelloader->FinishCombinedModel( pModel, pFunc, pUserData );}
void CModelInfoClient::ReleaseCombinedModel( int nModelIndex ){ model_t *pModel = LookupDynamicModel( nModelIndex );
if ( pModel ) { modelloader->ReleaseDynamicModel( pModel, true ); m_ClientDynamicModels.Remove( pModel ); }}
void CModelInfoClient::OnDynamicModelStringTableChanged( int nStringIndex, const char *pString, const void *pData ){ // Do a lookup to force an immediate insertion into our local lookup tables
model_t* pModel = LookupDynamicModel( NETDYNAMIC_TO_MODEL( nStringIndex ) );
// Notify model loader that the server-side state may have changed
bool bServerLoaded = pData && ( *(char*)pData != 0 ); modelloader->Client_OnServerModelStateChanged( pModel, bServerLoaded );}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
model_t *CModelInfoClient::ReferenceModel( const char *name ){ return modelloader->ReferenceModel( name, IModelLoader::FMODELLOADER_REFERENCEMASK );}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CModelInfoClient::UnreferenceModel( model_t *model ){ modelloader->UnreferenceModel( model, IModelLoader::FMODELLOADER_REFERENCEMASK );}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CModelInfoClient::UnloadUnreferencedModels( void ){ modelloader->UnloadUnreferencedModels();}
void CModelInfoClient::UpdateViewWeaponModelCache( const char **ppWeaponModels, int nWeaponModels ){ modelloader->UpdateViewWeaponModelCache( ppWeaponModels, nWeaponModels );}
void CModelInfoClient::TouchWorldWeaponModelCache( const char **ppWeaponModels, int nWeaponModels ){ modelloader->TouchWorldWeaponModelCache( ppWeaponModels, nWeaponModels );}
static CModelInfoClient g_ModelInfoClient;EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CModelInfoClient, IVModelInfoClient, VMODELINFO_CLIENT_INTERFACE_VERSION, g_ModelInfoClient );
// Expose IVModelInfo to the engine
IVModelInfoClient *modelinfoclient = &g_ModelInfoClient;#endif
|
