///////////////////////////////////////////////////////////////////////////////
//
//      ##  ######
//       ######  ###
//  ## ###############        Shark 3D Engine (www.shark3d.com)
//   ########## # # #
//    ########                Copyright (c) 1996-2006 Spinor GmbH.
//   ######### # # #          All rights reserved.
//  ##   ##########
//      ##
//
///////////////////////////////////////////////////////////////////////////////

//@cpp

#ifndef S3D_SHARK_MESH_LOADER_MODEL_H
#define S3D_SHARK_MESH_LOADER_MODEL_H

#include "../../interf/eng_model.h"
#include "../../../comp/core/comp_setup.h"
#include "../../../comp/core/comp_module.h"
#include "../../../comp/util/comp_util_serutil.h"
#include "../../../comp/util/comp_util_uniquebase.h"

#include <GeoLodLibraryDLL.h>


///////////////////////////////////////////////////////////////////////////////

typedef s3d_CSysInt32u s3d_CSharkMeshLoaderIdx;

typedef s3d_CDrvInt32uX4 s3d_CSharkMeshLoaderSubscr;

///////////////////////////////////////////////////////////////////////////////

class s3d_CSharkMeshLoaderLoader: public virtual s3d_CUtilEyeBase
{
public:
    virtual void LoaderPerform() = 0;
};

typedef s3d_CUtilEye<s3d_CSharkMeshLoaderLoader> s3d_CSharkMeshLoaderLoaderEye;

///////////////////////////////////////////////////////////////////////////////

class s3d_CSharkMeshLoaderChanged: public virtual s3d_CUtilEyeBase
{
public:
    virtual void ChangedPerform() = 0;
};

typedef s3d_CUtilEye<s3d_CSharkMeshLoaderChanged> s3d_CSharkMeshLoaderChangedEye;

///////////////////////////////////////////////////////////////////////////////

template<typename T>
struct s3d_CSharkMeshLoaderBank
        : public s3d_CUtilPtrBase,
        public s3d_CDrvBank
{
    s3d_CSysIntps m_Cnt;
    s3d_CUtilOwnArray<T> m_Data;
    s3d_CSharkMeshLoaderLoaderEye m_Loader;

    void Fetch(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
            s3d_CDrvBankContent &BankContent);
    s3d_CUtilPtrBase *GetOwner(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info);
};

///////////////////////////////////////////////////////////////////////////////

typedef s3d_CSharkMeshLoaderBank<s3d_CUtilVec2f> s3d_CSharkMeshLoaderBankVec2f;
typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderBankVec2f> s3d_CSharkMeshLoaderBankVec2fPtr;

typedef s3d_CSharkMeshLoaderBank<s3d_CUtilVec3f> s3d_CSharkMeshLoaderBankVec3f;
typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderBankVec3f> s3d_CSharkMeshLoaderBankVec3fPtr;

typedef s3d_CSharkMeshLoaderBank<s3d_CUtilVec4f> s3d_CSharkMeshLoaderBankVec4f;
typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderBankVec4f> s3d_CSharkMeshLoaderBankVec4fPtr;

typedef s3d_CSharkMeshLoaderBank<s3d_CSharkMeshLoaderIdx> s3d_CSharkMeshLoaderBankMeshIdx;
typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderBankMeshIdx> 
        s3d_CSharkMeshLoaderBankMeshIdxPtr;

typedef s3d_CSharkMeshLoaderBank<s3d_CUtilVec4f> s3d_CSharkMeshLoaderBankBoneWgh;
typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderBankBoneWgh> 
        s3d_CSharkMeshLoaderBankBoneWghPtr;

typedef s3d_CSharkMeshLoaderBank<s3d_CSharkMeshLoaderSubscr> 
        s3d_CSharkMeshLoaderBankBoneSubscr;
typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderBankBoneSubscr> 
        s3d_CSharkMeshLoaderBankBoneSubscrPtr;

typedef s3d_CSharkMeshLoaderBank<s3d_CDrvMeshPacket> s3d_CSharkMeshLoaderBankPacket;
typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderBankPacket> 
        s3d_CSharkMeshLoaderBankPacketPtr;

///////////////////////////////////////////////////////////////////////////////

