1HEADmaster

1 files changed, 249 insertions, 0 deletions

diff --git a/engine/modelloader.h b/engine/modelloader.h
new file mode 100644
index 0000000..f25555f
--- /dev/null
+++ b/engine/modelloader.h
@@ -0,0 +1,249 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( MOD_LOADER_H )
+#define MOD_LOADER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+struct model_t;
+class IMaterial;
+class IFileList;
+class IModelLoadCallback;
+
+#include "utlmemory.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+abstract_class IModelLoader
+{
+public:
+	enum REFERENCETYPE
+	{
+		// The name is allocated, but nothing else is in memory or being referenced
+		FMODELLOADER_NOTLOADEDORREFERENCED = 0,
+		// The model has been loaded into memory
+		FMODELLOADER_LOADED	= (1<<0),
+
+		// The model is being referenced by the server code
+		FMODELLOADER_SERVER = (1<<1),
+		// The model is being referenced by the client code
+		FMODELLOADER_CLIENT = (1<<2),
+		// The model is being referenced in the client .dll
+		FMODELLOADER_CLIENTDLL = (1<<3),
+		// The model is being referenced by static props
+		FMODELLOADER_STATICPROP	= (1<<4),
+		// The model is a detail prop
+		FMODELLOADER_DETAILPROP = (1<<5),
+		// The model is dynamically loaded
+		FMODELLOADER_DYNSERVER = (1<<6),
+		FMODELLOADER_DYNCLIENT = (1<<7),
+		FMODELLOADER_DYNAMIC = FMODELLOADER_DYNSERVER | FMODELLOADER_DYNCLIENT,
+
+		FMODELLOADER_REFERENCEMASK = (FMODELLOADER_SERVER | FMODELLOADER_CLIENT | FMODELLOADER_CLIENTDLL | FMODELLOADER_STATICPROP | FMODELLOADER_DETAILPROP | FMODELLOADER_DYNAMIC ),
+
+		// The model was touched by the preload method
+		FMODELLOADER_TOUCHED_BY_PRELOAD = (1<<15),
+		// The model was loaded by the preload method, a postload fixup is required
+		FMODELLOADER_LOADED_BY_PRELOAD = (1<<16),
+		// The model touched its materials as part of its load
+		FMODELLOADER_TOUCHED_MATERIALS = (1<<17),
+	};
+
+	enum ReloadType_t
+	{
+		RELOAD_LOD_CHANGED = 0,
+		RELOAD_EVERYTHING,
+		RELOAD_REFRESH_MODELS,
+	};
+
+	// Start up modelloader subsystem
+	virtual void		Init( void ) = 0;
+	virtual void		Shutdown( void ) = 0;
+
+	virtual int			GetCount( void ) = 0;
+	virtual model_t		*GetModelForIndex( int i ) = 0;
+
+	// Look up name for model
+	virtual const char *GetName( const model_t *model ) = 0;
+
+	// Check for extra data, reload studio model if needed
+	virtual void		*GetExtraData( model_t *model ) = 0;
+
+	// Get disk size for model
+	virtual int			GetModelFileSize( const char *name ) = 0;
+
+	// Finds the model, and loads it if it isn't already present.  Updates reference flags
+	virtual model_t		*GetModelForName( const char *name, REFERENCETYPE referencetype ) = 0;
+	virtual model_t		*ReferenceModel( const char *name, REFERENCETYPE referencetype ) = 0;
+	// Unmasks the referencetype field for the model
+	virtual void		UnreferenceModel( model_t *model, REFERENCETYPE referencetype ) = 0;
+	// Unmasks the specified reference type across all models
+	virtual void		UnreferenceAllModels( REFERENCETYPE referencetype ) = 0;
+	// Set all models to last loaded on server count -1
+	virtual void		ResetModelServerCounts() = 0;
+
+	// For any models with referencetype blank, frees all memory associated with the model
+	//  and frees up the models slot
+	virtual void		UnloadUnreferencedModels( void ) = 0;
+	virtual void		PurgeUnusedModels( void ) = 0;
+	virtual void		UnloadModel( model_t *pModel ) = 0;
+
+	// On the client only, there is some information that is computed at the time we are just
+	//  about to render the map the first time.  If we don't change/unload the map, then we
+	//  shouldn't have to recompute it each time we reconnect to the same map
+	virtual bool		Map_GetRenderInfoAllocated( void ) = 0;
+	virtual void		Map_SetRenderInfoAllocated( bool allocated ) = 0;
+
+	// Load all the displacements for rendering. Set bRestoring to true if we're recovering from an alt+tab.
+	virtual void		Map_LoadDisplacements( model_t *model, bool bRestoring ) = 0;
+
+	// Print which models are in the cache/known
+	virtual void		Print( void ) = 0;
+
+	// Validate version/header of a .bsp file
+	virtual bool		Map_IsValid( char const *mapname, bool bQuiet = false ) = 0;
+
+	// Recomputes surface flags
+	virtual void		RecomputeSurfaceFlags( model_t *mod ) = 0;
+
+	// Reloads all models
+	virtual void		Studio_ReloadModels( ReloadType_t reloadType ) = 0;
+
+	// Is a model loaded?
+	virtual bool		IsLoaded( const model_t *mod ) = 0;
+
+	virtual bool		LastLoadedMapHasHDRLighting( void ) = 0;
+
+	// See CL_HandlePureServerWhitelist for what this is for.
+	virtual void ReloadFilesInList( IFileList *pFilesToReload ) = 0;
+
+	virtual const char *GetActiveMapName( void ) = 0;
+
+	// Called by app system once per frame to poll and update dynamic models
+	virtual void		UpdateDynamicModels() = 0;
+
+	// Called by server and client engine code to flush unreferenced dynamic models
+	virtual void		FlushDynamicModels() = 0;
+
+	// Called by server and client engine code to flush unreferenced dynamic models
+	virtual void		ForceUnloadNonClientDynamicModels() = 0;
+
+	// Called by client code to load dynamic models, instead of GetModelForName.
+	virtual model_t		*GetDynamicModel( const char *name, bool bClientOnly ) = 0;
+
+	// Called by client code to query dynamic model state
+	virtual bool		IsDynamicModelLoading( model_t *pModel, bool bClientOnly ) = 0;
+
+	// Called by client code to refcount dynamic models
+	virtual void		AddRefDynamicModel( model_t *pModel, bool bClientSideRef ) = 0;
+	virtual void		ReleaseDynamicModel( model_t *pModel, bool bClientSideRef ) = 0;
+
+	// Called by client code
+	virtual bool		RegisterModelLoadCallback( model_t *pModel, bool bClientOnly, IModelLoadCallback *pCallback, bool bCallImmediatelyIfLoaded = true ) = 0;
+
+	// Called by client code or IModelLoadCallback destructor
+	virtual void		UnregisterModelLoadCallback( model_t *pModel, bool bClientOnly, IModelLoadCallback *pCallback ) = 0;
+
+	virtual void		Client_OnServerModelStateChanged( model_t *pModel, bool bServerLoaded ) = 0;
+};
+
+extern IModelLoader *modelloader;
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads the lump to temporary memory and automatically cleans up the
+//  memory when it goes out of scope.
+//-----------------------------------------------------------------------------
+
+class CMapLoadHelper
+{
+public:
+						CMapLoadHelper( int lumpToLoad );
+						~CMapLoadHelper( void );
+
+	// Get raw memory pointer
+	byte				*LumpBase( void );
+	int					LumpSize( void );
+	int					LumpOffset( void );
+	int					LumpVersion() const;
+	const char			*GetMapName( void );
+	char				*GetLoadName( void );
+	struct worldbrushdata_t	*GetMap( void );
+
+	// Global setup/shutdown
+	static void			Init( model_t *pMapModel, const char *pLoadname );
+	static void			InitFromMemory( model_t *pMapModel, const void *pData, int nDataSize );
+	static void			Shutdown( void );
+	static int			GetRefCount( void );
+	
+	// Free the lighting lump (increases free memory during loading on 360)
+	static void			FreeLightingLump();
+
+	// Returns the size of a particular lump without loading it
+	static int			LumpSize( int lumpId );
+	static int			LumpOffset( int lumpId );
+
+	// Loads one element in a lump.
+	void				LoadLumpElement( int nElemIndex, int nElemSize, void *pData );
+	void				LoadLumpData( int offset, int size, void *pData );
+
+private:
+	int					m_nLumpSize;
+	int					m_nLumpOffset;
+	int					m_nLumpVersion;
+	byte				*m_pRawData;
+	byte				*m_pData;
+	byte				*m_pUncompressedData;
+
+	// Handling for lump files
+	int					m_nLumpID;
+	char				m_szLumpFilename[MAX_PATH];
+};
+
+//-----------------------------------------------------------------------------
+// Recomputes translucency for the model...
+//-----------------------------------------------------------------------------
+
+void Mod_RecomputeTranslucency( model_t* mod, int nSkin, int nBody, void /*IClientRenderable*/ *pClientRenderable, float fInstanceAlphaModulate );
+
+//-----------------------------------------------------------------------------
+// game lumps
+//-----------------------------------------------------------------------------
+
+int Mod_GameLumpSize( int lumpId );
+int Mod_GameLumpVersion( int lumpId );
+bool Mod_LoadGameLump( int lumpId, void* pBuffer, int size );
+
+// returns the material count...
+int Mod_GetMaterialCount( model_t* mod );
+
+// returns the first n materials.
+int Mod_GetModelMaterials( model_t* mod, int count, IMaterial** ppMaterial );
+
+bool Mod_MarkWaterSurfaces( model_t *pModel );
+
+void Mod_SetMaterialVarFlag( model_t *pModel, unsigned int flag, bool on );
+
+//-----------------------------------------------------------------------------
+// Hooks the cache notify into the MDL cache system 
+//-----------------------------------------------------------------------------
+void ConnectMDLCacheNotify( );
+void DisconnectMDLCacheNotify( );
+
+//-----------------------------------------------------------------------------
+// Initialize studiomdl state
+//-----------------------------------------------------------------------------
+void InitStudioModelState( model_t *pModel );
+
+extern bool g_bLoadedMapHasBakedPropLighting;
+extern bool g_bBakedPropLightingNoSeparateHDR;
+
+#endif // MOD_LOADER_H