//========= 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

};

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

// 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

};

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

// 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 )

}

#endif // IVMODELINFO_H