struct s3d_CSharkMeshLoaderAttr
{
    // Cnt = m_FrmCnt * m_VertCnt:
    s3d_CDrvSigPtr m_BankSig;
    s3d_CSharkMeshLoaderBankVec2fPtr m_Bank;
};

///////////////////////////////////////////////////////////////////////////////

struct s3d_CSharkMeshLoaderTopol
{
    s3d_CDrvSigPtr m_TopolSig;

    s3d_CUtilInitInt m_VertCnt;
    s3d_CUtilInitInt m_VertEssCnt;

    s3d_CUtilInitInt m_IdxCnt;
    s3d_CUtilInitInt m_IdxEssCnt;

    s3d_CUtilInitInt m_BoneIdxCnt;
    s3d_CUtilInitInt m_BoneIdxEssCnt;

    s3d_CUtilInitInt m_PacketCnt;
    s3d_CUtilInitInt m_FamilyCnt;

    s3d_CUtilInitBool m_Closed;
    s3d_CUtilInitBool m_Sealed;

    // Cnt = m_FamilyCnt
    s3d_CUtilOwnArray<s3d_CEngMeshFamily> m_FamilyArray;

    // Cnt = m_PacketCnt
    s3d_CSharkMeshLoaderBankPacketPtr m_PacketBank;

    // Cnt = m_BoneIdxCnt
    s3d_CSharkMeshLoaderBankMeshIdxPtr m_BoneIdxBank;

    // Cnt = m_IdxCnt
    s3d_CSharkMeshLoaderBankMeshIdxPtr m_IdxBank;
    // Cnt = m_IdxCnt
    s3d_CSharkMeshLoaderBankMeshIdxPtr m_OppBank;
    // Cnt = m_IdxEssCnt
    s3d_CSharkMeshLoaderBankMeshIdxPtr m_NeighBank;
};

