1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#ifndef IVMODELINFO_H
#define IVMODELINFO_H
#ifdef _WIN32
#pragma once
#endif
#include "platform.h"
#include "dbg.h"
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
class IMaterial;
class KeyValues;
struct vcollide_t;
struct model_t;
class Vector;
class QAngle;
class CGameTrace;
struct cplane_t;
typedef CGameTrace trace_t;
struct studiohdr_t;
struct virtualmodel_t;
typedef unsigned char byte;
struct virtualterrainparams_t;
class CPhysCollide;
typedef unsigned short MDLHandle_t;
class CUtlBuffer;
class IClientRenderable;
//-----------------------------------------------------------------------------
// Purpose: a callback class that is notified when a model has finished loading
//-----------------------------------------------------------------------------
abstract_class IModelLoadCallback
{
public:
virtual void OnModelLoadComplete( const model_t* pModel ) = 0;
protected:
// Protected destructor so that nobody tries to delete via this interface.
// Automatically unregisters if the callback is destroyed while still pending.
~IModelLoadCallback();
};
//-----------------------------------------------------------------------------
// Purpose: Automate refcount tracking on a model index
//-----------------------------------------------------------------------------
class CRefCountedModelIndex
{
private:
int m_nIndex;
public:
CRefCountedModelIndex() : m_nIndex( -1 ) { }
~CRefCountedModelIndex() { Set( -1 ); }
CRefCountedModelIndex( const CRefCountedModelIndex& src ) : m_nIndex( -1 ) { Set( src.m_nIndex ); }
CRefCountedModelIndex& operator=( const CRefCountedModelIndex& src ) { Set( src.m_nIndex ); return *this; }
explicit CRefCountedModelIndex( int i ) : m_nIndex( -1 ) { Set( i ); }
CRefCountedModelIndex& operator=( int i ) { Set( i ); return *this; }
int Get() const { return m_nIndex; }
void Set( int i );
void Clear() { Set( -1 ); }
operator int () const { return m_nIndex; }
};
//-----------------------------------------------------------------------------
// Model info interface
//-----------------------------------------------------------------------------
// change this when the new version is incompatable with the old
#define VMODELINFO_CLIENT_INTERFACE_VERSION "VModelInfoClient006"
#define VMODELINFO_SERVER_INTERFACE_VERSION_3 "VModelInfoServer003"
#define VMODELINFO_SERVER_INTERFACE_VERSION "VModelInfoServer004"
// MODEL INDEX RULES
// If index >= 0, then index references the precached model string table
// If index == -1, then the model is invalid
// If index < -1, then the model is DYNAMIC and has a DYNAMIC INDEX of (-2 - index)
// - if the dynamic index is ODD, then the model is CLIENT ONLY
// and has a m_LocalDynamicModels lookup index of (dynamic index)>>1
// - if the dynamic index is EVEN, then the model is NETWORKED
// and has a dynamic model string table index of (dynamic index)>>1
inline bool IsDynamicModelIndex( int modelindex ) { return modelindex < -1; }
inline bool IsClientOnlyModelIndex( int modelindex ) { return modelindex < -1 && (modelindex & 1); }
abstract_class IVModelInfo
{
public:
virtual ~IVModelInfo( void ) { }
// Returns model_t* pointer for a model given a precached or dynamic model index.
virtual const model_t *GetModel( int modelindex ) = 0;
// Returns index of model by name for precached or known dynamic models.
// Does not adjust reference count for dynamic models.
virtual int GetModelIndex( const char *name ) const = 0;
// Returns name of model
virtual const char *GetModelName( const model_t *model ) const = 0;
virtual vcollide_t *GetVCollide( const model_t *model ) = 0;
virtual vcollide_t *GetVCollide( int modelindex ) = 0;
virtual void GetModelBounds( const model_t *model, Vector& mins, Vector& maxs ) const = 0;
virtual void GetModelRenderBounds( const model_t *model, Vector& mins, Vector& maxs ) const = 0;
virtual int GetModelFrameCount( const model_t *model ) const = 0;
virtual int GetModelType( const model_t *model ) const = 0;
virtual void *GetModelExtraData( const model_t *model ) = 0;
virtual bool ModelHasMaterialProxy( const model_t *model ) const = 0;
virtual bool IsTranslucent( model_t const* model ) const = 0;
virtual bool IsTranslucentTwoPass( const model_t *model ) const = 0;
virtual void RecomputeTranslucency( const model_t *model, int nSkin, int nBody, void /*IClientRenderable*/ *pClientRenderable, float fInstanceAlphaModulate=1.0f) = 0;
virtual int GetModelMaterialCount( const model_t* model ) const = 0;
virtual void GetModelMaterials( const model_t *model, int count, IMaterial** ppMaterial ) = 0;
virtual bool IsModelVertexLit( const model_t *model ) const = 0;
virtual const char *GetModelKeyValueText( const model_t *model ) = 0;
virtual bool GetModelKeyValue( const model_t *model, CUtlBuffer &buf ) = 0; // supports keyvalue blocks in submodels
virtual float GetModelRadius( const model_t *model ) = 0;
virtual const studiohdr_t *FindModel( const studiohdr_t *pStudioHdr, void **cache, const char *modelname ) const = 0;
virtual const studiohdr_t *FindModel( void *cache ) const = 0;
virtual virtualmodel_t *GetVirtualModel( const studiohdr_t *pStudioHdr ) const = 0;
virtual byte *GetAnimBlock( const studiohdr_t *pStudioHdr, int iBlock ) const = 0;
// Available on client only!!!
virtual void GetModelMaterialColorAndLighting( const model_t *model, Vector const& origin,
QAngle const& angles, trace_t* pTrace,
Vector& lighting, Vector& matColor ) = 0;
virtual void GetIlluminationPoint( const model_t *model, IClientRenderable *pRenderable, Vector const& origin,
QAngle const& angles, Vector* pLightingCenter ) = 0;
virtual int GetModelContents( int modelIndex ) = 0;
virtual studiohdr_t *GetStudiomodel( const model_t *mod ) = 0;
virtual int GetModelSpriteWidth( const model_t *model ) const = 0;
virtual int GetModelSpriteHeight( const model_t *model ) const = 0;
// Sets/gets a map-specified fade range (client only)
virtual void SetLevelScreenFadeRange( float flMinSize, float flMaxSize ) = 0;
virtual void GetLevelScreenFadeRange( float *pMinArea, float *pMaxArea ) const = 0;
// Sets/gets a map-specified per-view fade range (client only)
virtual void SetViewScreenFadeRange( float flMinSize, float flMaxSize ) = 0;
// Computes fade alpha based on distance fade + screen fade (client only)
virtual unsigned char ComputeLevelScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale ) const = 0;
virtual unsigned char ComputeViewScreenFade( const Vector &vecAbsOrigin, float flRadius, float flFadeScale ) const = 0;
// both client and server
virtual int GetAutoplayList( const studiohdr_t *pStudioHdr, unsigned short **pAutoplayList ) const = 0;
// Gets a virtual terrain collision model (creates if necessary)
// NOTE: This may return NULL if the terrain model cannot be virtualized
virtual CPhysCollide *GetCollideForVirtualTerrain( int index ) = 0;
virtual bool IsUsingFBTexture( const model_t *model, int nSkin, int nBody, void /*IClientRenderable*/ *pClientRenderable ) const = 0;
// Obsolete methods. These are left in to maintain binary compatibility with clients using the IVModelInfo old version.
virtual const model_t *FindOrLoadModel( const char *name ) { Warning( "IVModelInfo::FindOrLoadModel is now obsolte.\n" ); return NULL; }
virtual void InitDynamicModels( ) { Warning( "IVModelInfo::InitDynamicModels is now obsolte.\n" ); }
virtual void ShutdownDynamicModels( ) { Warning( "IVModelInfo::ShutdownDynamicModels is now obsolte.\n" ); }
virtual void AddDynamicModel( const char *name, int nModelIndex = -1 ) { Warning( "IVModelInfo::AddDynamicModel is now obsolte.\n" ); }
virtual void ReferenceModel( int modelindex ) { Warning( "IVModelInfo::ReferenceModel is now obsolte.\n" ); }
virtual void UnreferenceModel( int modelindex ) { Warning( "IVModelInfo::UnreferenceModel is now obsolte.\n" ); }
virtual void CleanupDynamicModels( bool bForce = false ) { Warning( "IVModelInfo::CleanupDynamicModels is now obsolte.\n" ); }
virtual MDLHandle_t GetCacheHandle( const model_t *model ) const = 0;
// Returns planes of non-nodraw brush model surfaces
virtual int GetBrushModelPlaneCount( const model_t *model ) const = 0;
virtual void GetBrushModelPlane( const model_t *model, int nIndex, cplane_t &plane, Vector *pOrigin ) const = 0;
virtual int GetSurfacepropsForVirtualTerrain( int index ) = 0;
// Poked by engine host system
virtual void OnLevelChange() = 0;
virtual int GetModelClientSideIndex( const char *name ) const = 0;
// Returns index of model by name, dynamically registered if not already known.
virtual int RegisterDynamicModel( const char *name, bool bClientSide ) = 0;
virtual bool IsDynamicModelLoading( int modelIndex ) = 0;
virtual void AddRefDynamicModel( int modelIndex ) = 0;
virtual void ReleaseDynamicModel( int modelIndex ) = 0;
// Registers callback for when dynamic model has finished loading.
// Automatically adds reference, pair with ReleaseDynamicModel.
virtual bool RegisterModelLoadCallback( int modelindex, IModelLoadCallback* pCallback, bool bCallImmediatelyIfLoaded = true ) = 0;
virtual void UnregisterModelLoadCallback( int modelindex, IModelLoadCallback* pCallback ) = 0;
};
typedef IVModelInfo IVModelInfo003;
abstract_class IVModelInfoClient : public IVModelInfo
{
public:
virtual void OnDynamicModelsStringTableChange( int nStringIndex, const char *pString, const void *pData ) = 0;
// For tools only!
virtual const model_t *FindOrLoadModel( const char *name ) = 0;
};
struct virtualterrainparams_t
{
// UNDONE: Add grouping here, specified in BSP file? (test grouping to see if this is necessary)
int index;
};
//-----------------------------------------------------------------------------
// Purpose: Force removal from callback list on destruction to avoid crashes.
//-----------------------------------------------------------------------------
inline IModelLoadCallback::~IModelLoadCallback()
{
#ifdef CLIENT_DLL
extern IVModelInfoClient *modelinfo;
#else
extern IVModelInfo *modelinfo;
#endif
if ( modelinfo )
{
modelinfo->UnregisterModelLoadCallback( -1, this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Automate refcount tracking on a model index
//-----------------------------------------------------------------------------
inline void CRefCountedModelIndex::Set( int i )
{
#ifdef CLIENT_DLL
extern IVModelInfoClient *modelinfo;
#else
extern IVModelInfo *modelinfo;
#endif
if ( i == m_nIndex )
return;
modelinfo->AddRefDynamicModel( i );
modelinfo->ReleaseDynamicModel( m_nIndex );
m_nIndex = i;
}
#endif // IVMODELINFO_H
|