1309 lines
41 KiB
C++
1309 lines
41 KiB
C++
//========= Copyright 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 "utldict.h"
|
|
#include "filesystem_engine.h"
|
|
#include "client.h"
|
|
#include "sys_dll.h"
|
|
#include "gl_rsurf.h"
|
|
#include "utlvector.h"
|
|
#include "utlhashtable.h"
|
|
#include "utlsymbol.h"
|
|
#include "ModelInfo.h"
|
|
#include "networkstringtable.h" // for Lock()
|
|
|
|
#ifndef SWDS
|
|
#include "demo.h"
|
|
#endif
|
|
|
|
// 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;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// private extension of CNetworkStringTable to correct lack of Lock retval
|
|
//-----------------------------------------------------------------------------
|
|
class CNetworkStringTable_LockOverride : public CNetworkStringTable
|
|
{
|
|
private:
|
|
CNetworkStringTable_LockOverride(); // no impl
|
|
~CNetworkStringTable_LockOverride(); // no impl
|
|
CNetworkStringTable_LockOverride(const CNetworkStringTable_LockOverride &); // no impl
|
|
CNetworkStringTable_LockOverride& operator=(const CNetworkStringTable_LockOverride &); // no impl
|
|
public:
|
|
bool LockWithRetVal( bool bLock ) { bool bWasLocked = m_bLocked; Lock(bLock); return bWasLocked; }
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// shared implementation of IVModelInfo
|
|
//-----------------------------------------------------------------------------
|
|
abstract_class CModelInfo : public IVModelInfoClient
|
|
{
|
|
public:
|
|
// GetModel, RegisterDynamicModel(name) are in CModelInfoClient/CModelInfoServer
|
|
virtual int GetModelIndex( const char *name ) const;
|
|
virtual int GetModelClientSideIndex( const char *name ) const;
|
|
|
|
virtual bool RegisterModelLoadCallback( int modelindex, IModelLoadCallback* pCallback, bool bCallImmediatelyIfLoaded );
|
|
virtual void UnregisterModelLoadCallback( int modelindex, IModelLoadCallback* pCallback );
|
|
virtual bool IsDynamicModelLoading( int modelIndex );
|
|
virtual void AddRefDynamicModel( int modelIndex );
|
|
virtual void ReleaseDynamicModel( int modelIndex );
|
|
|
|
virtual void OnLevelChange();
|
|
|
|
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 IsTranslucentTwoPass( const model_t *model ) const;
|
|
virtual void RecomputeTranslucency( const model_t *model, int nSkin, int nBody, void /*IClientRenderable*/ *pClientRenderable, float fInstanceAlphaModulate);
|
|
virtual int GetModelMaterialCount( const model_t *model ) const;
|
|
virtual void 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 );
|
|
vcollide_t *GetVCollide( const model_t *model );
|
|
vcollide_t *GetVCollide( int modelIndex );
|
|
virtual const char *GetModelKeyValueText( const model_t *model );
|
|
virtual bool GetModelKeyValue( const model_t *model, CUtlBuffer &buf );
|
|
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 iBlock ) 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;
|
|
|
|
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 Mix32HashFunctor()( (uint32)( p->fnHandle ) ); }
|
|
uint operator()( FileNameHandle_t fn ) const { return Mix32HashFunctor()( (uint32) 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;
|
|
};
|
|
|
|
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]->strName, name ) == 0 );
|
|
return NETDYNAMIC_TO_MODEL( netdyn );
|
|
}
|
|
|
|
#if defined( DEMO_BACKWARDCOMPATABILITY ) && !defined( SWDS )
|
|
// dynamic model tables in old system did not have a full path with "models/" prefix
|
|
if ( V_strnicmp( name, "models/", 7 ) == 0 && demoplayer && demoplayer->IsPlayingBack() && demoplayer->GetProtocolVersion() < PROTOCOL_VERSION_20 )
|
|
{
|
|
netdyn = pTable->FindStringIndex( name + 7 );
|
|
if ( netdyn != INVALID_STRING_INDEX )
|
|
{
|
|
Assert( !m_NetworkedDynamicModels.IsValidIndex( netdyn ) || V_strcmp( m_NetworkedDynamicModels[netdyn]->strName, name ) == 0 );
|
|
return NETDYNAMIC_TO_MODEL( netdyn );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return GetModelClientSideIndex( name );
|
|
}
|
|
|
|
int CModelInfo::GetModelClientSideIndex( const char *name ) const
|
|
{
|
|
if ( m_ClientDynamicModels.Count() != 0 )
|
|
{
|
|
FileNameHandle_t file = g_pFullFileSystem->FindFileName( name );
|
|
if ( file != FILENAMEHANDLE_INVALID )
|
|
{
|
|
UtlHashHandle_t h = m_ClientDynamicModels.Find( file );
|
|
if ( h != m_ClientDynamicModels.InvalidHandle() )
|
|
{
|
|
Assert( V_strcmp( m_ClientDynamicModels[h]->strName, 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 );
|
|
|
|
#if defined( DEMO_BACKWARDCOMPATABILITY ) && !defined( SWDS )
|
|
// dynamic model tables in old system did not have a full path with "models/" prefix
|
|
char fixupBuf[MAX_PATH];
|
|
if ( V_strnicmp( name, "models/", 7 ) != 0 && demoplayer && demoplayer->IsPlayingBack() && demoplayer->GetProtocolVersion() < PROTOCOL_VERSION_20 )
|
|
{
|
|
V_snprintf( fixupBuf, MAX_PATH, "models/%s", name );
|
|
name = fixupBuf;
|
|
}
|
|
#endif
|
|
|
|
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 ), IsClientOnlyModelIndex( modelIndex ), 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, false, pCallback );
|
|
modelloader->UnregisterModelLoadCallback( NULL, true, pCallback );
|
|
}
|
|
else if ( IsDynamicModelIndex( modelIndex ) )
|
|
{
|
|
const model_t *pModel = LookupDynamicModel( modelIndex );
|
|
Assert( pModel );
|
|
if ( pModel )
|
|
{
|
|
modelloader->UnregisterModelLoadCallback( const_cast< model_t *>( pModel ), IsClientOnlyModelIndex( modelIndex ), pCallback );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool CModelInfo::IsDynamicModelLoading( int modelIndex )
|
|
{
|
|
model_t *pModel = LookupDynamicModel( modelIndex );
|
|
return pModel && modelloader->IsDynamicModelLoading( pModel, IsClientOnlyModelIndex( modelIndex ) );
|
|
}
|
|
|
|
|
|
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();
|
|
}
|
|
|
|
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
|
|
{
|
|
if ( !model )
|
|
return -1;
|
|
|
|
if ( model->type == mod_bad )
|
|
{
|
|
if ( m_ClientDynamicModels.Find( (model_t*) model ) != m_ClientDynamicModels.InvalidHandle() )
|
|
return mod_studio;
|
|
INetworkStringTable* pTable = GetDynamicModelStringTable();
|
|
if ( pTable && pTable->FindStringIndex( model->strName ) != INVALID_STRING_INDEX )
|
|
return mod_studio;
|
|
|
|
#if defined( DEMO_BACKWARDCOMPATABILITY ) && !defined( SWDS )
|
|
// dynamic model tables in old system did not have a full path with "models/" prefix
|
|
if ( pTable && demoplayer && demoplayer->IsPlayingBack() && demoplayer->GetProtocolVersion() < PROTOCOL_VERSION_20 &&
|
|
V_strnicmp( model->strName, "models/", 7 ) == 0 && pTable->FindStringIndex( model->strName + 7 ) != INVALID_STRING_INDEX )
|
|
{
|
|
return mod_studio;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return model->type;
|
|
}
|
|
|
|
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( (MDLHandle_t)(int)cache&0xffff );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return virtualmodel_t block associated with model_t
|
|
//-----------------------------------------------------------------------------
|
|
virtualmodel_t *CModelInfo::GetVirtualModel( const studiohdr_t *pStudioHdr ) const
|
|
{
|
|
MDLHandle_t handle = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
|
|
return g_pMDLCache->GetVirtualModelFast( pStudioHdr, handle );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
byte *CModelInfo::GetAnimBlock( const studiohdr_t *pStudioHdr, int nBlock ) const
|
|
{
|
|
MDLHandle_t handle = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
|
|
return g_pMDLCache->GetAnimBlock( handle, nBlock );
|
|
}
|
|
|
|
int CModelInfo::GetAutoplayList( const studiohdr_t *pStudioHdr, unsigned short **pAutoplayList ) const
|
|
{
|
|
MDLHandle_t handle = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
|
|
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, (MDLHandle_t)(int)virtualModel&0xffff );
|
|
}
|
|
|
|
byte *studiohdr_t::GetAnimBlock( int i ) const
|
|
{
|
|
return g_pMDLCache->GetAnimBlock( (MDLHandle_t)(int)virtualModel&0xffff, i );
|
|
}
|
|
|
|
int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const
|
|
{
|
|
return g_pMDLCache->GetAutoplayList( (MDLHandle_t)(int)virtualModel&0xffff, pOut );
|
|
}
|
|
|
|
const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const
|
|
{
|
|
return g_pMDLCache->GetStudioHdr( (MDLHandle_t)(int)cache&0xffff );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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::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;
|
|
}
|
|
|
|
void CModelInfo::RecomputeTranslucency( const model_t *model, int nSkin, int nBody, void /*IClientRenderable*/ *pClientRenderable, float fInstanceAlphaModulate )
|
|
{
|
|
if ( model != NULL )
|
|
{
|
|
Mod_RecomputeTranslucency( (model_t *)model, nSkin, nBody, pClientRenderable, fInstanceAlphaModulate );
|
|
}
|
|
}
|
|
|
|
int CModelInfo::GetModelMaterialCount( const model_t *model ) const
|
|
{
|
|
if (!model)
|
|
return 0;
|
|
return Mod_GetMaterialCount( (model_t *)model );
|
|
}
|
|
|
|
void CModelInfo::GetModelMaterials( const model_t *model, int count, IMaterial** ppMaterials )
|
|
{
|
|
if (model)
|
|
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 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;
|
|
}
|
|
|
|
#if !defined( _RETAIL )
|
|
extern double g_flAccumulatedModelLoadTimeVCollideSync;
|
|
#endif
|
|
|
|
vcollide_t *CModelInfo::GetVCollide( const model_t *pModel )
|
|
{
|
|
if ( !pModel )
|
|
return NULL;
|
|
|
|
if ( pModel->type == mod_studio )
|
|
{
|
|
#if !defined( _RETAIL )
|
|
double t1 = Plat_FloatTime();
|
|
#endif
|
|
vcollide_t *col = g_pMDLCache->GetVCollide( pModel->studio );
|
|
#if !defined( _RETAIL )
|
|
double t2 = Plat_FloatTime();
|
|
g_flAccumulatedModelLoadTimeVCollideSync += ( t2 - t1 );
|
|
#endif
|
|
return col;
|
|
}
|
|
|
|
int i = GetModelIndex( GetModelName( pModel ) );
|
|
if ( i >= 0 )
|
|
{
|
|
return GetVCollide( i );
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
vcollide_t *CModelInfo::GetVCollide( int modelIndex )
|
|
{
|
|
// 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:
|
|
{
|
|
#if !defined( _RETAIL )
|
|
double t1 = Plat_FloatTime();
|
|
#endif
|
|
vcollide_t *col = g_pMDLCache->GetVCollide( pModel->studio );
|
|
#if !defined( _RETAIL )
|
|
double t2 = Plat_FloatTime();
|
|
g_flAccumulatedModelLoadTimeVCollideSync += ( t2 - t1 );
|
|
#endif
|
|
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();
|
|
}
|
|
|
|
|
|
|
|
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 );
|
|
}
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// implementation of IVModelInfo for server
|
|
//-----------------------------------------------------------------------------
|
|
class CModelInfoServer : public CModelInfo
|
|
{
|
|
public:
|
|
virtual int RegisterDynamicModel( const char *name, bool bClientSideOnly );
|
|
virtual const model_t *GetModel( int modelindex );
|
|
virtual const model_t *FindOrLoadModel( const char *name );
|
|
virtual void OnDynamicModelsStringTableChange( int nStringIndex, const char *pString, const void *pData );
|
|
|
|
virtual void GetModelMaterialColorAndLighting( const model_t *model, const Vector& origin,
|
|
const QAngle& angles, trace_t* pTrace, Vector& lighting, Vector& matColor );
|
|
|
|
protected:
|
|
virtual INetworkStringTable *GetDynamicModelStringTable() const;
|
|
virtual int LookupPrecachedModelIndex( const char *name ) const;
|
|
};
|
|
|
|
INetworkStringTable *CModelInfoServer::GetDynamicModelStringTable() const
|
|
{
|
|
return sv.GetDynamicModelsTable();
|
|
}
|
|
|
|
int CModelInfoServer::LookupPrecachedModelIndex( const char *name ) const
|
|
{
|
|
return sv.LookupModelIndex( name );
|
|
}
|
|
|
|
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, '/', true );
|
|
name = buf;
|
|
|
|
Assert( V_strnicmp( name, "models/", 7 ) == 0 && 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_LockOverride*>( pTable )->LockWithRetVal( 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 );
|
|
}
|
|
|
|
const model_t *CModelInfoServer::GetModel( int modelindex )
|
|
{
|
|
if ( IsDynamicModelIndex( modelindex ) )
|
|
return LookupDynamicModel( modelindex );
|
|
|
|
return sv.GetModel( modelindex );
|
|
}
|
|
|
|
void CModelInfoServer::OnDynamicModelsStringTableChange( int nStringIndex, const char *pString, const void *pData )
|
|
{
|
|
AssertMsg( false, "CModelInfoServer::OnDynamicModelsStringTableChange should never be called" );
|
|
}
|
|
|
|
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" );
|
|
}
|
|
|
|
const model_t *CModelInfoServer::FindOrLoadModel( const char *name )
|
|
{
|
|
AssertMsg( false, "CModelInfoServer::FindOrLoadModel should never be called" );
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static CModelInfoServer g_ModelInfoServer;
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CModelInfoServer, IVModelInfo003, VMODELINFO_SERVER_INTERFACE_VERSION_3, g_ModelInfoServer );
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CModelInfoServer, IVModelInfo, VMODELINFO_SERVER_INTERFACE_VERSION, g_ModelInfoServer );
|
|
|
|
// Expose IVModelInfo to the engine
|
|
IVModelInfo *modelinfo = &g_ModelInfoServer;
|
|
|
|
|
|
#ifndef SWDS
|
|
//-----------------------------------------------------------------------------
|
|
// implementation of IVModelInfo for client
|
|
//-----------------------------------------------------------------------------
|
|
class CModelInfoClient : public CModelInfo
|
|
{
|
|
public:
|
|
virtual int RegisterDynamicModel( const char *name, bool bClientSideOnly );
|
|
virtual const model_t *GetModel( int modelindex );
|
|
virtual const model_t *FindOrLoadModel( const char *name );
|
|
virtual void OnDynamicModelsStringTableChange( int nStringIndex, const char *pString, const void *pData );
|
|
|
|
// 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 void GetModelMaterialColorAndLighting( const model_t *model, const Vector& origin,
|
|
const QAngle& angles, trace_t* pTrace, Vector& lighting, Vector& matColor );
|
|
|
|
protected:
|
|
virtual INetworkStringTable *GetDynamicModelStringTable() const;
|
|
virtual int LookupPrecachedModelIndex( const char *name ) const;
|
|
|
|
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;
|
|
};
|
|
|
|
INetworkStringTable *CModelInfoClient::GetDynamicModelStringTable() const
|
|
{
|
|
return cl.m_pDynamicModelsTable;
|
|
}
|
|
|
|
int CModelInfoClient::LookupPrecachedModelIndex( const char *name ) const
|
|
{
|
|
return cl.LookupModelIndex( name );
|
|
}
|
|
|
|
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, '/', true );
|
|
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 );
|
|
}
|
|
|
|
const model_t *CModelInfoClient::GetModel( int modelindex )
|
|
{
|
|
if ( IsDynamicModelIndex( modelindex ) )
|
|
return LookupDynamicModel( modelindex );
|
|
|
|
return cl.GetModel( modelindex );
|
|
}
|
|
|
|
void CModelInfoClient::OnDynamicModelsStringTableChange( 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 ) : ( g_ClientGlobalVariables.network_protocol <= PROTOCOL_VERSION_20 );
|
|
modelloader->Client_OnServerModelStateChanged( pModel, bServerLoaded );
|
|
}
|
|
|
|
const model_t *CModelInfoClient::FindOrLoadModel( const char *name )
|
|
{
|
|
// 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 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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
|
|
{
|
|
if ( IsXbox() )
|
|
{
|
|
return 255;
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
if ( 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] );
|
|
}
|
|
else
|
|
{
|
|
baseColor.Init();
|
|
}
|
|
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, 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|