///////////////////////////////////////////////////////////////////////////////
/*
class s3d_CSharkMeshLoaderVariant
        : public s3d_CUtilPtrBase,
        public s3d_CSharkMeshLoaderLoader
{
public:
    s3d_CSharkMeshLoaderVariant(
            s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
            bool Bare,
            s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr, 
            s3d_CUtilStr_cr ResName, s3d_CSharkMeshLoaderChanged *Changed);
    ~s3d_CSharkMeshLoaderVariant();

    void GetMeshComposBase(
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage, 
            s3d_CEngMeshCompos &MeshCompos);
    void GetMeshComposFull(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage, 
            s3d_CEngModelCtx *ModelCtx,
            bool NeedMeshData,
            s3d_CEngMeshCompos &MeshCompos);
    s3d_CEngGeoData *GetGeoData(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage);

    void Reduce();

private:
    s3d_CUtilMsgHandlerPtr m_MsgHandler;
    s3d_CUtilStr m_Info;
    bool m_Bare;
    s3d_CUtilAtomMgrPtr m_AtomMgr;
    s3d_CCompResMgrPtr m_ResMgr;
    s3d_CUtilStr m_ResName;
    s3d_CSharkMeshLoaderChangedEye m_Changed;

    s3d_CUtilNotifRecipObj<s3d_CSharkMeshLoaderVariant> m_NotifRecip;
    bool m_Loaded;
    bool m_Reduced;

    // Data:

    s3d_CDrvSigPtr m_VariantSig;

    s3d_CSharkMeshLoaderTopol m_Topol;

    s3d_CUtilInitInt m_TexLayerCnt;
    // Cnt = m_TexLayerCnt * m_FamilyCnt
    s3d_CUtilOwnArray<int> m_TexIdxArray;
    // Cnt = m_TexLayerCnt * m_FamilyCnt
    s3d_CUtilOwnArray<int> m_SampModeArray;

    s3d_CUtilInitInt m_FrmCnt;
    // Cnt = m_FrmCnt
    s3d_CUtilOwnArray<float> m_KeyArray;

    s3d_CDrvSigPtr m_BoneWghBankSig;
    // Cnt = m_VertCnt
    s3d_CSharkMeshLoaderBankBoneWghPtr m_BoneWghBank;

    s3d_CDrvSigPtr m_BoneSubscrBankSig;
    // Cnt = m_VertCnt
    s3d_CSharkMeshLoaderBankBoneSubscrPtr m_BoneSubscrBank;

    s3d_CDrvSigPtr m_PointBankSig;
    // Cnt = m_FrmCnt * m_VertCnt
    s3d_CSharkMeshLoaderBankVec3fPtr m_PointBank;       

    s3d_CDrvSigPtr m_NormalBankSig;
    // Cnt = m_FrmCnt * m_VertCnt
    s3d_CSharkMeshLoaderBankVec3fPtr m_NormalBank;      

    s3d_CDrvSigPtr m_TangentUBankSig;
    // Cnt = m_FrmCnt * m_VertCnt
    s3d_CSharkMeshLoaderBankVec3fPtr m_TangentUBank;    

    s3d_CDrvSigPtr m_TangentVBankSig;
    // Cnt = m_FrmCnt * m_VertCnt
    s3d_CSharkMeshLoaderBankVec3fPtr m_TangentVBank;    

    s3d_CDrvSigPtr m_ColorAlphaBankSig;
    // Cnt = m_FrmCnt * m_VertCnt
    s3d_CSharkMeshLoaderBankVec4fPtr m_ColorAlphaBank;     

    s3d_CUtilInitInt m_TexAttrCnt;
    // Cnt = m_TexAttrCnt
    s3d_CUtilOwnArray<s3d_CSharkMeshLoaderAttr> m_TexAttrArray;
    
    // Cnt = FamilyCnt
    s3d_CUtilOwnArray<s3d_CUtilAtomPtr> m_MtlPtrArray;
    s3d_CUtilOwnArray<s3d_CUtilAtom*> m_MtlArray;
    s3d_CUtilOwnArray<float> m_FrictArray;
    s3d_CUtilOwnArray<float> m_SoftnessArray;
    s3d_CUtilOwnArray<float> m_BounceArray;

    s3d_CUtilInitInt m_PrimSphereCnt;
    s3d_CUtilOwnArray<s3d_CEngGeoSphere> m_PrimSphereArray;

    s3d_CUtilInitInt m_PrimCapsuleCnt;
    s3d_CUtilOwnArray<s3d_CEngGeoCapsule> m_PrimCapsuleArray;

    s3d_CUtilInitBool m_CouldMorePrim;

    void CheckLoad();
    void Load(bool Restore);
    void ReadData(
            s3d_CUtilSnkSeqRead *Snk, bool Restore);
    void ThrowFormatError(s3d_CUtilStr_cr Kind);
    void ThrowRestoreError(s3d_CUtilStr_cr Kind);

    void LoaderPerform();
    void ResChanged();

    s3d_CEngMeshData *EvalMeshDataBase(
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage);
    s3d_CEngMeshData *EvalMeshDataFull(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
            s3d_CEngModelCtx *ModelCtx);

    static s3d_CSysIntps SearchKitIdx(
                s3d_CSysIntps KeyCnt, float *KeyArray, float Phase);
};

typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderVariant> s3d_CSharkMeshLoaderVariantPtr;

///////////////////////////////////////////////////////////////////////////////

struct s3d_CSharkMeshLoaderVariantDesc
{
    s3d_CUtilAtomPtr m_Usage;
    s3d_CUtilInitFloat m_Prec;
    s3d_CSysIntps m_VariantIdx;
};*/

///////////////////////////////////////////////////////////////////////////////

class s3d_CSharkMeshLoaderInterp
{
public:
    static void EvalFrm(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
            s3d_CUtilMemPool *MemPool,
            s3d_CSysIntps FrmCnt, s3d_CSysIntps iKit, float KitFrac,
            s3d_CEngMeshData *MeshData);
};

///////////////////////////////////////////////////////////////////////////////

