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

//@cpp

#include "shark_mesh_loader_model.h"
#include "../../interf/eng_actu.h"
#include "../../../util/snk/util_snk_work.h"
#include "../../../util/snk/util_snk_extract.h"
#include "../../../util/os/util_filesystem.h"
#include "../../../drv/interf/drv_gfx.h"
#include "../../../general/general_def.h"


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


#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPX (1 << 0)
#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPY (1 << 1)
#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPZ (1 << 2)
#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORX (1 << 3)
#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORY (1 << 4)
#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORZ (1 << 5)
#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_FILTER (1 << 6)

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

template<typename T>
void s3d_SharkMeshLoaderInterpInterpBetweenT(
        s3d_CSysIntps Cnt, T *Target,
        const T *ArrayA, const T *ArrayB, float Frac)
{
    if(Target && ArrayA && ArrayB)
    {
        while(Cnt > 0)
        {
            T VecA = *ArrayA++;
            T VecB = *ArrayB++;
            T Vec = VecA.InterpLinear(VecB, Frac);
            *Target++ = Vec;
            Cnt--;
        }
    }
}

template<typename T>
void s3d_SharkMeshLoaderInterpInternT(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
        s3d_CUtilMemPool *MemPool, 
        s3d_CSysIntps VertCnt, s3d_CSysIntps FrmCnt,
        s3d_CSysIntps iKit, float KitFrac,
        s3d_CEngMeshAttr &Attr)
{
    Attr.m_BankSig = 0;
    s3d_CSysIntps VertFrmCnt = VertCnt * FrmCnt;
    const T *Data = s3d_DrvBankFetchArray<T>(
            MsgHandler, Info, "stdmesh_interp_t", Attr.m_Bank, VertFrmCnt);
    if(Data)
    {
        Data += iKit * VertCnt;
        if(iKit == FrmCnt)
            Data -= VertCnt;
        else if(iKit > 0)
        {
            if(KitFrac == 0)
                Data -= VertCnt;
            else if(KitFrac < 1)
            {
                const T *DataA = Data - VertCnt;
                const T *DataB = Data;
                T *NewData = new(MemPool) T[VertCnt];
                s3d_CDrvBankGivenArray<T> *NewBank
                        = new(MemPool) s3d_CDrvBankGivenArray<T>(
                                VertCnt, Data, 0);
                Attr.m_Bank = NewBank;
                s3d_SharkMeshLoaderInterpInterpBetweenT(VertCnt, NewData, 
                        DataA, DataB, KitFrac);
            }
        }
    }
}

void s3d_CSharkMeshLoaderInterp::EvalFrm(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
        s3d_CUtilMemPool *MemPool,
        s3d_CSysIntps FrmCnt, s3d_CSysIntps iKit, float KitFrac,
        s3d_CEngMeshData *MeshData)
{
    s3d_CSysIntps VertCnt = MeshData->m_Topol.m_VertCnt;
    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec3f>(
            MsgHandler, Info, MemPool, 
            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_PointAttr);
    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec3f>(
            MsgHandler, Info, MemPool, 
            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_NormalAttr);
    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec3f>(
            MsgHandler, Info, MemPool, 
            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_TangentUAttr);
    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec3f>(
            MsgHandler, Info, MemPool, 
            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_TangentVAttr);
    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec4f>(
            MsgHandler, Info, MemPool, 
            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_ColorAlphaAttr);
    s3d_CSysIntps AttrCnt = MeshData->m_TexAttrCnt;       
    s3d_CSysIntps iAttr;
    for(iAttr = 0; iAttr < AttrCnt; iAttr++)
    {
        s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec2f>(
                MsgHandler, Info, MemPool, 
                VertCnt, FrmCnt, iKit, KitFrac, 
                MeshData->m_TexAttrArray[iAttr]);
    }
}

template<typename T>
void s3d_SharkMeshLoaderInterpInterRedT(
        s3d_CSysIntps Cnt, T *Target, const T *Array, 
        const s3d_CSharkMeshLoaderIdx *RedArray, float Frac)
{
    if(Target && Array && RedArray)
    {
        int i;
        for(i = 0; i < Cnt; i++)
        {
            int iRed = RedArray[i];
            S3D_SYS_ASSERT(s3d_SysIsValidArrayIdx(iRed, Cnt));
            if(iRed == i)
                Target[i] = Array[i];
            else
            {
                T VecBase = Array[i];
                T VecRed = Array[iRed];
                T Vec = VecBase.InterpLinear(VecRed, Frac);
                Target[i] = Vec;
            }
        }
    }
}

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

template<typename T>
S3D_SYS_INLINE void s3d_SharkMeshLoaderReduceBank(
        s3d_CSysIntps &SizeTotal, 
        s3d_CSysIntps &SizeBefore, 
        s3d_CSysIntps &SizeAfter,
        const s3d_CUtilPtr< s3d_CSharkMeshLoaderBank<T> > &Bank)
{
    if(Bank)
    {
        s3d_CSysIntps BankSize = Bank->m_Cnt * S3D_SYS_SIZEOFS(T);
        SizeTotal += BankSize;
        if(Bank->m_Data)
        {
            SizeBefore += BankSize;
            if(Bank->m_RefCnt == 1)
                Bank->m_Data.Reset();
            else
                SizeAfter += BankSize;
        }
    }
}

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

