//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//

#ifndef IVMODELINFO_H
#define IVMODELINFO_H

#ifdef _WIN32
#pragma once
#endif

#include "../tier0/dbg.h"
#include "../tier0/platform.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