//@ Standard model implementation.
class /*S3D_SHARK_MESH_LOADER_PUBLIC_DECL */s3d_CSharkMeshLoader
    : public s3d_CEngModel,
    public s3d_CCompUtilSerImmut,
    public s3d_CCompUtilUniqueBase,
    public s3d_CSharkMeshLoaderChanged,
    public s3d_CSharkMeshLoaderLoader
{
public:
    S3D_UTIL_RTTI_TABLE_DECLARE

    //@
    s3d_CSharkMeshLoader(
        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
        bool Bare,
        s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr, 
        s3d_CUtilStr_cr ResName);

    //@
    ~s3d_CSharkMeshLoader();

    //@
    s3d_CUtilStr GetInfo();

    //@ Return a string description of the object.
    s3d_CUtilStr GetDesc();

    //@
    void RegisterNotif(s3d_CUtilNotifRecip *Recip);

    //@
    int GetAnimActuCnt();

    //@
    s3d_CUtilStr GetAnimActuName(int Idx);

    //@
    void GetAnimActuRange(int Idx, float &Start, float &End);

    //@
    int GetAnimPosCnt();

    //@
    s3d_CUtilStr GetAnimPosName(int Idx);

    //@
    int GetTexCnt();

    //@
    s3d_CUtilStr GetTexName(int Idx);

    //@
    void GetBound(s3d_CUtilVec3f &Cen, s3d_CUtilVec3f &Ext);

    //@
    void GetMeshCompos(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage, 
            s3d_CUtilMat4x4f_cr Map, s3d_CUtilVec3f_cr Ext,
            s3d_CUtilVec3f_cr Prec, s3d_CEngModelCtx *ModelCtx,
            bool NeedMeshData,
            s3d_CEngMeshCompos &MeshCompos);

    //@
    void GetAvailMeshComposArray(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
            s3d_CEngMeshComposArray &MeshComposArray);

    //@
    s3d_CEngGeoData *GetGeoData(
            s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage);

    //@
    bool VisibCheckInf(
            s3d_CUtilMemPool *MemPool, 
            s3d_CUtilVec3f_cr RelRefPoint);

    //@
    void VisibAddBoundTest(
            s3d_CUtilMemPool *MemPool, 
            s3d_CEngBoundTestArray *BoundTestArray, 
            s3d_CUtilVec3f_cr RelRefPoint, 
            s3d_CUtilVec3f_cr BoundTransl, s3d_CUtilQuatf_cr BoundQuat);

    //@
    void Reduce();

    //@
    void ResChanged();

    //@
    void ChangedPerform();

//	bool UseTriangleStrips(void) const { return use_triangle_strips; }

	inline const Geometry::LodStripsLibraryData *GetLodStripsData(void) const { return geo_mesh_loader.GetLodStripsData(); }
	inline Geometry::Mesh *GetGeoMesh(void) const { return m_GeoMesh; }

private:
    bool m_Bare;
    s3d_CUtilAtomMgrPtr m_AtomMgr;
    s3d_CCompResMgrPtr m_ResMgr;
    s3d_CUtilStr m_ResName;

    s3d_CUtilNotifRecipObj<s3d_CSharkMeshLoader> m_NotifRecip;
    s3d_CUtilNotifMgr m_NotifMgr;

    s3d_CUtilMsgHandlerPtr m_MsgHandler;
    s3d_CUtilStr m_Info;

    s3d_CUtilStr m_ModelName;

    bool m_Loaded;

    // Model data:

    float m_RangeStart;
    float m_RangeEnd;

    s3d_CUtilVec3f m_BoundCen;
    s3d_CUtilVec3f m_BoundExt;

    int m_BoneCnt;
    s3d_CUtilOwnArray<s3d_CUtilStr> m_BoneNameArray;
    s3d_CUtilOwnArray<s3d_CUtilTranslQuatf> m_BoneTransfArray;

    s3d_CUtilInitInt m_TexNameCnt;
    s3d_CUtilOwnArray<s3d_CUtilStr> m_TexNameArray;

/*    s3d_CUtilInitInt m_VariantDescCnt;
    s3d_CUtilOwnArray<s3d_CSharkMeshLoaderVariantDesc> m_VariantDescArray;
    s3d_CUtilInitInt m_VariantCnt;
    s3d_CUtilOwnArray<s3d_CSharkMeshLoaderVariantPtr> m_VariantArray;

    s3d_CSysIntps m_VariantIdxGeo;*/

    void Unload();
    void CheckLoad();
    void Load();
	// GAMETOOLS
 /*   void ReadModel(
            s3d_CUtilSnkSeqRead *Snk);*/
	void ReadModelGT();

/*    void ReadVariantDesc(
            s3d_CUtilSnkSeqRead *Snk, 
            s3d_CSharkMeshLoaderVariantDesc &VariantDesc);*/
    void ThrowFormatError(s3d_CUtilStr_cr Kind);

    s3d_CSysIntps SearchVariantIdxPrec(
            s3d_CUtilAtom *Usage, float Prec);
    float CalcMeshPrec(s3d_CUtilMat4x4f_cr Map, s3d_CUtilVec3f_cr Prec);

	// GAMETOOLS
	Geometry::Mesh *m_GeoMesh;
	Geometry::GeoMeshLoader geo_mesh_loader;
    void LoaderPerform();
    void GetMeshComposBase(
            s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage, 
            s3d_CEngMeshCompos &MeshCompos);

    s3d_CDrvSigPtr m_PointBankSig;
    // Cnt = m_FrmCnt * m_VertCnt
    s3d_CSharkMeshLoaderBankVec3fPtr m_PointBank;

    s3d_CDrvSigPtr m_NormalBankSig;
    // Cnt = m_FrmCnt * m_VertCnt
    s3d_CSharkMeshLoaderBankVec3fPtr m_NormalBank;

    s3d_CUtilInitInt m_TexAttrCnt;
    // Cnt = m_TexAttrCnt
	s3d_CEngMeshAttr *m_TexAttrArray;

    s3d_CSharkMeshLoaderBankMeshIdx *m_IdxBank; //<- indices   
    s3d_CSharkMeshLoaderBankMeshIdx *m_BoneIdxBank; //<- bone indices   

	// families (submeshes)
	s3d_CEngMeshFamily *m_FamilyArray;

	// packets
	s3d_CSharkMeshLoaderBankPacket *m_PacketsBank;

	// signatures
    s3d_CDrvSigPtr m_MeshSig, m_TopolSig;

//	bool use_triangle_strips;

};