/*s3d_CSharkMeshLoaderVariant::s3d_CSharkMeshLoaderVariant(
        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
        bool Bare,
        s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr, 
        s3d_CUtilStr_cr ResName, s3d_CSharkMeshLoaderChanged *Changed)
{
    m_MsgHandler = MsgHandler;
    m_Info = Info;
    m_Bare = Bare;
    m_AtomMgr = AtomMgr;
    m_ResMgr = ResMgr;
    m_ResName = ResName;
    m_Changed = Changed;

    m_NotifRecip.Assign(this, &s3d_CSharkMeshLoaderVariant::ResChanged);
    m_Loaded = false;
    m_Reduced = false;

    m_VariantSig = S3D_SYS_NEW s3d_CDrvSig;
    m_Topol.m_TopolSig = S3D_SYS_NEW s3d_CDrvSig;
}

s3d_CSharkMeshLoaderVariant::~s3d_CSharkMeshLoaderVariant()
{
}

void s3d_CSharkMeshLoaderVariant::GetMeshComposBase(
        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage, 
        s3d_CEngMeshCompos &MeshCompos)
{
    CheckLoad();

    MeshCompos.m_MeshSig = m_VariantSig;
    MeshCompos.m_TexFamilyCnt = m_Topol.m_FamilyCnt;
    MeshCompos.m_TexLayerCnt = m_TexLayerCnt;
    MeshCompos.m_TexIdxArray = m_TexIdxArray;
    MeshCompos.m_SampModeArray = m_SampModeArray;
    MeshCompos.m_MeshData = EvalMeshDataBase(MemPool, Usage);
}

void s3d_CSharkMeshLoaderVariant::GetMeshComposFull(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage, 
        s3d_CEngModelCtx *ModelCtx,
        bool NeedMeshData,
        s3d_CEngMeshCompos &MeshCompos)
{    
    CheckLoad();

    MeshCompos.m_MeshSig = m_VariantSig;
    MeshCompos.m_TexFamilyCnt = m_Topol.m_FamilyCnt;
    MeshCompos.m_TexLayerCnt = m_TexLayerCnt;
    MeshCompos.m_TexIdxArray = m_TexIdxArray;
    MeshCompos.m_SampModeArray = m_SampModeArray;
    if(NeedMeshData)
    {
        MeshCompos.m_MeshData = EvalMeshDataFull(
                MsgHandler, Info, MemPool, Usage, ModelCtx);
    }
}

s3d_CEngGeoData *s3d_CSharkMeshLoaderVariant::GetGeoData(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage)
{
    CheckLoad();

    if(m_CouldMorePrim)
    {
        s3d_CUtilMsg e;
        e.m_Code = 
                "eng/posgen/std/eng_posgen_std_model.variant_could_more_prim";
        e.m_StdTempl = "Geometry has triangles which could be exported "
                "as primitive geometry instead. ";
        e.AddInfo(m_Info);
        s3d_UtilMsgReportError(m_MsgHandler, e);
    }

    if(m_Topol.m_IdxCnt != m_Topol.m_IdxEssCnt)
    {
        s3d_CUtilMsg e;
        e.m_Code = 
                "eng/posgen/std/eng_posgen_std_model.not_all_essential";
        e.m_StdTempl = "Geometry has triangles which are not essential. ";
        e.AddInfo(m_Info);
        s3d_UtilMsgReportError(m_MsgHandler, e);
        return 0;
    }

    s3d_CSysIntps FamilyCnt = m_Topol.m_FamilyCnt;
    s3d_CSysIntps *FamilyIdxCntArray = new(MemPool) s3d_CSysIntps[FamilyCnt];
    s3d_CSysIntps iFamily;
    for(iFamily = 0; iFamily < FamilyCnt; iFamily++)
        FamilyIdxCntArray[iFamily] = m_Topol.m_FamilyArray[iFamily].m_IdxCnt;

    s3d_CEngGeoData *Geo = new(MemPool) s3d_CEngGeoData;
    Geo->m_Info = m_Info.GetChars();
    Geo->m_Desc = m_ResName.GetChars();
    Geo->m_FamilyCnt = m_Topol.m_FamilyCnt;
    Geo->m_FamilyMtlArray = m_MtlArray;
    Geo->m_FamilyFrictArray = m_FrictArray;
    Geo->m_FamilySoftnessArray = m_SoftnessArray;
    Geo->m_FamilyBounceArray = m_BounceArray;
    Geo->m_IdxCnt = m_Topol.m_IdxCnt;
    Geo->m_IdxBank = m_Topol.m_IdxBank;
    Geo->m_OppBank = m_Topol.m_OppBank;
    Geo->m_FamilyIdxCntArray = FamilyIdxCntArray;
    Geo->m_PointCnt = m_Topol.m_VertCnt;
    Geo->m_PointBank = m_PointBank;
    Geo->m_SphereCnt = m_PrimSphereCnt;
    Geo->m_SphereArray = m_PrimSphereArray;
    Geo->m_CapsuleCnt = m_PrimCapsuleCnt;
    Geo->m_CapsuleArray = m_PrimCapsuleArray;
    return Geo;
}

void s3d_CSharkMeshLoaderVariant::Reduce()
{
    if(m_RefCnt > 1)
        return; // Someone else holds a reference to it as Owner.

    m_Reduced = true;

    s3d_CSysIntps SizeTotal = 0;
    s3d_CSysIntps SizeBefore = 0;
    s3d_CSysIntps SizeAfter = 0;

    //s3d_SharkMeshLoaderReduceBank(
    //        SizeTotal, SizeBefore, SizeAfter, 
    //        m_Topol.m_PacketArray);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_Topol.m_PacketBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_Topol.m_IdxBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_Topol.m_OppBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_Topol.m_BoneIdxBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_BoneWghBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_BoneSubscrBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_PointBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_NormalBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_TangentUBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_TangentVBank);
    s3d_SharkMeshLoaderReduceBank(
            SizeTotal, SizeBefore, SizeAfter, 
            m_ColorAlphaBank);
    s3d_CSysIntps nTexAttr = m_TexAttrCnt;
    s3d_CSysIntps iTexAttr;
    for(iTexAttr = 0; iTexAttr < nTexAttr; iTexAttr++)
    {
        s3d_CSharkMeshLoaderAttr *TexAttr = &m_TexAttrArray[iTexAttr];
        s3d_SharkMeshLoaderReduceBank(
                SizeTotal, SizeBefore, SizeAfter, 
                TexAttr->m_Bank);
    }

    s3d_CUtilMsg m;
    m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.variant_reduce";
    m.m_StdTempl = "Reduced standard model variant \"[1]\". "
                    "[2] total bytes. Reduced from [3] to [4] bytes. ";
    m.AddInfo(m_Info);
    m.AddInfo(m_ResName);
    m.AddInfo(s3d_CUtilStrUtil::StrOfIntps(SizeTotal));
    m.AddInfo(s3d_CUtilStrUtil::StrOfIntps(SizeBefore));
    m.AddInfo(s3d_CUtilStrUtil::StrOfIntps(SizeAfter));
    s3d_UtilMsgReportNote(m_MsgHandler, m);
}

void s3d_CSharkMeshLoaderVariant::CheckLoad()
{
    if(!m_Loaded)
        Load(false);
}

void s3d_CSharkMeshLoaderVariant::Load(bool Restore)
{
    if(Restore)
    {
        s3d_CUtilMsg m;
        m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.variant_load";
        m.m_StdTempl = "Restoring standard model variant \"[1]\".";
        m.AddInfo(m_Info);
        m.AddInfo(m_ResName);
        s3d_UtilMsgReportNote(m_MsgHandler, m);
    }
    else
    {
        s3d_CUtilMsg m;
        m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.variant_load";
        m.m_StdTempl = "Loading standard model variant \"[1]\".";
        m.AddInfo(m_Info);
        m.AddInfo(m_ResName);
        s3d_UtilMsgReportNote(m_MsgHandler, m);
    }

    m_Loaded = true;
    m_Reduced = false;

    int Generosity = 0;
    s3d_CUtilStr ResInfo;
    s3d_CUtilStreamPtr ResStream;
    bool Final = false;
    m_ResMgr->GetResource(
            m_Info, m_ResName, true, Generosity,
            ResInfo, ResStream, Final, &m_NotifRecip);

    if(ResStream && ResStream->GetSize() > 0)
    {
        s3d_CUtilSnkSeqReadPtr Snk;
        int SnkFormat = 0;
        s3d_CUtilSnkWork::CreateSeqReadStream(m_MsgHandler, m_Info, 
                        ResStream, m_Bare, SnkFormat, Snk);

        s3d_CUtilStr Format;
        while(Snk->GetRemainField() > 0)
        {
            s3d_CUtilStr FieldName = Snk->BeginField();
            if(FieldName == "format")
            {
                Format = Snk->ReadStr();
            }
            else if(FieldName == "data")
            {
                if(Format == S3D_SHARK_MESH_LOADER_VARIANT_SNKFORMAT)
                {
                    Snk->BeginChunk();
                    ReadData(Snk, Restore);
                    Snk->EndChunk();
                }
                else
                {
                    s3d_CUtilMsg e;
                    e.m_Code = 
                            "eng/posgen/std/eng_posgen_std_model.variant_format";
                    e.m_StdTempl = "Found format \"[2]\" instead of \"[1]\".";
                    e.AddInfo(m_Info);
                    e.AddInfo(S3D_SHARK_MESH_LOADER_VARIANT_SNKFORMAT);
                    e.AddInfo(Format);
                    s3d_UtilMsgReportError(m_MsgHandler, e);
                }
            }
            Snk->EndField();
        }
        if(Format.IsEmpty())
        {
            s3d_CUtilMsg e;
            e.m_Code = "eng/posgen/std/eng_posgen_std_model.variant_no_format";
            e.m_StdTempl = "No format \"[1]\" found.";
            e.AddInfo(m_Info);
            e.AddInfo(S3D_SHARK_MESH_LOADER_VARIANT_SNKFORMAT);
            s3d_UtilMsgReportError(m_MsgHandler, e);
        }

        Snk->Finish();
    }
}

void s3d_CSharkMeshLoaderVariant::ReadData(
        s3d_CUtilSnkSeqRead *Snk, bool Restore)
{
    if(!Restore)
    {
        m_Topol.m_VertCnt = -1;
        m_Topol.m_VertEssCnt = -1;
        m_Topol.m_IdxCnt = -1;
        m_Topol.m_IdxEssCnt = -1;
        m_Topol.m_BoneIdxCnt = -1;
        m_Topol.m_BoneIdxEssCnt = -1;
        m_Topol.m_FamilyCnt = -1;
        m_Topol.m_PacketCnt = -1;
        m_FrmCnt = -1;
        m_TexLayerCnt = -1;
        m_TexAttrCnt = -1;
        m_CouldMorePrim = false;
    }

    while(Snk->GetRemainField() > 0)
    {
        s3d_CUtilStr FieldName = Snk->BeginField();
        if(FieldName == "vert_cnt")
        {
            s3d_CSysIntps NewVertCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewVertCnt != m_Topol.m_VertCnt)
                    ThrowRestoreError("vert_cnt");
            }
            else
            {
                if(m_Topol.m_VertCnt >= 0)
                    ThrowFormatError("variant.vert_cnt");
                m_Topol.m_VertCnt = NewVertCnt;
            }
        }
        else if(FieldName == "vert_ess_cnt")
        {
            s3d_CSysIntps NewVertEssCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewVertEssCnt != m_Topol.m_VertEssCnt)
                    ThrowRestoreError("vert_ess_cmt");
            }
            else
            {
                if(m_Topol.m_VertEssCnt >= 0)
                    ThrowFormatError("variant.vert_ess_cnt");
                m_Topol.m_VertEssCnt = NewVertEssCnt;
            }
        }
        else if(FieldName == "idx_cnt")
        {
            s3d_CSysIntps NewIdxCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewIdxCnt != m_Topol.m_IdxCnt)
                    ThrowRestoreError("idx_cnt");
            }
            else
            {
                if(m_Topol.m_IdxCnt >= 0)
                    ThrowFormatError("variant.idx_cnt");
                m_Topol.m_IdxCnt = NewIdxCnt;
            }
        }
        else if(FieldName == "idx_ess_cnt")
        {
            s3d_CSysIntps NewIdxEssCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewIdxEssCnt != m_Topol.m_IdxEssCnt)
                    ThrowRestoreError("idx_ess_cnt");
            }
            else
            {
                if(m_Topol.m_IdxEssCnt >= 0)
                    ThrowFormatError("variant.idx_ess_cnt");
                m_Topol.m_IdxEssCnt = NewIdxEssCnt;
            }
        }
        else if(FieldName == "bone_idx_cnt")
        {
            s3d_CSysIntps NewBoneIdxCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewBoneIdxCnt != m_Topol.m_BoneIdxCnt)
                    ThrowRestoreError("bone_idx_cnt");
            }
            else
            {
                if(m_Topol.m_BoneIdxCnt >= 0)
                    ThrowFormatError("variant.bone_idx_cnt");
                m_Topol.m_BoneIdxCnt = NewBoneIdxCnt;
            }
        }
        else if(FieldName == "bone_idx_ess_cnt")
        {
            s3d_CSysIntps NewBoneIdxEssCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewBoneIdxEssCnt != m_Topol.m_BoneIdxEssCnt)
                    ThrowRestoreError("bone_idx_ess_cnt");
            }
            else
            {
                if(m_Topol.m_BoneIdxEssCnt >= 0)
                    ThrowFormatError("variant.bone_idx_ess_cnt");
                m_Topol.m_BoneIdxEssCnt = NewBoneIdxEssCnt;
            }
        }
        else if(FieldName == "packet_cnt")
        {
            s3d_CSysIntps NewPacketCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewPacketCnt != m_Topol.m_PacketCnt)
                    ThrowRestoreError("packet_cnt");
            }
            else
            {
                if(m_Topol.m_PacketCnt >= 0)
                    ThrowFormatError("variant.packet_cnt");
                m_Topol.m_PacketCnt = NewPacketCnt;
            }
        }
        else if(FieldName == "family_cnt")
        {
            s3d_CSysIntps NewFamilyCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewFamilyCnt != m_Topol.m_FamilyCnt)
                    ThrowRestoreError("family_cnt");
            }
            else
            {
                if(m_Topol.m_FamilyCnt >= 0)
                    ThrowFormatError("variant.family_cnt");
                m_Topol.m_FamilyCnt = NewFamilyCnt;
            }
        }
        else if(FieldName == "closed")
        {
            m_Topol.m_Closed = (Snk->ReadInt() != 0);
        }
        else if(FieldName == "sealed")
        {
            m_Topol.m_Sealed = (Snk->ReadInt() != 0);
        }
        else if(FieldName == "family_array")
        {
            s3d_CSysIntps FamilyCnt = Snk->GetRemainInt() / 7;
            if(FamilyCnt != m_Topol.m_FamilyCnt)
                ThrowRestoreError("family_cnt");

            m_Topol.m_FamilyArray.Alloc(m_Topol.m_FamilyCnt);
            int iFamily;
            for(iFamily = 0; iFamily < m_Topol.m_FamilyCnt; iFamily++)
            {
                s3d_CEngMeshFamily *Family = &m_Topol.m_FamilyArray[iFamily];
                Family->m_VertCnt = Snk->ReadInt();
                Family->m_VertEssCnt = Snk->ReadInt();
                Family->m_IdxCnt = Snk->ReadInt();
                Family->m_IdxEssCnt = Snk->ReadInt();
                Family->m_BoneIdxCnt = Snk->ReadInt();
                Family->m_BoneIdxEssCnt = Snk->ReadInt();
                Family->m_PacketCnt = Snk->ReadInt();
            }
        }
        else if(FieldName == "packet_array")
        {
            int PacketCnt = Snk->GetRemainInt() / 6;
            if(PacketCnt != m_Topol.m_PacketCnt)
                ThrowRestoreError("packet_cnt");

            s3d_CSharkMeshLoaderBankPacketPtr Bank;
            if(Restore)
            {
                Bank = m_Topol.m_PacketBank;
                if(!Bank)
                    ThrowRestoreError("packet_bank");
            }
            else
            {
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankPacket;
                Bank->m_Loader = this;
                m_Topol.m_PacketBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = PacketCnt;
                Bank->m_Data.Alloc(PacketCnt);
            }
            s3d_CDrvMeshPacket *Data = Bank->m_Data;

            int iPacket;
            for(iPacket = 0; iPacket < PacketCnt; iPacket++)
            {
                s3d_CDrvMeshPacket *Packet = &Data[iPacket];
                Packet->m_VertCnt = Snk->ReadInt();
                Packet->m_VertEssCnt = Snk->ReadInt();
                Packet->m_IdxCnt = Snk->ReadInt();
                Packet->m_IdxEssCnt = Snk->ReadInt();
                Packet->m_BoneIdxCnt = Snk->ReadInt();
                Packet->m_BoneIdxEssCnt = Snk->ReadInt();
            }
        }
        else if(FieldName == "bone_idx_array")
        {
            int BoneIdxCnt = Snk->GetRemainInt();
            if(BoneIdxCnt != m_Topol.m_BoneIdxCnt)
                ThrowRestoreError("bone_idx_cnt");

            s3d_CSharkMeshLoaderBankMeshIdxPtr Bank;
            if(Restore)
            {
                Bank = m_Topol.m_BoneIdxBank;
                if(!Bank)
                    ThrowRestoreError("bone_idx_bank");
            }
            else
            {
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
                Bank->m_Loader = this;
                m_Topol.m_BoneIdxBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = BoneIdxCnt;
                Bank->m_Data.Alloc(BoneIdxCnt);
            }
            s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
            int i;
            for(i = 0; i < BoneIdxCnt; i++)
            {
                int RawBoneIdx = Snk->ReadInt();
                s3d_CSharkMeshLoaderIdx BoneIdx = s3d_CSharkMeshLoaderIdx(RawBoneIdx);
                Data[i] = BoneIdx;
            }
        }
        else if(FieldName == "idx_array")
        {
            int IdxCnt = Snk->GetRemainInt();
            if(IdxCnt != m_Topol.m_IdxCnt)
                ThrowRestoreError("idx_cnt");

            s3d_CSharkMeshLoaderBankMeshIdxPtr Bank;
            if(Restore)
            {
                Bank = m_Topol.m_IdxBank;
                if(!Bank)
                    ThrowRestoreError("idx_bank");
            }
            else
            {
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
                Bank->m_Loader = this;
                m_Topol.m_IdxCnt = IdxCnt;
                m_Topol.m_IdxBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = IdxCnt;
                Bank->m_Data.Alloc(IdxCnt);
            }
            s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
            int i;
            for(i = 0; i < IdxCnt; i++)
            {
                int RawIdx = Snk->ReadInt();
                if(RawIdx < 0 || RawIdx >= m_Topol.m_VertCnt)
                    ThrowFormatError("variant.idx_cnt_array.idx_out_of_range");
                s3d_CSharkMeshLoaderIdx Idx = s3d_CSharkMeshLoaderIdx(RawIdx);
                Data[i] = Idx;
            }
        }
        else if(FieldName == "opp_array")
        {
            int OppCnt = Snk->GetRemainInt();
            if(OppCnt != m_Topol.m_IdxEssCnt)
                ThrowFormatError("opp_array.idx_ess_cnt");

            s3d_CSharkMeshLoaderBankMeshIdxPtr Bank;
            if(Restore)
            {
                Bank = m_Topol.m_OppBank;
                if(!Bank)
                    ThrowRestoreError("opp_bank");
            }
            else
            {
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
                Bank->m_Loader = this;
                m_Topol.m_OppBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = OppCnt;
                Bank->m_Data.Alloc(OppCnt);
            }
            s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
            int i;
            for(i = 0; i < OppCnt; i++)
            {
                int Val = Snk->ReadInt();
                Data[i] = Val;
            }
        }
        else if(FieldName == "neigh_array")
        {
            int NeighCnt = Snk->GetRemainInt();
            if(NeighCnt != m_Topol.m_IdxEssCnt)
                ThrowFormatError("neigh_array.idx_ess_cnt");

            s3d_CSharkMeshLoaderBankMeshIdxPtr Bank;
            if(Restore)
            {
                Bank = m_Topol.m_NeighBank;
                if(!Bank)
                    ThrowRestoreError("neigh_bank");
            }
            else
            {
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
                Bank->m_Loader = this;
                m_Topol.m_NeighBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = NeighCnt;
                Bank->m_Data.Alloc(NeighCnt);
            }
            s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
            int i;
            for(i = 0; i < NeighCnt; i++)
            {
                int Val = Snk->ReadInt();
                Data[i] = Val;
            }
        }
        else if(FieldName == "tex_layer_cnt")
        {
            s3d_CSysIntps NewTexLayerCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewTexLayerCnt != m_TexLayerCnt)
                    ThrowRestoreError("tex_layer_cnt");
            }
            else
            {
                if(m_TexLayerCnt >= 0)
                    ThrowFormatError("variant.tex_layer_cnt");
                m_TexLayerCnt = NewTexLayerCnt;
            }
        }
        else if(FieldName == "tex_idx_array")
        {
            int TexIdxCnt = Snk->GetRemainInt();
            int ValCnt = -1;
            if(m_TexLayerCnt >= 0 && m_Topol.m_FamilyCnt >= 0)
                ValCnt = m_TexLayerCnt * m_Topol.m_FamilyCnt;
            if(TexIdxCnt != ValCnt)
                ThrowRestoreError("layer_cnt");

            if(!Restore)
                m_TexIdxArray.Alloc(TexIdxCnt);
            int i;
            for(i = 0; i < TexIdxCnt; i++)
                m_TexIdxArray[i] = Snk->ReadInt();
        }
        else if(FieldName == "sampler_mode_array")
        {
            int SampModeCnt = Snk->GetRemainInt();
            int ValCnt = -1;
            if(m_TexLayerCnt >= 0 && m_Topol.m_FamilyCnt >= 0)
                ValCnt = m_TexLayerCnt * m_Topol.m_FamilyCnt;
            if(SampModeCnt != ValCnt)
                ThrowRestoreError("layer_cnt");

            if(!Restore)
                m_SampModeArray.Alloc(SampModeCnt);
            int i;
            for(i = 0; i < SampModeCnt; i++)
            {
                int Val = Snk->ReadInt();
                int SampMode = 0;
                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPX)
                    SampMode |= s3d_CDrvGfxEng::SampMode_ClampX;
                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPY)
                    SampMode |= s3d_CDrvGfxEng::SampMode_ClampY;
                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPZ)
                    SampMode |= s3d_CDrvGfxEng::SampMode_ClampZ;
                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORX)
                    SampMode |= s3d_CDrvGfxEng::SampMode_MirrorX;
                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORY)
                    SampMode |= s3d_CDrvGfxEng::SampMode_MirrorY;
                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORZ)
                    SampMode |= s3d_CDrvGfxEng::SampMode_MirrorZ;
                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_FILTER)
                    SampMode |= s3d_CDrvGfxEng::SampMode_Filter;
                m_SampModeArray[i] = SampMode;
            }
        }
        else if(FieldName == "frm_cnt")
        {
            s3d_CSysIntps NewFrmCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewFrmCnt != m_FrmCnt)
                    ThrowRestoreError("frm_cnt");
            }
            else
            {
                if(m_FrmCnt >= 0)
                    ThrowFormatError("variant.frm_cnt");
                m_FrmCnt = NewFrmCnt;
            }
        }
        else if(FieldName == "key_array")
        {
            s3d_CSysIntps FrmCnt = Snk->GetRemainFloat();
            if(FrmCnt != m_FrmCnt)
                ThrowRestoreError("frm_cnt");

            if(!Restore)
                m_KeyArray.Alloc(m_FrmCnt);
            int i;
            for(i = 0; i < m_FrmCnt; i++)
                m_KeyArray[i] = Snk->ReadFloat();
        }
        else if(FieldName == "bone_wgh_array")
        {
            int NewVertCnt = Snk->GetRemainFloat() / 4;
            if(NewVertCnt != m_Topol.m_VertCnt)
                ThrowFormatError("bone_wgh_array.value_cnt");

            s3d_CSharkMeshLoaderBankBoneWghPtr Bank;
            if(Restore)
            {
                Bank = m_BoneWghBank;
                if(!Bank)
                    ThrowRestoreError("bone_wgh_array");
            }
            else
            {
                m_BoneWghBankSig = S3D_SYS_NEW s3d_CDrvSig;
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankBoneWgh;
                Bank->m_Loader = this;
                m_BoneWghBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = NewVertCnt;
                Bank->m_Data.Alloc(NewVertCnt);
            }
            s3d_CUtilVec4f *Data = Bank->m_Data;
            int i;
            for(i = 0; i < NewVertCnt; i++)
            {
                s3d_CUtilVec4f Val;
                Val.m_x = Snk->ReadFloat();
                Val.m_y = Snk->ReadFloat();
                Val.m_z = Snk->ReadFloat();
                Val.m_w = Snk->ReadFloat();
                Data[i] = Val;
            }
        }
        else if(FieldName == "bone_subscr_array")
        {
            int NewVertCnt = Snk->GetRemainInt() / 4;
            if(NewVertCnt != m_Topol.m_VertCnt)
                ThrowFormatError("bone_wgh_array.value_cnt");

            s3d_CSharkMeshLoaderBankBoneSubscrPtr Bank;
            if(Restore)
            {
                Bank = m_BoneSubscrBank;
                if(!Bank)
                    ThrowRestoreError("bone_wgh_array");
            }
            else
            {
                m_BoneSubscrBankSig = S3D_SYS_NEW s3d_CDrvSig;
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankBoneSubscr;
                Bank->m_Loader = this;
                m_BoneSubscrBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = NewVertCnt;
                Bank->m_Data.Alloc(NewVertCnt);
            }
            s3d_CDrvInt32uX4 *Data = Bank->m_Data;
            int i;
            for(i = 0; i < NewVertCnt; i++)
            {
                s3d_CDrvInt32uX4 Val;
                Val.m_x = Snk->ReadInt();
                Val.m_y = Snk->ReadInt();
                Val.m_z = Snk->ReadInt();
                Val.m_w = Snk->ReadInt();
                Data[i] = Val;
            }
        }
        else if(FieldName == "point_array")
        {
            int ValCnt = Snk->GetRemainFloat();
            int VecCnt = -1;
            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
            if(ValCnt != 3 * VecCnt)
                ThrowFormatError("point_array.value_cnt");

            s3d_CSharkMeshLoaderBankVec3fPtr Bank;
            if(Restore)
            {
                Bank = m_PointBank;
                if(!Bank)
                    ThrowRestoreError("point_array");
            }
            else
            {
                m_PointBankSig = S3D_SYS_NEW s3d_CDrvSig;
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
                Bank->m_Loader = this;
                m_PointBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = VecCnt;
                Bank->m_Data.Alloc(VecCnt);
            }
            s3d_CUtilVec3f *Data = Bank->m_Data;
            int i;
            for(i = 0; i < VecCnt; i++)
            {
                s3d_CUtilVec3f Val;
                Val.m_x = Snk->ReadFloat();
                Val.m_y = Snk->ReadFloat();
                Val.m_z = Snk->ReadFloat();
                Data[i] = Val;
            }
        }
        else if(FieldName == "normal_array")
        {
            int ValCnt = Snk->GetRemainFloat();
            int VecCnt = -1;
            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
            if(ValCnt != 3 * VecCnt)
                ThrowFormatError("normal_array.value_cnt");

            s3d_CSharkMeshLoaderBankVec3fPtr Bank;
            if(Restore)
            {
                Bank = m_NormalBank;
                if(!Bank)
                    ThrowRestoreError("normal_array");
            }
            else
            {
                m_NormalBankSig = S3D_SYS_NEW s3d_CDrvSig;
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
                Bank->m_Loader = this;
                m_NormalBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = VecCnt;
                Bank->m_Data.Alloc(VecCnt);
            }
            s3d_CUtilVec3f *Data = Bank->m_Data;
            int i;
            for(i = 0; i < VecCnt; i++)
            {
                s3d_CUtilVec3f Val;
                Val.m_x = Snk->ReadFloat();
                Val.m_y = Snk->ReadFloat();
                Val.m_z = Snk->ReadFloat();
                Data[i] = Val;
            }
        }
        else if(FieldName == "tangentu_array")
        {
            int ValCnt = Snk->GetRemainFloat();
            int VecCnt = -1;
            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
            if(ValCnt != 3 * VecCnt)
                ThrowFormatError("tangentu_array.value_cnt");

            s3d_CSharkMeshLoaderBankVec3fPtr Bank;
            if(Restore)
            {
                Bank = m_TangentUBank;
                if(!Bank)
                    ThrowRestoreError("tangentu_array");
            }
            else
            {
                m_TangentUBankSig = S3D_SYS_NEW s3d_CDrvSig;
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
                Bank->m_Loader = this;
                m_TangentUBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = VecCnt;
                Bank->m_Data.Alloc(VecCnt);
            }
            s3d_CUtilVec3f *Data = Bank->m_Data;
            int i;
            for(i = 0; i < VecCnt; i++)
            {
                s3d_CUtilVec3f Val;
                Val.m_x = Snk->ReadFloat();
                Val.m_y = Snk->ReadFloat();
                Val.m_z = Snk->ReadFloat();
                Data[i] = Val;
            }
        }
        else if(FieldName == "tangentv_array")
        {
            int ValCnt = Snk->GetRemainFloat();
            int VecCnt = -1;
            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
            if(ValCnt != 3 * VecCnt)
                ThrowFormatError("tangentv_array.value_cnt");

            s3d_CSharkMeshLoaderBankVec3fPtr Bank;
            if(Restore)
            {
                Bank = m_TangentVBank;
                if(!Bank)
                    ThrowRestoreError("tangentv_array");
            }
            else
            {
                m_TangentVBankSig = S3D_SYS_NEW s3d_CDrvSig;
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
                Bank->m_Loader = this;
                m_TangentVBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = VecCnt;
                Bank->m_Data.Alloc(VecCnt);
            }
            s3d_CUtilVec3f *Data = Bank->m_Data;
            int i;
            for(i = 0; i < VecCnt; i++)
            {
                s3d_CUtilVec3f Val;
                Val.m_x = Snk->ReadFloat();
                Val.m_y = Snk->ReadFloat();
                Val.m_z = Snk->ReadFloat();
                Data[i] = Val;
            }
        }
        else if(FieldName == "coloralpha_array")
        {
            int ValCnt = Snk->GetRemainFloat();
            int VecCnt = -1;
            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
            if(ValCnt != 4 * VecCnt)
                ThrowFormatError("coloralpha_array.value_cnt");

            s3d_CSharkMeshLoaderBankVec4fPtr Bank;
            if(Restore)
            {
                Bank = m_ColorAlphaBank;
                if(!Bank)
                    ThrowRestoreError("coloralpha_array");
            }
            else
            {
                m_ColorAlphaBankSig = S3D_SYS_NEW s3d_CDrvSig;
                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec4f;
                Bank->m_Loader = this;
                m_ColorAlphaBank = Bank;
            }
            if(!Bank->m_Data)
            {
                Bank->m_Cnt = VecCnt;
                Bank->m_Data.Alloc(VecCnt);
            }
            s3d_CUtilVec4f *Data = Bank->m_Data;
            int i;
            for(i = 0; i < VecCnt; i++)
            {
                s3d_CUtilVec4f Val;
                Val.m_x = Snk->ReadFloat();
                Val.m_y = Snk->ReadFloat();
                Val.m_z = Snk->ReadFloat();
                Val.m_w = Snk->ReadFloat();
                Data[i] = Val;
            }
        }
        else if(FieldName == "tex_attr_cnt")
        {
            s3d_CSysIntps NewTexAttrCnt = Snk->ReadInt();
            if(Restore)
            {
                if(NewTexAttrCnt != m_TexAttrCnt)
                    ThrowRestoreError("tex_attr_cnt");
            }
            else
            {
                if(m_TexAttrCnt >= 0)
                    ThrowFormatError("variant.tex_attr_cnt");
                m_TexAttrCnt = NewTexAttrCnt;
            }
        }
        else if(FieldName == "tex_coord_array")
        {
            int VecCnt = Snk->GetRemainFloat() / 2;
            int TexAttrCnt = m_TexAttrCnt;
            int FrmCnt = m_FrmCnt;
            int VertCnt = m_Topol.m_VertCnt;
            int AttrVecCnt = FrmCnt * VertCnt;
            if(VecCnt != TexAttrCnt * AttrVecCnt)
                ThrowFormatError("tex_layer_array.texcoord_cnt");

            if(!Restore)
                m_TexAttrArray.Alloc(TexAttrCnt);

            int i;
            for(i = 0; i < m_TexAttrCnt; i++)
            {
                s3d_CSharkMeshLoaderAttr *TexAttr 
                    = &m_TexAttrArray[i];
                s3d_CSharkMeshLoaderBankVec2fPtr Bank;
                if(Restore)
                {
                    Bank = TexAttr->m_Bank;
                    if(!Bank)
                        ThrowRestoreError("texattr_array");
                }
                else
                {
                    Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec2f;
                    Bank->m_Loader = this;
                    TexAttr->m_Bank = Bank;
                }
                if(!Bank->m_Data)
                {
                    Bank->m_Cnt = AttrVecCnt;
                    Bank->m_Data.Alloc(AttrVecCnt);
                }
                s3d_CUtilVec2f *Data = Bank->m_Data;
                int j;
                for(j = 0; j < AttrVecCnt; j++)
                {
                    s3d_CUtilVec2f Val;
                    Val.m_x = Snk->ReadFloat();
                    Val.m_y = Snk->ReadFloat();
                    Data[j] = Val;
                }
            }
        }
        else if(FieldName == "mtl_array")
        {
            int MtlCnt = Snk->GetRemainStr();
            if(MtlCnt != m_Topol.m_FamilyCnt)
                ThrowFormatError("tex_layer_array.mtl_cnt");
            if(!Restore)
            {
                m_MtlPtrArray.Alloc(MtlCnt);
                m_MtlArray.Alloc(MtlCnt);
            }
            s3d_CSysIntps j;
            for(j = 0; j < MtlCnt; j++)
            {
                s3d_CUtilStr MtlStr = Snk->ReadStr();
                s3d_CUtilAtomPtr Mtl = m_AtomMgr->GetAtom(MtlStr);
                m_MtlPtrArray[j] = Mtl;
                m_MtlArray[j] = Mtl;
            }
        }
        else if(FieldName == "frict_array")
        {
            int FrictCnt = Snk->GetRemainFloat();
            if(FrictCnt != m_Topol.m_FamilyCnt)
                ThrowFormatError("tex_layer_array.frict_cnt");
            if(!Restore)
                m_FrictArray.Alloc(FrictCnt);
            s3d_CSysIntps j;
            for(j = 0; j < FrictCnt; j++)
                m_FrictArray[j] = Snk->ReadFloat();
        }
        else if(FieldName == "softness_array")
        {
            int SoftnessCnt = Snk->GetRemainFloat();
            if(SoftnessCnt != m_Topol.m_FamilyCnt)
                ThrowFormatError("tex_layer_array.softness_cnt");
            if(!Restore)
                m_SoftnessArray.Alloc(SoftnessCnt);
            s3d_CSysIntps j;
            for(j = 0; j < SoftnessCnt; j++)
                m_SoftnessArray[j] = Snk->ReadFloat();
        }
        else if(FieldName == "bounce_array")
        {
            int BounceCnt = Snk->GetRemainFloat();
            if(BounceCnt != m_Topol.m_FamilyCnt)
                ThrowFormatError("tex_layer_array.bounce_cnt");
            if(!Restore)
                m_BounceArray.Alloc(BounceCnt);
            s3d_CSysIntps j;
            for(j = 0; j < BounceCnt; j++)
                m_BounceArray[j] = Snk->ReadFloat();
        }
        else if(FieldName == "prim_sphere_center_radius_array")
        {
            s3d_CSysIntps GeoSphereCnt = Snk->GetRemainFloat() / 4;
            if(Restore)
            {
                if(GeoSphereCnt != m_PrimSphereCnt)
                    ThrowRestoreError("sphere_cnt");
            }
            else
            {
                m_PrimSphereCnt = GeoSphereCnt;
                m_PrimSphereArray.Alloc(GeoSphereCnt);
            }
            s3d_CEngGeoSphere *Target = m_PrimSphereArray;
            s3d_CSysIntps j;
            for(j = 0; j < GeoSphereCnt; j++)
            {
                Target->m_FamilyIdx = 0;
                Target->m_Cen.m_x = Snk->ReadFloat();
                Target->m_Cen.m_y = Snk->ReadFloat();
                Target->m_Cen.m_z = Snk->ReadFloat();
                Target->m_Radius = Snk->ReadFloat();
                Target++;
            }
        }
        else if(FieldName == "prim_sphere_family_idx_array")
        {
            s3d_CSysIntps GeoSphereCnt = Snk->GetRemainInt();
            if(GeoSphereCnt != m_PrimSphereCnt)
                ThrowFormatError("prim_sphere.ct");
            s3d_CEngGeoSphere *Target = m_PrimSphereArray;
            s3d_CSysIntps j;
            for(j = 0; j < GeoSphereCnt; j++)
            {
                Target->m_FamilyIdx = Snk->ReadInt();
                Target++;
            }
        }
        else if(FieldName == "prim_capsule_start_end_radius_array")
        {
            s3d_CSysIntps GeoCapsuleCnt = Snk->GetRemainFloat() / 7;
            if(Restore)
            {
                if(GeoCapsuleCnt != m_PrimCapsuleCnt)
                    ThrowRestoreError("capsule_cnt");
            }
            else
            {
                m_PrimCapsuleCnt = GeoCapsuleCnt;
                m_PrimCapsuleArray.Alloc(GeoCapsuleCnt);
            }
            s3d_CEngGeoCapsule *Target = m_PrimCapsuleArray;
            s3d_CSysIntps j;
            for(j = 0; j < GeoCapsuleCnt; j++)
            {
                Target->m_FamilyIdx = 0;
                Target->m_Start.m_x = Snk->ReadFloat();
                Target->m_Start.m_y = Snk->ReadFloat();
                Target->m_Start.m_z = Snk->ReadFloat();
                Target->m_End.m_x = Snk->ReadFloat();
                Target->m_End.m_y = Snk->ReadFloat();
                Target->m_End.m_z = Snk->ReadFloat();
                Target->m_Radius = Snk->ReadFloat();
                Target++;
            }
        }
        else if(FieldName == "prim_capsule_family_idx_array")
        {
            s3d_CSysIntps GeoCapsuleCnt = Snk->GetRemainInt();
            if(GeoCapsuleCnt != m_PrimCapsuleCnt)
                ThrowFormatError("prim_capsule.ct");
            s3d_CEngGeoCapsule *Target = m_PrimCapsuleArray;
            s3d_CSysIntps j;
            for(j = 0; j < GeoCapsuleCnt; j++)
            {
                Target->m_FamilyIdx = Snk->ReadInt();
                Target++;
            }
        }
        else if(FieldName == "could_more_prim")
            m_CouldMorePrim = (Snk->ReadInt() != 0);
        Snk->EndField();
    }

    if(!Restore)
    {
        if(m_Topol.m_VertCnt < 0)
            m_Topol.m_VertCnt = 0;
        if(m_Topol.m_VertEssCnt < 0)
            m_Topol.m_VertEssCnt = 0;
        if(m_Topol.m_IdxCnt < 0)
            m_Topol.m_IdxCnt = 0;
        if(m_Topol.m_IdxEssCnt < 0)
            m_Topol.m_IdxEssCnt = 0;
        if(m_Topol.m_BoneIdxCnt < 0)
            m_Topol.m_BoneIdxCnt = 0;
        if(m_Topol.m_BoneIdxEssCnt < 0)
            m_Topol.m_BoneIdxEssCnt = 0;
        if(m_Topol.m_PacketCnt < 0)
            m_Topol.m_PacketCnt = 0;
        if(m_Topol.m_FamilyCnt < 0)
            m_Topol.m_FamilyCnt = 0;
        if(m_FrmCnt < 0)
            m_FrmCnt = 0;
        if(m_TexLayerCnt < 0)
            m_TexLayerCnt = 0;
        if(m_TexAttrCnt < 0)
            m_TexAttrCnt = 0;

        m_BoneWghBankSig = S3D_SYS_NEW s3d_CDrvSig;
        m_BoneSubscrBankSig = S3D_SYS_NEW s3d_CDrvSig;
        if(m_FrmCnt == 1)
        {
            m_PointBankSig = S3D_SYS_NEW s3d_CDrvSig;
            m_NormalBankSig = S3D_SYS_NEW s3d_CDrvSig;
            m_ColorAlphaBankSig = S3D_SYS_NEW s3d_CDrvSig;
            m_TangentUBankSig = S3D_SYS_NEW s3d_CDrvSig;
            m_TangentVBankSig = S3D_SYS_NEW s3d_CDrvSig;
            int iTexAttr;
            for(iTexAttr = 0; iTexAttr < m_TexAttrCnt; iTexAttr++)
            {
                m_TexAttrArray[iTexAttr].m_BankSig 
                    = S3D_SYS_NEW s3d_CDrvSig;
            }
        }
    }
}

void s3d_CSharkMeshLoaderVariant::ThrowFormatError(s3d_CUtilStr_cr Kind)
{
    s3d_CUtilMsg e;
    e.m_Code = "eng/model/std/SHARK_MESH_LOADER.format";
    e.m_StdTempl = "Model variant \"[1]\" has an illegal format "
                    "concerning \"[2]\".";
    e.AddInfo(m_Info);
    e.AddInfo(m_ResName);
    e.AddInfo(Kind);
    s3d_UtilMsgReportFatal(m_MsgHandler, e);
}

void s3d_CSharkMeshLoaderVariant::ThrowRestoreError(s3d_CUtilStr_cr Kind)
{
    s3d_CUtilMsg e;
    e.m_Code = "eng/model/std/SHARK_MESH_LOADER.format";
    e.m_StdTempl = "Model variant \"[1]\" is restored, "
                    "but the new data is different concerning \"[2]\".";
    e.AddInfo(m_Info);
    e.AddInfo(m_ResName);
    e.AddInfo(Kind);
    s3d_UtilMsgReportFatal(m_MsgHandler, e);
}

void s3d_CSharkMeshLoaderVariant::LoaderPerform()
{
    Load(true);
}

void s3d_CSharkMeshLoaderVariant::ResChanged()
{
    if(m_Changed)
        m_Changed->ChangedPerform();
}

s3d_CEngMeshData *s3d_CSharkMeshLoaderVariant::EvalMeshDataBase(
        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage)
{
    bool Dyn = (m_FrmCnt > 1);

    int TexAttrCnt = m_TexAttrCnt;

    s3d_CEngMeshAttr *MeshTexAttrArray 
                = new(MemPool) s3d_CEngMeshAttr[TexAttrCnt];
    int iTexAttr;
    for(iTexAttr = 0; iTexAttr < TexAttrCnt; iTexAttr++)
    {
        s3d_CSharkMeshLoaderAttr *TexAttr 
                = &m_TexAttrArray[iTexAttr];
        s3d_CEngMeshAttr *MeshTexAttr = &MeshTexAttrArray[iTexAttr];
        MeshTexAttr->m_BankDyn = Dyn;
        MeshTexAttr->m_BankSig = TexAttr->m_BankSig;
        MeshTexAttr->m_Bank = TexAttr->m_Bank;
    }

    s3d_CEngMeshData *MeshData = new(MemPool) s3d_CEngMeshData;
    MeshData->m_Info = m_Info.GetChars();
    MeshData->m_Desc = m_ResName.GetChars();
    MeshData->m_Usage = Usage;
    MeshData->m_MeshOwner = this;
    MeshData->m_Topol.m_TopolSig = m_Topol.m_TopolSig;
    MeshData->m_Topol.m_VertCnt = m_Topol.m_VertCnt;
    MeshData->m_Topol.m_VertEssCnt = m_Topol.m_VertEssCnt;
    MeshData->m_Topol.m_IdxCnt = m_Topol.m_IdxCnt;
    MeshData->m_Topol.m_IdxEssCnt = m_Topol.m_IdxEssCnt;
    MeshData->m_Topol.m_BoneIdxCnt = m_Topol.m_BoneIdxCnt;
    MeshData->m_Topol.m_BoneIdxEssCnt = m_Topol.m_BoneIdxEssCnt;
    MeshData->m_Topol.m_FamilyCnt = m_Topol.m_FamilyCnt;
    MeshData->m_Topol.m_PacketCnt = m_Topol.m_PacketCnt;
    MeshData->m_Topol.m_UseSubscr = (m_BoneSubscrBank != 0);
    MeshData->m_Topol.m_Closed = m_Topol.m_Closed;
    MeshData->m_Topol.m_Sealed = m_Topol.m_Sealed;
    MeshData->m_Topol.m_FamilyArray = m_Topol.m_FamilyArray;
    MeshData->m_Topol.m_PacketBank = m_Topol.m_PacketBank;
    MeshData->m_Topol.m_BoneIdxBank = m_Topol.m_BoneIdxBank;
    MeshData->m_Topol.m_IdxBank = m_Topol.m_IdxBank;
    MeshData->m_Topol.m_OppBank = m_Topol.m_OppBank;
    MeshData->m_Topol.m_NeighBank = m_Topol.m_NeighBank;
    MeshData->m_BoneWghAttr.m_BankDyn = Dyn;
    MeshData->m_BoneWghAttr.m_BankSig = m_BoneWghBankSig;
    MeshData->m_BoneWghAttr.m_Bank = m_BoneWghBank;
    MeshData->m_BoneSubscrAttr.m_BankDyn = Dyn;
    MeshData->m_BoneSubscrAttr.m_BankSig = m_BoneSubscrBankSig;
    MeshData->m_BoneSubscrAttr.m_Bank = m_BoneSubscrBank;
    MeshData->m_PointAttr.m_BankDyn = Dyn;
    MeshData->m_PointAttr.m_BankSig = m_PointBankSig;
    MeshData->m_PointAttr.m_Bank = m_PointBank;
    MeshData->m_NormalAttr.m_BankDyn = Dyn;
    MeshData->m_NormalAttr.m_BankSig = m_NormalBankSig;
    MeshData->m_NormalAttr.m_Bank = m_NormalBank;
    MeshData->m_TangentUAttr.m_BankDyn = Dyn;
    MeshData->m_TangentUAttr.m_BankSig = m_TangentUBankSig;
    MeshData->m_TangentUAttr.m_Bank = m_TangentUBank;
    MeshData->m_TangentVAttr.m_BankDyn = Dyn;
    MeshData->m_TangentVAttr.m_BankSig = m_TangentVBankSig;
    MeshData->m_TangentVAttr.m_Bank = m_TangentVBank;
    MeshData->m_ColorAlphaAttr.m_BankDyn = Dyn;
    MeshData->m_ColorAlphaAttr.m_BankSig = m_ColorAlphaBankSig;
    MeshData->m_ColorAlphaAttr.m_Bank = m_ColorAlphaBank;
    MeshData->m_TexAttrCnt = TexAttrCnt;
    MeshData->m_TexAttrArray = MeshTexAttrArray;
    return MeshData;
}

s3d_CEngMeshData *s3d_CSharkMeshLoaderVariant::EvalMeshDataFull(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
        s3d_CEngModelCtx *ModelCtx)
{
    s3d_CEngMeshData *MeshData = EvalMeshDataBase(MemPool, Usage);

    int FrmCnt = m_FrmCnt;
    if(ModelCtx && FrmCnt > 1)
    {
        s3d_CEngActu *Actu = ModelCtx->GetAnimActu(0);
        float Phase = 0;
        if(Actu)
            Phase = Actu->GetVal();

        s3d_CSysIntps iKit = SearchKitIdx(m_FrmCnt, m_KeyArray, Phase);
        float KitFrac = 0;
        if(iKit > 0)
        {
            float KeyA = m_KeyArray[iKit - 1];
            float KeyB = m_KeyArray[iKit];
            if(KeyA != KeyB)
                KitFrac = (Phase - KeyA) / (KeyB - KeyA);
        }

        s3d_CSharkMeshLoaderInterp::EvalFrm(
                MsgHandler, Info, MemPool, 
                FrmCnt, iKit, KitFrac, MeshData);
    }

    return MeshData;
}

s3d_CSysIntps s3d_CSharkMeshLoaderVariant::SearchKitIdx(
        s3d_CSysIntps KeyCnt, float *KeyArray, float Phase)
{
    s3d_CSysIntps From = 0;
    s3d_CSysIntps To = KeyCnt;
    while(To > From)
    {
        s3d_CSysIntps Mid = (From + To) >> 1;
        if(KeyArray[Mid] >= Phase)
            To = Mid;
        else
            From = Mid + 1;
    }
    return From;
}
*/
///////////////////////////////////////////////////////////////////////////////