typedef s3d_CUtilPtr<s3d_CSharkMeshLoader> s3d_CSharkMeshLoaderPtr;

///////////////////////////////////////////////////////////////////////////////

//@ Standard suppl for standard model objects
// which can read standard model files.
class s3d_CSharkMeshLoaderSuppl
        : public s3d_CCompSuppl,
        public s3d_CCompSetup
{
public:
    S3D_UTIL_RTTI_TABLE_DECLARE

    //@
    s3d_CSharkMeshLoaderSuppl();

    //@
    s3d_CSharkMeshLoaderSuppl(
            s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
            bool Bare, s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr);

    //@
    void SetupInit(
            s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
            s3d_CCompSuppl *FetchSuppl, s3d_CUtilSnkChunk *Param);

    //@
    void SetupDone();

    //@
    s3d_CCompObjPtr SupplObj(
            s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
            s3d_CUtilStr_cr Ident, s3d_CUtilStr_cr Version);

private:
    bool m_Bare;
    s3d_CUtilAtomMgrPtr m_AtomMgr;
    s3d_CCompResMgrPtr m_ResMgr;
};

//@
typedef s3d_CUtilPtr<s3d_CSharkMeshLoaderSuppl> s3d_CSharkMeshLoaderSupplPtr;

///////////////////////////////////////////////////////////////////////////////
// Definitions:
///////////////////////////////////////////////////////////////////////////////

template<typename T>
void s3d_CSharkMeshLoaderBank<T>::Fetch(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
        s3d_CDrvBankContent &BankContent)
{
    if(m_Data)
    {
        BankContent.m_Cnt = m_Cnt;
        BankContent.m_TypeDesc = s3d_DrvDataGetTypeDesc<T>();
        BankContent.m_Stride = S3D_SYS_SIZEOFS(T);
        BankContent.m_Data 
                = reinterpret_cast<const s3d_CSysIntm*>(m_Data.Get());
        return;
    }
    if(m_Loader)
        m_Loader->LoaderPerform();
    if(m_Data)
    {
        BankContent.m_Cnt = m_Cnt;
        BankContent.m_TypeDesc = s3d_DrvDataGetTypeDesc<T>();
        BankContent.m_Stride = S3D_SYS_SIZEOFS(T);
        BankContent.m_Data 
                = reinterpret_cast<const s3d_CSysIntm*>(m_Data.Get());
        return;
    }
    s3d_CUtilMsg e;
    e.m_Code = "eng/model/std/SHARK_MESH_LOADER.not_available";
    e.m_StdTempl = "Data not available.";
    e.AddInfo(Info);
    s3d_UtilMsgReportFatal(MsgHandler, e);
}

template<typename T>
s3d_CUtilPtrBase *s3d_CSharkMeshLoaderBank<T>::GetOwner(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info)
{
    return this;
}

///////////////////////////////////////////////////////////////////////////////

#endif