S3D_UTIL_RTTI_TABLE_DEFINE_BEGIN(s3d_CSharkMeshLoader)
S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CEngModel)
S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompUtilSerImmut)
S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompUtilUniqueBase)
S3D_UTIL_RTTI_TABLE_DEFINE_END

s3d_CSharkMeshLoader::s3d_CSharkMeshLoader(
        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
        bool Bare,
        s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr, 
        s3d_CUtilStr_cr ResName)
{
    m_MsgHandler = MsgHandler;
    m_Info = Info;
    m_Bare = Bare;
    m_AtomMgr = AtomMgr;
    m_ResMgr = ResMgr;
    m_ResName = ResName;

    m_NotifRecip.Assign(this, &s3d_CSharkMeshLoader::ResChanged);

    m_Loaded = false;

    // Data:
    m_RangeStart = 0;
    m_RangeEnd = 0;
    m_BoundCen = 0;
    m_BoundExt = 0;
    m_BoneCnt = 0;
    m_BoneNameArray.Reset();
    m_BoneTransfArray.Reset();
    m_TexNameCnt = 0;
    m_TexNameArray.Reset();
/*    m_VariantDescCnt = 0;
    m_VariantDescArray.Reset();
    m_VariantCnt = 0;
    m_VariantArray.Reset();
    m_VariantIdxGeo = -1;*/

	m_MeshSig = S3D_SYS_NEW s3d_CDrvSig;
	m_TopolSig = S3D_SYS_NEW s3d_CDrvSig;

//	use_triangle_strips = false;
}

s3d_CSharkMeshLoader::~s3d_CSharkMeshLoader()
{
}

s3d_CUtilStr s3d_CSharkMeshLoader::GetInfo()
{
    return m_Info;
}

s3d_CUtilStr s3d_CSharkMeshLoader::GetDesc()
{
    return m_ResName;
}

void s3d_CSharkMeshLoader::RegisterNotif(s3d_CUtilNotifRecip *Recip)
{
    m_NotifMgr.Register(Recip);
}

int s3d_CSharkMeshLoader::GetAnimActuCnt()
{
    if(m_RangeStart < m_RangeEnd)
        return 1;
    else
        return 0;
}

s3d_CUtilStr s3d_CSharkMeshLoader::GetAnimActuName(int Idx)
{
    return 0;
}

void s3d_CSharkMeshLoader::GetAnimActuRange(int Idx, float &Start, float &End) 
{
    CheckLoad();

    Start = m_RangeStart;
    End = m_RangeEnd;
}

int s3d_CSharkMeshLoader::GetAnimPosCnt()
{
    CheckLoad();

    return m_BoneCnt;
}

s3d_CUtilStr s3d_CSharkMeshLoader::GetAnimPosName(int Idx)
{
    CheckLoad();

    if(s3d_SysIsValidArrayIdx(Idx, m_BoneCnt))
        return m_BoneNameArray[Idx];
    return 0;
}

int s3d_CSharkMeshLoader::GetTexCnt()
{
    CheckLoad();

    return m_TexNameCnt;
}

s3d_CUtilStr s3d_CSharkMeshLoader::GetTexName(int Idx)
{
    CheckLoad();

    if(s3d_SysIsValidArrayIdx(Idx, m_TexNameCnt))
        return m_TexNameArray[Idx];
    return "";
}

void s3d_CSharkMeshLoader::GetBound(
                s3d_CUtilVec3f &Cen, s3d_CUtilVec3f &Ext)
{
    CheckLoad();

    Cen = m_BoundCen;
    Ext = m_BoundExt;
}

void s3d_CSharkMeshLoader::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)
{
    CheckLoad();

	GetMeshComposBase(MemPool,Usage,MeshCompos);

	// GAMETOOLS: no tenemos variantes: son el mismo fichero!
/*    float MeshPrec = 0;
    if(m_VariantCnt > 1)
        MeshPrec = CalcMeshPrec(Map, Prec);

    s3d_CSysIntps VariantIdx = SearchVariantIdxPrec(Usage, MeshPrec);
    if(VariantIdx < 0)
        return;

    MeshCompos.m_BoundCen = m_BoundCen;
    MeshCompos.m_BoundExt = m_BoundExt;
    MeshCompos.m_BoneRefTransfCnt = m_BoneCnt;
    MeshCompos.m_BoneRefTransfArray = m_BoneTransfArray;

    s3d_CSharkMeshLoaderVariant *Variant = m_VariantArray[VariantIdx]; 
    Variant->GetMeshComposFull(MsgHandler, Info, MemPool, 
                Usage, ModelCtx, NeedMeshData, MeshCompos);

    s3d_CEngMeshData *MeshData = MeshCompos.m_MeshData;
    if(MeshData)
    {
        MeshData->m_BoundCen = m_BoundCen;
        MeshData->m_BoundExt = m_BoundExt;
        MeshData->m_Topol.m_BoneCnt = m_BoneCnt;
    }*/
}

void s3d_CSharkMeshLoader::GetMeshComposBase(
        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage, 
        s3d_CEngMeshCompos &MeshCompos)
{
	// construir un mesh compos fake por ahora!
	MeshCompos.m_BoundCen = m_BoundCen;
    MeshCompos.m_BoundExt = m_BoundExt;
	MeshCompos.m_BoneRefTransfCnt = 0;

    MeshCompos.m_MeshSig = m_MeshSig;
    MeshCompos.m_TexFamilyCnt = 1; //m_Topol.m_FamilyCnt;
    MeshCompos.m_TexLayerCnt = 1; //m_TexLayerCnt;
    MeshCompos.m_TexIdxArray = 0; //m_TexIdxArray;
//    MeshCompos.m_SampModeArray = m_SampModeArray;

//    bool Dyn = (m_FrmCnt > 1);
	bool Dyn = false; // creo que deberia ser true para poder cambiar de lod mas eficientemente
    s3d_CEngMeshData *MeshData = new(MemPool) s3d_CEngMeshData;
	MeshData->m_BoundCen = m_BoundCen;
    MeshData->m_BoundExt = m_BoundExt;
    MeshData->m_Info = m_Info.GetChars();
    MeshData->m_Desc = m_ResName.GetChars();
    MeshData->m_Usage = Usage;
	MeshData->m_MeshOwner = this;
    MeshData->m_Topol.m_TopolSig = m_TopolSig;
    MeshData->m_Topol.m_VertCnt = m_GeoMesh->mVertexBuffer->mVertexCount; //m_Topol.m_VertCnt;
    MeshData->m_Topol.m_VertEssCnt = MeshData->m_Topol.m_VertCnt; //m_Topol.m_VertEssCnt;
    MeshData->m_Topol.m_IdxCnt = m_IdxBank->m_Cnt; //m_Topol.m_IdxCnt;
    MeshData->m_Topol.m_IdxEssCnt = MeshData->m_Topol.m_IdxCnt; //m_Topol.m_IdxEssCnt;
    MeshData->m_Topol.m_BoneIdxCnt = 0; //m_Topol.m_BoneIdxCnt;
    MeshData->m_Topol.m_BoneIdxEssCnt = 0; //m_Topol.m_BoneIdxEssCnt;
    MeshData->m_Topol.m_UseSubscr = false; //(m_BoneSubscrBank != 0); // necesario (creo) para huesos!
    MeshData->m_Topol.m_Closed = false; //m_Topol.m_Closed;
    MeshData->m_Topol.m_Sealed = false; //m_Topol.m_Sealed;
	MeshData->m_Topol.m_FamilyArray = new(MemPool) s3d_CEngMeshFamily[m_GeoMesh->mSubMeshCount]; //m_Topol.m_FamilyArray;
	MeshData->m_Topol.m_FamilyCnt = m_GeoMesh->mSubMeshCount;
	for (int i=0; i<m_GeoMesh->mSubMeshCount; i++)
	{
		MeshData->m_Topol.m_FamilyArray[i].m_BoneIdxCnt = 0;
		MeshData->m_Topol.m_FamilyArray[i].m_BoneIdxEssCnt = 0;
		MeshData->m_Topol.m_FamilyArray[i].m_IdxCnt = m_GeoMesh->mSubMesh[i].mIndexCount;
		MeshData->m_Topol.m_FamilyArray[i].m_IdxEssCnt = m_GeoMesh->mSubMesh[i].mIndexCount;
		MeshData->m_Topol.m_FamilyArray[i].m_PacketCnt = 1;
		MeshData->m_Topol.m_FamilyArray[i].m_VertCnt = m_GeoMesh->mSubMesh[i].mVertexBuffer->mVertexCount;
		MeshData->m_Topol.m_FamilyArray[i].m_VertEssCnt = MeshData->m_Topol.m_FamilyArray[i].m_VertCnt;
	}

 /*   MeshData->m_Topol.m_VertCnt = 3;
    MeshData->m_Topol.m_VertEssCnt = 3;
    MeshData->m_Topol.m_IdxCnt = 3;
    MeshData->m_Topol.m_IdxEssCnt = 3;
    MeshData->m_Topol.m_BoneIdxCnt = 0; //m_Topol.m_BoneIdxCnt;
    MeshData->m_Topol.m_BoneIdxEssCnt = 0; //m_Topol.m_BoneIdxEssCnt;
    MeshData->m_Topol.m_UseSubscr = false; //(m_BoneSubscrBank != 0); // necesario (creo) para huesos!
    MeshData->m_Topol.m_Closed = false; //m_Topol.m_Closed;
    MeshData->m_Topol.m_Sealed = false; //m_Topol.m_Sealed;
	MeshData->m_Topol.m_FamilyArray = new(MemPool) s3d_CEngMeshFamily[1]; //m_Topol.m_FamilyArray;
	MeshData->m_Topol.m_FamilyCnt = 1;
	MeshData->m_Topol.m_FamilyArray[0].m_BoneIdxCnt = 0;
	MeshData->m_Topol.m_FamilyArray[0].m_BoneIdxEssCnt = 0;
	MeshData->m_Topol.m_FamilyArray[0].m_IdxCnt = 3;
	MeshData->m_Topol.m_FamilyArray[0].m_IdxEssCnt = 3;
	MeshData->m_Topol.m_FamilyArray[0].m_PacketCnt = 1;
	MeshData->m_Topol.m_FamilyArray[0].m_VertCnt = 3;
	MeshData->m_Topol.m_FamilyArray[0].m_VertEssCnt = 3;*/


//	MeshData->m_Topol.m_FamilyArray = m_FamilyArray;
	{
/*		s3d_CSharkMeshLoaderBankPacket *Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankPacket;		
		Bank->m_Loader = this;
		Bank->m_Cnt = 1;
		Bank->m_Data.Alloc(Bank->m_Cnt);
        s3d_CDrvMeshPacket *Data = Bank->m_Data;
        for(int iPacket = 0; iPacket < Bank->m_Cnt; iPacket++)
        {
            s3d_CDrvMeshPacket *Packet = &Data[iPacket];
            Packet->m_VertCnt = 3;
            Packet->m_VertEssCnt = 3;
            Packet->m_IdxCnt = 3;
            Packet->m_IdxEssCnt = 3;
            Packet->m_BoneIdxCnt = 0;
            Packet->m_BoneIdxEssCnt = 0;
        }
		MeshData->m_Topol.m_PacketBank = Bank;
		MeshData->m_Topol.m_PacketCnt = 1;*/
		MeshData->m_Topol.m_PacketBank = m_PacketsBank;
	    MeshData->m_Topol.m_PacketCnt = m_GeoMesh->mSubMeshCount; //m_Topol.m_PacketCnt;
	}
	{
/*		s3d_CSharkMeshLoaderBankMeshIdx *Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
		Bank->m_Loader = this;
		Bank->m_Cnt = 0;
        Bank->m_Data.Alloc(0);
        s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
//        for(int i = 0; i < BoneIdxCnt; i++)
//        {
//            int RawBoneIdx = Snk->ReadInt();
//            s3d_CSharkMeshLoaderIdx BoneIdx = s3d_CSharkMeshLoaderIdx(RawBoneIdx);
//            Data[i] = BoneIdx;
//        }*/
		MeshData->m_Topol.m_BoneIdxBank = 0; //Bank;
	}
	{
/*		s3d_CSharkMeshLoaderBankMeshIdx *Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
		Bank->m_Loader = this;
        Bank->m_Cnt = 3;
        Bank->m_Data.Alloc(Bank->m_Cnt);
		Bank->m_Data[0] = 0;
		Bank->m_Data[1] = 1;
		Bank->m_Data[2] = 2;
		MeshData->m_Topol.m_IdxBank = Bank;*/
		MeshData->m_Topol.m_IdxBank = m_IdxBank;
	}
	{
		MeshData->m_Topol.m_OppBank = 0;
/*		MeshData->m_Topol.m_OppBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
		MeshData->m_Topol.m_OppBank->m_Cnt = 3;
		MeshData->m_Topol.m_OppBank->m_Data.Alloc(MeshData->m_Topol.m_OppBank->m_Cnt);	
		s3d_CSharkMeshLoaderIdx *Data = MeshData->m_Topol.m_OppBank->m_Data;
		Data[0] = -1;
		Data[1] = -1;
		Data[2] = -1;*/
	}
	{
		MeshData->m_Topol.m_NeighBank = 0;
/*		MeshData->m_Topol.m_NeighBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
		MeshData->m_Topol.m_NeighBank->m_Cnt = 3;
		MeshData->m_Topol.m_NeighBank->m_Data.Alloc(MeshData->m_Topol.m_NeighBank->m_Cnt);	
		s3d_CSharkMeshLoaderIdx *Data = MeshData->m_Topol.m_NeighBank->m_Data;
		Data[0] = -1;
		Data[1] = -1;
		Data[2] = -1;*/
	}
    MeshData->m_BoneWghAttr.m_BankDyn = Dyn;
    MeshData->m_BoneWghAttr.m_BankSig = 0; //S3D_SYS_NEW s3d_CDrvSig;
    MeshData->m_BoneWghAttr.m_Bank = 0;
    MeshData->m_BoneSubscrAttr.m_BankDyn = Dyn;
    MeshData->m_BoneSubscrAttr.m_BankSig = 0;
    MeshData->m_BoneSubscrAttr.m_Bank = 0;	
	{
/*		static s3d_CDrvSig *PointAttrSig = S3D_SYS_NEW s3d_CDrvSig;
        MeshData->m_PointAttr.m_BankSig = PointAttrSig;
        s3d_CSharkMeshLoaderBankVec3f *Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
        Bank->m_Loader = this;
        Bank->m_Cnt = 3;
        Bank->m_Data.Alloc(Bank->m_Cnt);
        s3d_CUtilVec3f *Data = Bank->m_Data;
		{
            s3d_CUtilVec3f Val;
            Val.m_x = 0;
            Val.m_y = 0;
            Val.m_z = 0;
            Data[0] = Val;
		}
		{
            s3d_CUtilVec3f Val;
            Val.m_x = 1;
            Val.m_y = 0;
            Val.m_z = 0;
            Data[1] = Val;
		}
		{
            s3d_CUtilVec3f Val;
            Val.m_x = 0;
            Val.m_y = 1;
            Val.m_z = 0;
            Data[2] = Val;
		}
		MeshData->m_PointAttr.m_Bank = Bank;*/		
		MeshData->m_PointAttr.m_BankDyn = Dyn;
		MeshData->m_PointAttr.m_BankSig = m_PointBankSig;
		MeshData->m_PointAttr.m_Bank = m_PointBank;
	}
	{
		MeshData->m_NormalAttr.m_BankDyn = Dyn;
		MeshData->m_NormalAttr.m_BankSig = m_NormalBankSig;
		MeshData->m_NormalAttr.m_Bank = m_NormalBank;
	}
    MeshData->m_TangentUAttr.m_BankDyn = Dyn;
    MeshData->m_TangentUAttr.m_BankSig = 0; //m_TangentUBankSig;
    MeshData->m_TangentUAttr.m_Bank = 0; //m_TangentUBank;
    MeshData->m_TangentVAttr.m_BankDyn = Dyn;
    MeshData->m_TangentVAttr.m_BankSig = 0; //m_TangentVBankSig;
    MeshData->m_TangentVAttr.m_Bank = 0; //m_TangentVBank;
    MeshData->m_ColorAlphaAttr.m_BankDyn = Dyn;
    MeshData->m_ColorAlphaAttr.m_BankSig = 0; //m_ColorAlphaBankSig;
    MeshData->m_ColorAlphaAttr.m_Bank = 0; //m_ColorAlphaBank;
	{
/*		s3d_CSharkMeshLoaderBankVec2f *TexAttrBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec2f;
		TexAttrBank->m_Loader = this;
		TexAttrBank->m_Cnt = MeshData->m_Topol.m_VertCnt;
		TexAttrBank->m_Data.Alloc(MeshData->m_Topol.m_VertCnt);

		s3d_CUtilVec2f *Data = TexAttrBank->m_Data;
		{
            s3d_CUtilVec2f Val;
            Val.m_x = 0;
            Val.m_y = 0;
            Data[0] = Val;
		}	
		{
            s3d_CUtilVec2f Val;
            Val.m_x = 1;
            Val.m_y = 0;
            Data[1] = Val;
		}	
		{
            s3d_CUtilVec2f Val;
            Val.m_x = 1;
            Val.m_y = 1;
            Data[2] = Val;
		}	

		int TexAttrCnt = 1; // we always will have just one texture coord set
		s3d_CEngMeshAttr *MeshTexAttrArray = new(MemPool) s3d_CEngMeshAttr[1];
//		m_TexAttrArray.Alloc(1);

//		s3d_CSharkMeshLoaderAttr *TexAttr = &m_TexAttrArray[0];
		s3d_CEngMeshAttr *MeshTexAttr = &MeshTexAttrArray[0];
		MeshTexAttr->m_BankDyn = Dyn;
		static s3d_CDrvSig *TexAttrSig = S3D_SYS_NEW s3d_CDrvSig;
		MeshTexAttr->m_BankSig = TexAttrSig;
		MeshTexAttr->m_Bank = TexAttrBank;
		MeshData->m_TexAttrArray = MeshTexAttrArray;*/
		
	    MeshData->m_TexAttrArray = m_TexAttrArray;		
		MeshData->m_TexAttrCnt = 1;
	}

	MeshCompos.m_MeshData = MeshData;
}


void s3d_CSharkMeshLoader::GetAvailMeshComposArray(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
        s3d_CEngMeshComposArray &MeshComposArray)
{
    CheckLoad();

    s3d_CEngMeshCompos MeshCompos;
	GetMeshComposBase(MemPool,Usage,MeshCompos);
    MeshComposArray.InsertBack(MemPool, MeshCompos);

	// GAMETOOLS: no tenemos variantes, son la misma malla!

/*    s3d_CSysIntps iVariantDesc;
    for(iVariantDesc = 0; iVariantDesc < m_VariantDescCnt; iVariantDesc++)
    {
        s3d_CSharkMeshLoaderVariantDesc *VariantDesc 
                = &m_VariantDescArray[iVariantDesc];
        if(VariantDesc->m_Usage != Usage)
            continue;
        s3d_CSysIntps VariantIdx = VariantDesc->m_VariantIdx;
        if(VariantIdx < 0 || VariantIdx >= m_VariantCnt)
            continue;
        s3d_CSharkMeshLoaderVariant *Variant = m_VariantArray[VariantIdx];

        s3d_CEngMeshCompos MeshCompos;
        MeshCompos.m_BoundCen = m_BoundCen;
        MeshCompos.m_BoundExt = m_BoundExt;
        MeshCompos.m_BoneRefTransfCnt = m_BoneCnt;
        MeshCompos.m_BoneRefTransfArray = m_BoneTransfArray;

        Variant->GetMeshComposBase(MemPool, Usage, MeshCompos);

        s3d_CEngMeshData *MeshData = MeshCompos.m_MeshData;
        if(MeshData)
        {
            MeshData->m_BoundCen = m_BoundCen;
            MeshData->m_BoundExt = m_BoundExt;
            MeshData->m_Topol.m_BoneCnt = m_BoneCnt;
        }

        MeshComposArray.InsertBack(MemPool, MeshCompos);
    }*/
}

s3d_CEngGeoData *s3d_CSharkMeshLoader::GetGeoData(
        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage)
{
    CheckLoad();

	// GAMETOOLS: no tenemos variantes, con la misma malla!
	return 0;

/*    s3d_CSysIntps VariantIdx = SearchVariantIdxPrec(Usage, 0);
    if(VariantIdx < 0)
        return 0;

    s3d_CSharkMeshLoaderVariant *Variant = m_VariantArray[VariantIdx]; 
    return Variant->GetGeoData(MsgHandler, Info, MemPool, Usage);*/
}

bool s3d_CSharkMeshLoader::VisibCheckInf(
        s3d_CUtilMemPool *MemPool, s3d_CUtilVec3f_cr RelRefPoint)
{
    return true;
}

void s3d_CSharkMeshLoader::VisibAddBoundTest(
        s3d_CUtilMemPool *MemPool, 
        s3d_CEngBoundTestArray *BoundTestArray, 
        s3d_CUtilVec3f_cr RelRefPoint, 
        s3d_CUtilVec3f_cr BoundTransl, s3d_CUtilQuatf_cr BoundQuat)
{
}

void s3d_CSharkMeshLoader::Reduce()
{
    s3d_CUtilMsg m;
    m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.model_reduce";
    m.m_StdTempl = "Reducing standard model \"[1]\".";
    m.AddInfo(m_Info);
    m.AddInfo(m_ResName);
    s3d_UtilMsgReportNote(m_MsgHandler, m);

	// GAMETOOLS: no tenemos variantes, son la misma malla!
	// LO QUE HACE ESTO ES LIBERAR LOS DATOS QUE YA NO HACE FALTA TENERLOS EN MEMORIA

/*    int iVariant;
    for(iVariant = 0; iVariant < m_VariantCnt; iVariant++)
    {
        s3d_CSharkMeshLoaderVariant *Variant = m_VariantArray[iVariant];
        Variant->Reduce();
    }*/
}

void s3d_CSharkMeshLoader::ResChanged()
{
    Unload();

    m_NotifMgr.PerformNotif();
}

void s3d_CSharkMeshLoader::ChangedPerform()
{
    Unload();
    
    m_NotifMgr.PerformNotif();
}

void s3d_CSharkMeshLoader::Unload()
{
    /*
    s3d_CUtilMsg m;
    m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.model_destroy";
    m.m_StdTempl = "Unloading standard model \"[1]\".";
    m.AddInfo(m_Info);
    m.AddInfo(m_ResName);
    s3d_UtilMsgReportNote(m_MsgHandler, m);
    */

    m_RangeStart = 0;
    m_RangeEnd = 0;
    m_BoundCen = 0;
    m_BoundExt = 0;
    m_BoneCnt = 0;
    m_BoneNameArray.Reset();
    m_BoneTransfArray.Reset();
    m_TexNameCnt = 0;
    m_TexNameArray.Reset();
/*    m_VariantCnt = 0;
    m_VariantDescArray.Reset();*/

    m_Loaded = false;
}

void s3d_CSharkMeshLoader::CheckLoad()
{
    if(!m_Loaded)
        Load();
}

void s3d_CSharkMeshLoader::Load()
{
    s3d_CUtilMsg m;
    m.m_Code = "shark_mesh_loader.model_load";
    m.m_StdTempl = "Loading standard model \"[1]\".";
    m.AddInfo(m_Info);
    m.AddInfo(m_ResName);
    s3d_UtilMsgReportNote(m_MsgHandler, m);

    m_Loaded = true;

	m_GeoMesh = geo_mesh_loader.load((char*)m_ResName.GetChars());	

	if (m_GeoMesh)
	{
		ReadModelGT();
		m_TexNameCnt = 1;
		m_TexNameArray.Alloc(m_TexNameCnt);
		m_TexNameArray[0] = "stdtex:level/texture/Devil_diffuse_Atomic-Design.tga";
//		m_TexNameArray[1] = "stdtex:level/texture/Head_07_Devil_normal.tga";
	}
	

/*    int Generosity = 0;
    s3d_CUtilStr ResInfo;
    s3d_CUtilStreamPtr ResStream;
    bool Final = false;
    m_ResMgr->GetResource(
            m_Info, m_ResName, true, Generosity,
            ResInfo, ResStream, Final, &m_NotifRecip);

    if(ResStream && ResStream->GetSize() > 0)
    {
        s3d_CUtilSnkSeqReadPtr Snk;
        int SnkFormat = 0;
        s3d_CUtilSnkWork::CreateSeqReadStream(m_MsgHandler, m_Info, 
                ResStream, m_Bare, SnkFormat, Snk);

        s3d_CUtilStr Format;
        while(Snk->GetRemainField() > 0)
        {
            s3d_CUtilStr FieldName = Snk->BeginField();
            if(FieldName == "format")
            {
                Format = Snk->ReadStr();
            }
            else if(FieldName == "data")
            {
                if(Format == S3D_SHARK_MESH_LOADER_MODEL_SNKFORMAT)
                {
                    Snk->BeginChunk();
                    ReadModel(Snk);
                    Snk->EndChunk();
                }
                else
                {
                    s3d_CUtilMsg e;
                    e.m_Code = 
                            "eng/posgen/std/eng_posgen_std_model.model_format";
                    e.m_StdTempl = "Found format \"[2]\" instead of \"[1]\".";
                    e.AddInfo(m_Info);
                    e.AddInfo(S3D_SHARK_MESH_LOADER_MODEL_SNKFORMAT);
                    e.AddInfo(Format);
                    s3d_UtilMsgReportError(m_MsgHandler, e);
                }
            }
            Snk->EndField();
        }
        if(Format.IsEmpty())
        {
            s3d_CUtilMsg e;
            e.m_Code = "eng/posgen/std/eng_posgen_std_model.variant_no_format";
            e.m_StdTempl = "No format \"[1]\" found.";
            e.AddInfo(m_Info);
            e.AddInfo(S3D_SHARK_MESH_LOADER_MODEL_SNKFORMAT);
            s3d_UtilMsgReportError(m_MsgHandler, e);
        }

        Snk->Finish();
    }

    // Load variants:

    s3d_CUtilStr ModelResSuffix = s3d_CUtilFilesystem::GetSuffix(m_ResName);
    s3d_CUtilStr ModelResStem = s3d_CUtilFilesystem::GetWithoutSuffix(
            m_ResName);

    m_VariantArray.Alloc(m_VariantCnt);
    s3d_CSysIntps iVariant;
    for(iVariant = 0; iVariant < m_VariantCnt; iVariant++)
    {
        s3d_CUtilStr VariantResStem = ModelResStem + "$" + 
                s3d_CUtilStrUtil::StrOfInt(iVariant);
        s3d_CUtilStr VariantResName = VariantResStem + ModelResSuffix;

        s3d_CSharkMeshLoaderVariantPtr Variant 
                = S3D_SYS_NEW s3d_CSharkMeshLoaderVariant(
                        m_MsgHandler, m_Info, m_Bare, 
                        m_AtomMgr, m_ResMgr, VariantResName, this);
        m_VariantArray[iVariant] = Variant;
    }*/
}

/*void s3d_CSharkMeshLoader::ReadModel(
        s3d_CUtilSnkSeqRead *Snk)
{
    m_RangeStart = 0;
    m_RangeEnd = 0;

    m_BoundCen = 0;
    m_BoundExt = 0;

    m_BoneCnt = -1;

    m_BoneNameArray.Reset();
    m_BoneTransfArray.Reset();
    m_TexNameArray.Reset();

    s3d_CUtilArray<s3d_CSharkMeshLoaderVariantDesc> VariantDescArray;
    s3d_CUtilPtrArray<s3d_CSharkMeshLoaderVariant> VariantArray;

    bool HasTexCnt = false;
    bool HasVariant = false;
    bool HasVariantDesc = false;

    while(Snk->GetRemainField() > 0)
    {
        s3d_CUtilStr FieldName = Snk->BeginField();
        if(FieldName == "name")
            m_ModelName = Snk->ReadStr();
        else if(FieldName == "range")
        {
            m_RangeStart = Snk->ReadFloat();
            m_RangeEnd = Snk->ReadFloat();
        }
        else if(FieldName == "bound")
        {
            m_BoundCen.m_x = Snk->ReadFloat();
            m_BoundCen.m_y = Snk->ReadFloat();
            m_BoundCen.m_z = Snk->ReadFloat();
            m_BoundExt.m_x = Snk->ReadFloat();
            m_BoundExt.m_y = Snk->ReadFloat();
            m_BoundExt.m_z = Snk->ReadFloat();
        }
        else if(FieldName == "bone_cnt")
        {
            if(m_BoneCnt >= 0)
                ThrowFormatError("bone_cnt");
            m_BoneCnt = Snk->ReadInt();
        }
        else if(FieldName == "bone_name_array")
        {
            int BoneNameCnt = Snk->GetRemainStr();
            if(BoneNameCnt != m_BoneCnt)
                ThrowFormatError("bone_name_array");
            m_BoneNameArray.Alloc(m_BoneCnt);
            int i;
            for(i = 0; i < m_BoneCnt; i++)
                m_BoneNameArray[i] = Snk->ReadStr();
        }
        else if(FieldName == "bone_transf_array")
        {
            int BoneTransfCnt = Snk->GetRemainFloat() / 7;
            if(BoneTransfCnt != m_BoneCnt)
                ThrowFormatError("bone_transf_array");
            m_BoneTransfArray.Alloc(m_BoneCnt);
            int i;
            for(i = 0; i < m_BoneCnt; i++)
            {
                s3d_CUtilTranslQuatf Transf;
                Transf.m_Transl.m_x = Snk->ReadFloat();
                Transf.m_Transl.m_y = Snk->ReadFloat();
                Transf.m_Transl.m_z = Snk->ReadFloat();
                Transf.m_Quat.m_x = Snk->ReadFloat();
                Transf.m_Quat.m_y = Snk->ReadFloat();
                Transf.m_Quat.m_z = Snk->ReadFloat();
                Transf.m_Quat.m_w = Snk->ReadFloat();
                m_BoneTransfArray[i] = Transf;
            }
        }
        else if(FieldName == "tex_name_array")
        {
            if(HasTexCnt)
                ThrowFormatError("tex_name_array");
            HasTexCnt = true;
            m_TexNameCnt = Snk->GetRemainStr();
            if(m_TexNameArray)
                ThrowFormatError("tex_name_array");
            m_TexNameArray.Alloc(m_TexNameCnt);
            int i;
            for(i = 0; i < m_TexNameCnt; i++)
                m_TexNameArray[i] = Snk->ReadStr();
        }
        else if(FieldName == "variant_cnt")
        {
            if(HasVariant)
                ThrowFormatError("variant");
            HasVariant = true;
            int NewVariantCnt = Snk->ReadInt();
            m_VariantCnt = NewVariantCnt;
        }
        else if(FieldName == "variantdesc_array")
        {
            if(HasVariantDesc)
                ThrowFormatError("variantdesc_array");
            HasVariantDesc = true;
            int NewVariantDescCnt = Snk->GetRemainChunk();
            m_VariantDescCnt = NewVariantDescCnt;
            m_VariantDescArray.Alloc(m_VariantDescCnt);
            int iVariantDesc;
            for(iVariantDesc = 0; iVariantDesc < m_VariantDescCnt; 
                    iVariantDesc++)
            {
                Snk->BeginChunk();
                ReadVariantDesc(Snk, m_VariantDescArray[iVariantDesc]);
                Snk->EndChunk();
            }
        }
        Snk->EndField();
    }
}*/

void s3d_CSharkMeshLoader::ReadModelGT()
{
	if (m_GeoMesh->mSubMeshCount>1)
		ThrowFormatError("Only meshes composed by 1 submesh are supported.");

/*	if (!m_GeoMesh->mVertexBuffer || (m_GeoMesh->mVertexBuffer && m_GeoMesh->mVertexBuffer->mVertexCount==0))
		m_GeoMesh = m_GeoMesh->toSharedVertex(); // the original mesh must be deleted! MEMORY LEAK!
*/
//	assert(!m_GeoMesh->mVertexBuffer || (m_GeoMesh->mVertexBuffer && m_GeoMesh->mVertexBuffer->mVertexCount==0));
/*	if (m_GeoMesh->mSubMesh[0].mType==Geometry::GEO_TRIANGLE_STRIPS)
		use_triangle_strips = true;*/

	if (geo_mesh_loader.GetLodStripsData()==NULL)
		ThrowFormatError("Only mesh models with LOD info are supported");		

    m_RangeStart = 0; // parece que estos e refiere a las animaciones
    m_RangeEnd = 0;

    m_BoundCen = 0;
    m_BoundExt = 0;

    m_BoneCnt = -1;

    m_BoneNameArray.Reset();
    m_BoneTransfArray.Reset();
    m_TexNameArray.Reset();

    bool HasTexCnt = false;
    bool HasVariant = false;
    bool HasVariantDesc = false;

	m_ModelName = "GtModel";

	m_BoundCen.m_x = (m_GeoMesh->mMeshBounds.minX + m_GeoMesh->mMeshBounds.maxX) / 2;
	m_BoundCen.m_y = (m_GeoMesh->mMeshBounds.minY + m_GeoMesh->mMeshBounds.maxY) / 2;
	m_BoundCen.m_z = (m_GeoMesh->mMeshBounds.minZ + m_GeoMesh->mMeshBounds.maxZ) / 2;
	m_BoundExt.m_x = fabsf(m_GeoMesh->mMeshBounds.minX - m_GeoMesh->mMeshBounds.maxX);
	m_BoundExt.m_y = fabsf(m_GeoMesh->mMeshBounds.minY - m_GeoMesh->mMeshBounds.maxY);
	m_BoundExt.m_z = fabsf(m_GeoMesh->mMeshBounds.minZ - m_GeoMesh->mMeshBounds.maxZ);

	// VERTEX BUFFER INFO
	// alloc vertex buffer
    m_PointBankSig = S3D_SYS_NEW s3d_CDrvSig;
    m_PointBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
    m_PointBank->m_Loader = this;
    m_PointBank->m_Cnt = m_GeoMesh->mVertexBuffer->mVertexCount;
    m_PointBank->m_Data.Alloc(m_GeoMesh->mVertexBuffer->mVertexCount);

	// alloc normal buffer
    m_NormalBankSig = S3D_SYS_NEW s3d_CDrvSig;
    m_NormalBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
    m_NormalBank->m_Loader = this;
    m_NormalBank->m_Cnt = m_GeoMesh->mVertexBuffer->mVertexCount;
    m_NormalBank->m_Data.Alloc(m_GeoMesh->mVertexBuffer->mVertexCount);

	// alloc tex buffer
	m_TexAttrArray = S3D_SYS_NEW s3d_CEngMeshAttr;
    m_TexAttrArray->m_BankSig = S3D_SYS_NEW s3d_CDrvSig;
    s3d_CSharkMeshLoaderBankVec2f *tBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec2f;
    tBank->m_Loader = this;
    tBank->m_Cnt = m_GeoMesh->mVertexBuffer->mVertexCount;
    tBank->m_Data.Alloc(m_GeoMesh->mVertexBuffer->mVertexCount);
	m_TexAttrArray->m_Bank = tBank;

    s3d_CUtilVec3f *vData = m_PointBank->m_Data;
    s3d_CUtilVec3f *nData = m_NormalBank->m_Data;
    s3d_CUtilVec2f *tData = tBank->m_Data;
    for(int i = 0; i < m_GeoMesh->mVertexBuffer->mVertexCount; i++)
    {
        s3d_CUtilVec3f Val;
        Val.m_x = m_GeoMesh->mVertexBuffer->mPosition[i].x;
        Val.m_y = m_GeoMesh->mVertexBuffer->mPosition[i].y;
        Val.m_z = m_GeoMesh->mVertexBuffer->mPosition[i].z;
        vData[i] = Val;

        Val.m_x = m_GeoMesh->mVertexBuffer->mNormal[i].x;
        Val.m_y = m_GeoMesh->mVertexBuffer->mNormal[i].y;
        Val.m_z = m_GeoMesh->mVertexBuffer->mNormal[i].z;
        nData[i] = Val;

        s3d_CUtilVec2f Val2;
        Val2.m_x = m_GeoMesh->mVertexBuffer->mTexCoords[i].x;
        Val2.m_y = m_GeoMesh->mVertexBuffer->mTexCoords[i].y;
        tData[i] = Val2;
    }

	// INDICES
	m_IdxBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
	m_IdxBank->m_Loader = this;
    m_IdxBank->m_Cnt = 0;

	for (int i=0; i<m_GeoMesh->mSubMeshCount; i++)
		m_IdxBank->m_Cnt += m_GeoMesh->mSubMesh[i].mIndexCount;

	m_IdxBank->m_Data.Alloc(m_IdxBank->m_Cnt);

	for (int i=0, k=0; i<m_GeoMesh->mSubMeshCount; i++)
	{
		for (int j=0; j<m_GeoMesh->mSubMesh[i].mIndexCount; j++, k++)
		{
			int RawIdx = m_GeoMesh->mSubMesh[i].mIndex[j];
			if (RawIdx < 0 || RawIdx >= m_GeoMesh->mVertexBuffer->mVertexCount)
				ThrowFormatError("m_GeoMesh->mSubMesh[i].mIndex[j] out_of_range");

			s3d_CSharkMeshLoaderIdx Idx = s3d_CSharkMeshLoaderIdx(RawIdx);
			m_IdxBank->m_Data[k] = Idx;
		}
	}

	// BONE INDICES
	/* nuevo de los huesos!*/
/*	if (m_GeoMesh->hasSkeleton)
	{
		m_BoneCnt = m_GeoMesh->mBones.size();
		m_BoneIdxBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
		m_BoneIdxBank->m_Loader = this;
		m_BoneIdxBank->m_Cnt = 0;

		m_BoneIdxBank->m_Data.Alloc(m_GeoMesh->mSubMesh[0].m
	}
	
*/

	/* */


//	// FAMILIES
//	m_FamilyArray = new s3d_CEngMeshFamily[m_GeoMesh->mSubMeshCount]; //m_Topol.m_FamilyArray;
//	for (int i=0; i<m_GeoMesh->mSubMeshCount; i++)
//	{
//		m_FamilyArray[i].m_BoneIdxCnt = 0;
//		m_FamilyArray[i].m_BoneIdxEssCnt = 0;
//		m_FamilyArray[i].m_IdxCnt = m_GeoMesh->mSubMesh[i].mIndexCount;
//		m_FamilyArray[i].m_IdxEssCnt = m_GeoMesh->mSubMesh[i].mIndexCount;
//		m_FamilyArray[i].m_PacketCnt = 1;
//		m_FamilyArray[i].m_VertCnt = m_GeoMesh->mSubMesh[i].mVertexBuffer->mVertexCount;
//		m_FamilyArray[i].m_VertEssCnt = m_FamilyArray[i].m_VertCnt;
//	}

	// PACKETS

	m_PacketsBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankPacket;		
	m_PacketsBank->m_Loader = this;
	m_PacketsBank->m_Cnt = m_GeoMesh->mSubMeshCount; // always assume 1 packet per family
	m_PacketsBank->m_Data.Alloc(m_PacketsBank->m_Cnt);
    s3d_CDrvMeshPacket *Data = m_PacketsBank->m_Data;
    for(int iPacket = 0; iPacket < m_PacketsBank->m_Cnt; iPacket++)
    {
        s3d_CDrvMeshPacket *Packet = &Data[iPacket];
		Packet->m_VertCnt = m_GeoMesh->mSubMesh[iPacket].mVertexBuffer->mVertexCount;
        Packet->m_VertEssCnt = Packet->m_VertCnt;
        Packet->m_IdxCnt = m_GeoMesh->mSubMesh[iPacket].mIndexCount;
        Packet->m_IdxEssCnt = Packet->m_IdxCnt;
        Packet->m_BoneIdxCnt = 0;
        Packet->m_BoneIdxEssCnt = 0;
    }

 /*   while(Snk->GetRemainField() > 0)
    {
        s3d_CUtilStr FieldName = Snk->BeginField();
        if(FieldName == "name")
            m_ModelName = Snk->ReadStr();
        else if(FieldName == "range")
        {
            m_RangeStart = Snk->ReadFloat();
            m_RangeEnd = Snk->ReadFloat();
        }
        else if(FieldName == "bound")
        {
            m_BoundCen.m_x = Snk->ReadFloat();
            m_BoundCen.m_y = Snk->ReadFloat();
            m_BoundCen.m_z = Snk->ReadFloat();
            m_BoundExt.m_x = Snk->ReadFloat();
            m_BoundExt.m_y = Snk->ReadFloat();
            m_BoundExt.m_z = Snk->ReadFloat();
        }
        else if(FieldName == "bone_cnt")
        {
            if(m_BoneCnt >= 0)
                ThrowFormatError("bone_cnt");
            m_BoneCnt = Snk->ReadInt();
        }
        else if(FieldName == "bone_name_array")
        {
            int BoneNameCnt = Snk->GetRemainStr();
            if(BoneNameCnt != m_BoneCnt)
                ThrowFormatError("bone_name_array");
            m_BoneNameArray.Alloc(m_BoneCnt);
            int i;
            for(i = 0; i < m_BoneCnt; i++)
                m_BoneNameArray[i] = Snk->ReadStr();
        }
        else if(FieldName == "bone_transf_array")
        {
            int BoneTransfCnt = Snk->GetRemainFloat() / 7;
            if(BoneTransfCnt != m_BoneCnt)
                ThrowFormatError("bone_transf_array");
            m_BoneTransfArray.Alloc(m_BoneCnt);
            int i;
            for(i = 0; i < m_BoneCnt; i++)
            {
                s3d_CUtilTranslQuatf Transf;
                Transf.m_Transl.m_x = Snk->ReadFloat();
                Transf.m_Transl.m_y = Snk->ReadFloat();
                Transf.m_Transl.m_z = Snk->ReadFloat();
                Transf.m_Quat.m_x = Snk->ReadFloat();
                Transf.m_Quat.m_y = Snk->ReadFloat();
                Transf.m_Quat.m_z = Snk->ReadFloat();
                Transf.m_Quat.m_w = Snk->ReadFloat();
                m_BoneTransfArray[i] = Transf;
            }
        }
        else if(FieldName == "tex_name_array")
        {
            if(HasTexCnt)
                ThrowFormatError("tex_name_array");
            HasTexCnt = true;
            m_TexNameCnt = Snk->GetRemainStr();
            if(m_TexNameArray)
                ThrowFormatError("tex_name_array");
            m_TexNameArray.Alloc(m_TexNameCnt);
            int i;
            for(i = 0; i < m_TexNameCnt; i++)
                m_TexNameArray[i] = Snk->ReadStr();
        }
        else if(FieldName == "variant_cnt")
        {
            if(HasVariant)
                ThrowFormatError("variant");
            HasVariant = true;
            int NewVariantCnt = Snk->ReadInt();
            m_VariantCnt = NewVariantCnt;
        }
        else if(FieldName == "variantdesc_array")
        {
            if(HasVariantDesc)
                ThrowFormatError("variantdesc_array");
            HasVariantDesc = true;
            int NewVariantDescCnt = Snk->GetRemainChunk();
            m_VariantDescCnt = NewVariantDescCnt;
            m_VariantDescArray.Alloc(m_VariantDescCnt);
            int iVariantDesc;
            for(iVariantDesc = 0; iVariantDesc < m_VariantDescCnt; 
                    iVariantDesc++)
            {
                Snk->BeginChunk();
                ReadVariantDesc(Snk, m_VariantDescArray[iVariantDesc]);
                Snk->EndChunk();
            }
        }
        Snk->EndField();
    }*/
}

/*
void s3d_CSharkMeshLoader::ReadVariantDesc(
        s3d_CUtilSnkSeqRead *Snk, 
        s3d_CSharkMeshLoaderVariantDesc &VariantDesc)
{
    while(Snk->GetRemainField() > 0)
    {
        s3d_CUtilStr FieldName = Snk->BeginField();
        if(FieldName == "usage")
        {
            s3d_CUtilStr UsageStr = Snk->ReadStr();
            VariantDesc.m_Usage = m_AtomMgr->GetAtom(UsageStr);
        }
        else if(FieldName == "prec")
            VariantDesc.m_Prec = Snk->ReadFloat();
        else if(FieldName == "variant_idx")
            VariantDesc.m_VariantIdx = Snk->ReadInt();
        Snk->EndField();
    }
}*/

void s3d_CSharkMeshLoader::ThrowFormatError(s3d_CUtilStr_cr Kind)
{
    s3d_CUtilMsg e;
    e.m_Code = "eng/model/std/SHARK_MESH_LOADER.format";
    e.m_StdTempl = "Model \"[1]\" has an illegal format "
                    "concerning \"[2]\".";
    e.AddInfo(m_Info);
    e.AddInfo(m_ModelName);
    e.AddInfo(Kind);
    s3d_UtilMsgReportFatal(m_MsgHandler, e);
}
/*
s3d_CSysIntps s3d_CSharkMeshLoader::SearchVariantIdxPrec(
        s3d_CUtilAtom *Usage, float Prec)
{
    if(!Usage)
        return -1;

    s3d_CSysIntps BestBelowVariantIdx = -1;
    float BestBelowPrec = -FLT_MAX;
    s3d_CSysIntps BestAboveVariantIdx = -1;
    float BestAbovePrec = FLT_MAX;
    s3d_CSysIntps iVariantDesc;
    for(iVariantDesc = 0; iVariantDesc < m_VariantDescCnt; iVariantDesc++)
    {
        s3d_CSharkMeshLoaderVariantDesc *VariantDesc = 
                &m_VariantDescArray[iVariantDesc];
        if(VariantDesc->m_Usage == Usage)
        {
            float VariantPrec = VariantDesc->m_Prec;
            if(VariantPrec <= Prec)
            {
                if(VariantPrec > BestBelowPrec)
                {
                    BestBelowVariantIdx = VariantDesc->m_VariantIdx;
                    BestBelowPrec = VariantPrec;
                }
            }
            else
            {
                if(VariantPrec < BestAbovePrec)
                {
                    BestAboveVariantIdx = VariantDesc->m_VariantIdx;
                    BestAbovePrec = VariantPrec;
                }
            }
        }
    }
    if(BestBelowVariantIdx >= 0)
        return BestBelowVariantIdx;
    else
        return BestAboveVariantIdx;
}*/

float s3d_CSharkMeshLoader::CalcMeshPrec(
                        s3d_CUtilMat4x4f_cr Map, s3d_CUtilVec3f_cr Prec)
{
    if(Map == 0)
        return 0;
    if(Prec == 0)
        return 0;
    s3d_CUtilMat3x3f Deriv = Map.MulOneProjDeriv(m_BoundCen);
    s3d_CUtilVec3f Scale = Deriv.RowGetSumAbsComp();
    float MeshPrec = Prec.CompDiv(Scale).GetMinComp();
    return MeshPrec;
}

///////////////////////////////////////////////////////////////////////////////
/*@{ 

@declare{comp.class}{SHARK_MESH_LOADER.modelsuppl}{}

Supplier for standard models as written by the prepare tool.
@p

@}*/
///////////////////////////////////////////////////////////////////////////////

S3D_UTIL_RTTI_TABLE_DEFINE_BEGIN(s3d_CSharkMeshLoaderSuppl)
S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompSuppl)
S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompSetup)
S3D_UTIL_RTTI_TABLE_DEFINE_END

s3d_CSharkMeshLoaderSuppl::s3d_CSharkMeshLoaderSuppl()
{
}

s3d_CSharkMeshLoaderSuppl::s3d_CSharkMeshLoaderSuppl(
        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
        bool Bare, s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr)
{
    m_Bare = Bare;
    m_AtomMgr = AtomMgr;
    m_ResMgr = ResMgr;
}

void s3d_CSharkMeshLoaderSuppl::SetupInit(
        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
        s3d_CCompSuppl *FetchSuppl, s3d_CUtilSnkChunk *Param)
{
    s3d_CUtilSnkExtract SnkExtract;
    SnkExtract.Assign(MsgHandler, Param);

    /*@{ @declare{comp.param}{shark_mesh_loader.modelsuppl.env}{$ [str]}
    @}*/
    s3d_CUtilStr EnvIdent, EnvInfo;
    SnkExtract.ExtractStr(EnvInfo, EnvIdent, "env", true);

    SnkExtract.CheckForUnknown();

    s3d_CCompEnvPtr Env = s3d_CompSupplObjT<s3d_CCompEnv>(
            MsgHandler, EnvInfo, FetchSuppl, 
            EnvIdent, S3D_GENERAL_INTEROP_INTERF);
    if(!Env)
        return;

    m_Bare = Env->m_Bare;
    m_AtomMgr = Env->m_AtomMgr;
    m_ResMgr = Env->m_ResMgr;
}

void s3d_CSharkMeshLoaderSuppl::SetupDone()
{
}

s3d_CCompObjPtr s3d_CSharkMeshLoaderSuppl::SupplObj(
        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
        s3d_CUtilStr_cr Ident, s3d_CUtilStr_cr Version)
{
    if(Ident.IsEmpty())
        return 0;

    s3d_CUtilMsg m;
    m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.create_model";
    m.m_StdTempl = "Creating standard model \"[1]\". "
            "The model is not loaded yet. ";
    m.AddInfo(Info);
    m.AddInfo(Ident);
    s3d_UtilMsgReportNote(MsgHandler, m);

    s3d_CSharkMeshLoaderPtr Model = S3D_SYS_NEW s3d_CSharkMeshLoader(
            MsgHandler, Info, m_Bare, m_AtomMgr, m_ResMgr, Ident);
    return Model.Get();
}

void s3d_CSharkMeshLoader::LoaderPerform()
{
    Load();
}


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