source: GTP/trunk/App/Demos/Geom/Shark3D/src/shark_mesh_loader/shark_mesh_loader_model.cpp @ 2236

Revision 2236, 91.8 KB checked in by gumbau, 17 years ago (diff)
Line 
1///////////////////////////////////////////////////////////////////////////////
2//
3//      ##  ######
4//       ######  ###
5//  ## ###############        Shark 3D Engine (www.shark3d.com)
6//   ########## # # #
7//    ########                Copyright (c) 1996-2006 Spinor GmbH.
8//   ######### # # #          All rights reserved.
9//  ##   ##########
10//      ##
11//
12///////////////////////////////////////////////////////////////////////////////
13
14//@cpp
15
16#include "shark_mesh_loader_model.h"
17#include "../../interf/eng_actu.h"
18#include "../../../util/snk/util_snk_work.h"
19#include "../../../util/snk/util_snk_extract.h"
20#include "../../../util/os/util_filesystem.h"
21#include "../../../drv/interf/drv_gfx.h"
22#include "../../../general/general_def.h"
23
24
25///////////////////////////////////////////////////////////////////////////////
26
27
28#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPX (1 << 0)
29#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPY (1 << 1)
30#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPZ (1 << 2)
31#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORX (1 << 3)
32#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORY (1 << 4)
33#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORZ (1 << 5)
34#define S3D_SHARK_MESH_LOADER_SAMPLERMODE_FILTER (1 << 6)
35
36///////////////////////////////////////////////////////////////////////////////
37
38template<typename T>
39void s3d_SharkMeshLoaderInterpInterpBetweenT(
40        s3d_CSysIntps Cnt, T *Target,
41        const T *ArrayA, const T *ArrayB, float Frac)
42{
43    if(Target && ArrayA && ArrayB)
44    {
45        while(Cnt > 0)
46        {
47            T VecA = *ArrayA++;
48            T VecB = *ArrayB++;
49            T Vec = VecA.InterpLinear(VecB, Frac);
50            *Target++ = Vec;
51            Cnt--;
52        }
53    }
54}
55
56template<typename T>
57void s3d_SharkMeshLoaderInterpInternT(
58        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
59        s3d_CUtilMemPool *MemPool,
60        s3d_CSysIntps VertCnt, s3d_CSysIntps FrmCnt,
61        s3d_CSysIntps iKit, float KitFrac,
62        s3d_CEngMeshAttr &Attr)
63{
64    Attr.m_BankSig = 0;
65    s3d_CSysIntps VertFrmCnt = VertCnt * FrmCnt;
66    const T *Data = s3d_DrvBankFetchArray<T>(
67            MsgHandler, Info, "stdmesh_interp_t", Attr.m_Bank, VertFrmCnt);
68    if(Data)
69    {
70        Data += iKit * VertCnt;
71        if(iKit == FrmCnt)
72            Data -= VertCnt;
73        else if(iKit > 0)
74        {
75            if(KitFrac == 0)
76                Data -= VertCnt;
77            else if(KitFrac < 1)
78            {
79                const T *DataA = Data - VertCnt;
80                const T *DataB = Data;
81                T *NewData = new(MemPool) T[VertCnt];
82                s3d_CDrvBankGivenArray<T> *NewBank
83                        = new(MemPool) s3d_CDrvBankGivenArray<T>(
84                                VertCnt, Data, 0);
85                Attr.m_Bank = NewBank;
86                s3d_SharkMeshLoaderInterpInterpBetweenT(VertCnt, NewData,
87                        DataA, DataB, KitFrac);
88            }
89        }
90    }
91}
92
93void s3d_CSharkMeshLoaderInterp::EvalFrm(
94        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
95        s3d_CUtilMemPool *MemPool,
96        s3d_CSysIntps FrmCnt, s3d_CSysIntps iKit, float KitFrac,
97        s3d_CEngMeshData *MeshData)
98{
99    s3d_CSysIntps VertCnt = MeshData->m_Topol.m_VertCnt;
100    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec3f>(
101            MsgHandler, Info, MemPool,
102            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_PointAttr);
103    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec3f>(
104            MsgHandler, Info, MemPool,
105            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_NormalAttr);
106    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec3f>(
107            MsgHandler, Info, MemPool,
108            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_TangentUAttr);
109    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec3f>(
110            MsgHandler, Info, MemPool,
111            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_TangentVAttr);
112    s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec4f>(
113            MsgHandler, Info, MemPool,
114            VertCnt, FrmCnt, iKit, KitFrac, MeshData->m_ColorAlphaAttr);
115    s3d_CSysIntps AttrCnt = MeshData->m_TexAttrCnt;       
116    s3d_CSysIntps iAttr;
117    for(iAttr = 0; iAttr < AttrCnt; iAttr++)
118    {
119        s3d_SharkMeshLoaderInterpInternT<s3d_CUtilVec2f>(
120                MsgHandler, Info, MemPool,
121                VertCnt, FrmCnt, iKit, KitFrac,
122                MeshData->m_TexAttrArray[iAttr]);
123    }
124}
125
126template<typename T>
127void s3d_SharkMeshLoaderInterpInterRedT(
128        s3d_CSysIntps Cnt, T *Target, const T *Array,
129        const s3d_CSharkMeshLoaderIdx *RedArray, float Frac)
130{
131    if(Target && Array && RedArray)
132    {
133        int i;
134        for(i = 0; i < Cnt; i++)
135        {
136            int iRed = RedArray[i];
137            S3D_SYS_ASSERT(s3d_SysIsValidArrayIdx(iRed, Cnt));
138            if(iRed == i)
139                Target[i] = Array[i];
140            else
141            {
142                T VecBase = Array[i];
143                T VecRed = Array[iRed];
144                T Vec = VecBase.InterpLinear(VecRed, Frac);
145                Target[i] = Vec;
146            }
147        }
148    }
149}
150
151///////////////////////////////////////////////////////////////////////////////
152
153template<typename T>
154S3D_SYS_INLINE void s3d_SharkMeshLoaderReduceBank(
155        s3d_CSysIntps &SizeTotal,
156        s3d_CSysIntps &SizeBefore,
157        s3d_CSysIntps &SizeAfter,
158        const s3d_CUtilPtr< s3d_CSharkMeshLoaderBank<T> > &Bank)
159{
160    if(Bank)
161    {
162        s3d_CSysIntps BankSize = Bank->m_Cnt * S3D_SYS_SIZEOFS(T);
163        SizeTotal += BankSize;
164        if(Bank->m_Data)
165        {
166            SizeBefore += BankSize;
167            if(Bank->m_RefCnt == 1)
168                Bank->m_Data.Reset();
169            else
170                SizeAfter += BankSize;
171        }
172    }
173}
174
175///////////////////////////////////////////////////////////////////////////////
176
177/*s3d_CSharkMeshLoaderVariant::s3d_CSharkMeshLoaderVariant(
178        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
179        bool Bare,
180        s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr,
181        s3d_CUtilStr_cr ResName, s3d_CSharkMeshLoaderChanged *Changed)
182{
183    m_MsgHandler = MsgHandler;
184    m_Info = Info;
185    m_Bare = Bare;
186    m_AtomMgr = AtomMgr;
187    m_ResMgr = ResMgr;
188    m_ResName = ResName;
189    m_Changed = Changed;
190
191    m_NotifRecip.Assign(this, &s3d_CSharkMeshLoaderVariant::ResChanged);
192    m_Loaded = false;
193    m_Reduced = false;
194
195    m_VariantSig = S3D_SYS_NEW s3d_CDrvSig;
196    m_Topol.m_TopolSig = S3D_SYS_NEW s3d_CDrvSig;
197}
198
199s3d_CSharkMeshLoaderVariant::~s3d_CSharkMeshLoaderVariant()
200{
201}
202
203void s3d_CSharkMeshLoaderVariant::GetMeshComposBase(
204        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
205        s3d_CEngMeshCompos &MeshCompos)
206{
207    CheckLoad();
208
209    MeshCompos.m_MeshSig = m_VariantSig;
210    MeshCompos.m_TexFamilyCnt = m_Topol.m_FamilyCnt;
211    MeshCompos.m_TexLayerCnt = m_TexLayerCnt;
212    MeshCompos.m_TexIdxArray = m_TexIdxArray;
213    MeshCompos.m_SampModeArray = m_SampModeArray;
214    MeshCompos.m_MeshData = EvalMeshDataBase(MemPool, Usage);
215}
216
217void s3d_CSharkMeshLoaderVariant::GetMeshComposFull(
218        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
219        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
220        s3d_CEngModelCtx *ModelCtx,
221        bool NeedMeshData,
222        s3d_CEngMeshCompos &MeshCompos)
223{   
224    CheckLoad();
225
226    MeshCompos.m_MeshSig = m_VariantSig;
227    MeshCompos.m_TexFamilyCnt = m_Topol.m_FamilyCnt;
228    MeshCompos.m_TexLayerCnt = m_TexLayerCnt;
229    MeshCompos.m_TexIdxArray = m_TexIdxArray;
230    MeshCompos.m_SampModeArray = m_SampModeArray;
231    if(NeedMeshData)
232    {
233        MeshCompos.m_MeshData = EvalMeshDataFull(
234                MsgHandler, Info, MemPool, Usage, ModelCtx);
235    }
236}
237
238s3d_CEngGeoData *s3d_CSharkMeshLoaderVariant::GetGeoData(
239        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
240        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage)
241{
242    CheckLoad();
243
244    if(m_CouldMorePrim)
245    {
246        s3d_CUtilMsg e;
247        e.m_Code =
248                "eng/posgen/std/eng_posgen_std_model.variant_could_more_prim";
249        e.m_StdTempl = "Geometry has triangles which could be exported "
250                "as primitive geometry instead. ";
251        e.AddInfo(m_Info);
252        s3d_UtilMsgReportError(m_MsgHandler, e);
253    }
254
255    if(m_Topol.m_IdxCnt != m_Topol.m_IdxEssCnt)
256    {
257        s3d_CUtilMsg e;
258        e.m_Code =
259                "eng/posgen/std/eng_posgen_std_model.not_all_essential";
260        e.m_StdTempl = "Geometry has triangles which are not essential. ";
261        e.AddInfo(m_Info);
262        s3d_UtilMsgReportError(m_MsgHandler, e);
263        return 0;
264    }
265
266    s3d_CSysIntps FamilyCnt = m_Topol.m_FamilyCnt;
267    s3d_CSysIntps *FamilyIdxCntArray = new(MemPool) s3d_CSysIntps[FamilyCnt];
268    s3d_CSysIntps iFamily;
269    for(iFamily = 0; iFamily < FamilyCnt; iFamily++)
270        FamilyIdxCntArray[iFamily] = m_Topol.m_FamilyArray[iFamily].m_IdxCnt;
271
272    s3d_CEngGeoData *Geo = new(MemPool) s3d_CEngGeoData;
273    Geo->m_Info = m_Info.GetChars();
274    Geo->m_Desc = m_ResName.GetChars();
275    Geo->m_FamilyCnt = m_Topol.m_FamilyCnt;
276    Geo->m_FamilyMtlArray = m_MtlArray;
277    Geo->m_FamilyFrictArray = m_FrictArray;
278    Geo->m_FamilySoftnessArray = m_SoftnessArray;
279    Geo->m_FamilyBounceArray = m_BounceArray;
280    Geo->m_IdxCnt = m_Topol.m_IdxCnt;
281    Geo->m_IdxBank = m_Topol.m_IdxBank;
282    Geo->m_OppBank = m_Topol.m_OppBank;
283    Geo->m_FamilyIdxCntArray = FamilyIdxCntArray;
284    Geo->m_PointCnt = m_Topol.m_VertCnt;
285    Geo->m_PointBank = m_PointBank;
286    Geo->m_SphereCnt = m_PrimSphereCnt;
287    Geo->m_SphereArray = m_PrimSphereArray;
288    Geo->m_CapsuleCnt = m_PrimCapsuleCnt;
289    Geo->m_CapsuleArray = m_PrimCapsuleArray;
290    return Geo;
291}
292
293void s3d_CSharkMeshLoaderVariant::Reduce()
294{
295    if(m_RefCnt > 1)
296        return; // Someone else holds a reference to it as Owner.
297
298    m_Reduced = true;
299
300    s3d_CSysIntps SizeTotal = 0;
301    s3d_CSysIntps SizeBefore = 0;
302    s3d_CSysIntps SizeAfter = 0;
303
304    //s3d_SharkMeshLoaderReduceBank(
305    //        SizeTotal, SizeBefore, SizeAfter,
306    //        m_Topol.m_PacketArray);
307    s3d_SharkMeshLoaderReduceBank(
308            SizeTotal, SizeBefore, SizeAfter,
309            m_Topol.m_PacketBank);
310    s3d_SharkMeshLoaderReduceBank(
311            SizeTotal, SizeBefore, SizeAfter,
312            m_Topol.m_IdxBank);
313    s3d_SharkMeshLoaderReduceBank(
314            SizeTotal, SizeBefore, SizeAfter,
315            m_Topol.m_OppBank);
316    s3d_SharkMeshLoaderReduceBank(
317            SizeTotal, SizeBefore, SizeAfter,
318            m_Topol.m_BoneIdxBank);
319    s3d_SharkMeshLoaderReduceBank(
320            SizeTotal, SizeBefore, SizeAfter,
321            m_BoneWghBank);
322    s3d_SharkMeshLoaderReduceBank(
323            SizeTotal, SizeBefore, SizeAfter,
324            m_BoneSubscrBank);
325    s3d_SharkMeshLoaderReduceBank(
326            SizeTotal, SizeBefore, SizeAfter,
327            m_PointBank);
328    s3d_SharkMeshLoaderReduceBank(
329            SizeTotal, SizeBefore, SizeAfter,
330            m_NormalBank);
331    s3d_SharkMeshLoaderReduceBank(
332            SizeTotal, SizeBefore, SizeAfter,
333            m_TangentUBank);
334    s3d_SharkMeshLoaderReduceBank(
335            SizeTotal, SizeBefore, SizeAfter,
336            m_TangentVBank);
337    s3d_SharkMeshLoaderReduceBank(
338            SizeTotal, SizeBefore, SizeAfter,
339            m_ColorAlphaBank);
340    s3d_CSysIntps nTexAttr = m_TexAttrCnt;
341    s3d_CSysIntps iTexAttr;
342    for(iTexAttr = 0; iTexAttr < nTexAttr; iTexAttr++)
343    {
344        s3d_CSharkMeshLoaderAttr *TexAttr = &m_TexAttrArray[iTexAttr];
345        s3d_SharkMeshLoaderReduceBank(
346                SizeTotal, SizeBefore, SizeAfter,
347                TexAttr->m_Bank);
348    }
349
350    s3d_CUtilMsg m;
351    m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.variant_reduce";
352    m.m_StdTempl = "Reduced standard model variant \"[1]\". "
353                    "[2] total bytes. Reduced from [3] to [4] bytes. ";
354    m.AddInfo(m_Info);
355    m.AddInfo(m_ResName);
356    m.AddInfo(s3d_CUtilStrUtil::StrOfIntps(SizeTotal));
357    m.AddInfo(s3d_CUtilStrUtil::StrOfIntps(SizeBefore));
358    m.AddInfo(s3d_CUtilStrUtil::StrOfIntps(SizeAfter));
359    s3d_UtilMsgReportNote(m_MsgHandler, m);
360}
361
362void s3d_CSharkMeshLoaderVariant::CheckLoad()
363{
364    if(!m_Loaded)
365        Load(false);
366}
367
368void s3d_CSharkMeshLoaderVariant::Load(bool Restore)
369{
370    if(Restore)
371    {
372        s3d_CUtilMsg m;
373        m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.variant_load";
374        m.m_StdTempl = "Restoring standard model variant \"[1]\".";
375        m.AddInfo(m_Info);
376        m.AddInfo(m_ResName);
377        s3d_UtilMsgReportNote(m_MsgHandler, m);
378    }
379    else
380    {
381        s3d_CUtilMsg m;
382        m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.variant_load";
383        m.m_StdTempl = "Loading standard model variant \"[1]\".";
384        m.AddInfo(m_Info);
385        m.AddInfo(m_ResName);
386        s3d_UtilMsgReportNote(m_MsgHandler, m);
387    }
388
389    m_Loaded = true;
390    m_Reduced = false;
391
392    int Generosity = 0;
393    s3d_CUtilStr ResInfo;
394    s3d_CUtilStreamPtr ResStream;
395    bool Final = false;
396    m_ResMgr->GetResource(
397            m_Info, m_ResName, true, Generosity,
398            ResInfo, ResStream, Final, &m_NotifRecip);
399
400    if(ResStream && ResStream->GetSize() > 0)
401    {
402        s3d_CUtilSnkSeqReadPtr Snk;
403        int SnkFormat = 0;
404        s3d_CUtilSnkWork::CreateSeqReadStream(m_MsgHandler, m_Info,
405                        ResStream, m_Bare, SnkFormat, Snk);
406
407        s3d_CUtilStr Format;
408        while(Snk->GetRemainField() > 0)
409        {
410            s3d_CUtilStr FieldName = Snk->BeginField();
411            if(FieldName == "format")
412            {
413                Format = Snk->ReadStr();
414            }
415            else if(FieldName == "data")
416            {
417                if(Format == S3D_SHARK_MESH_LOADER_VARIANT_SNKFORMAT)
418                {
419                    Snk->BeginChunk();
420                    ReadData(Snk, Restore);
421                    Snk->EndChunk();
422                }
423                else
424                {
425                    s3d_CUtilMsg e;
426                    e.m_Code =
427                            "eng/posgen/std/eng_posgen_std_model.variant_format";
428                    e.m_StdTempl = "Found format \"[2]\" instead of \"[1]\".";
429                    e.AddInfo(m_Info);
430                    e.AddInfo(S3D_SHARK_MESH_LOADER_VARIANT_SNKFORMAT);
431                    e.AddInfo(Format);
432                    s3d_UtilMsgReportError(m_MsgHandler, e);
433                }
434            }
435            Snk->EndField();
436        }
437        if(Format.IsEmpty())
438        {
439            s3d_CUtilMsg e;
440            e.m_Code = "eng/posgen/std/eng_posgen_std_model.variant_no_format";
441            e.m_StdTempl = "No format \"[1]\" found.";
442            e.AddInfo(m_Info);
443            e.AddInfo(S3D_SHARK_MESH_LOADER_VARIANT_SNKFORMAT);
444            s3d_UtilMsgReportError(m_MsgHandler, e);
445        }
446
447        Snk->Finish();
448    }
449}
450
451void s3d_CSharkMeshLoaderVariant::ReadData(
452        s3d_CUtilSnkSeqRead *Snk, bool Restore)
453{
454    if(!Restore)
455    {
456        m_Topol.m_VertCnt = -1;
457        m_Topol.m_VertEssCnt = -1;
458        m_Topol.m_IdxCnt = -1;
459        m_Topol.m_IdxEssCnt = -1;
460        m_Topol.m_BoneIdxCnt = -1;
461        m_Topol.m_BoneIdxEssCnt = -1;
462        m_Topol.m_FamilyCnt = -1;
463        m_Topol.m_PacketCnt = -1;
464        m_FrmCnt = -1;
465        m_TexLayerCnt = -1;
466        m_TexAttrCnt = -1;
467        m_CouldMorePrim = false;
468    }
469
470    while(Snk->GetRemainField() > 0)
471    {
472        s3d_CUtilStr FieldName = Snk->BeginField();
473        if(FieldName == "vert_cnt")
474        {
475            s3d_CSysIntps NewVertCnt = Snk->ReadInt();
476            if(Restore)
477            {
478                if(NewVertCnt != m_Topol.m_VertCnt)
479                    ThrowRestoreError("vert_cnt");
480            }
481            else
482            {
483                if(m_Topol.m_VertCnt >= 0)
484                    ThrowFormatError("variant.vert_cnt");
485                m_Topol.m_VertCnt = NewVertCnt;
486            }
487        }
488        else if(FieldName == "vert_ess_cnt")
489        {
490            s3d_CSysIntps NewVertEssCnt = Snk->ReadInt();
491            if(Restore)
492            {
493                if(NewVertEssCnt != m_Topol.m_VertEssCnt)
494                    ThrowRestoreError("vert_ess_cmt");
495            }
496            else
497            {
498                if(m_Topol.m_VertEssCnt >= 0)
499                    ThrowFormatError("variant.vert_ess_cnt");
500                m_Topol.m_VertEssCnt = NewVertEssCnt;
501            }
502        }
503        else if(FieldName == "idx_cnt")
504        {
505            s3d_CSysIntps NewIdxCnt = Snk->ReadInt();
506            if(Restore)
507            {
508                if(NewIdxCnt != m_Topol.m_IdxCnt)
509                    ThrowRestoreError("idx_cnt");
510            }
511            else
512            {
513                if(m_Topol.m_IdxCnt >= 0)
514                    ThrowFormatError("variant.idx_cnt");
515                m_Topol.m_IdxCnt = NewIdxCnt;
516            }
517        }
518        else if(FieldName == "idx_ess_cnt")
519        {
520            s3d_CSysIntps NewIdxEssCnt = Snk->ReadInt();
521            if(Restore)
522            {
523                if(NewIdxEssCnt != m_Topol.m_IdxEssCnt)
524                    ThrowRestoreError("idx_ess_cnt");
525            }
526            else
527            {
528                if(m_Topol.m_IdxEssCnt >= 0)
529                    ThrowFormatError("variant.idx_ess_cnt");
530                m_Topol.m_IdxEssCnt = NewIdxEssCnt;
531            }
532        }
533        else if(FieldName == "bone_idx_cnt")
534        {
535            s3d_CSysIntps NewBoneIdxCnt = Snk->ReadInt();
536            if(Restore)
537            {
538                if(NewBoneIdxCnt != m_Topol.m_BoneIdxCnt)
539                    ThrowRestoreError("bone_idx_cnt");
540            }
541            else
542            {
543                if(m_Topol.m_BoneIdxCnt >= 0)
544                    ThrowFormatError("variant.bone_idx_cnt");
545                m_Topol.m_BoneIdxCnt = NewBoneIdxCnt;
546            }
547        }
548        else if(FieldName == "bone_idx_ess_cnt")
549        {
550            s3d_CSysIntps NewBoneIdxEssCnt = Snk->ReadInt();
551            if(Restore)
552            {
553                if(NewBoneIdxEssCnt != m_Topol.m_BoneIdxEssCnt)
554                    ThrowRestoreError("bone_idx_ess_cnt");
555            }
556            else
557            {
558                if(m_Topol.m_BoneIdxEssCnt >= 0)
559                    ThrowFormatError("variant.bone_idx_ess_cnt");
560                m_Topol.m_BoneIdxEssCnt = NewBoneIdxEssCnt;
561            }
562        }
563        else if(FieldName == "packet_cnt")
564        {
565            s3d_CSysIntps NewPacketCnt = Snk->ReadInt();
566            if(Restore)
567            {
568                if(NewPacketCnt != m_Topol.m_PacketCnt)
569                    ThrowRestoreError("packet_cnt");
570            }
571            else
572            {
573                if(m_Topol.m_PacketCnt >= 0)
574                    ThrowFormatError("variant.packet_cnt");
575                m_Topol.m_PacketCnt = NewPacketCnt;
576            }
577        }
578        else if(FieldName == "family_cnt")
579        {
580            s3d_CSysIntps NewFamilyCnt = Snk->ReadInt();
581            if(Restore)
582            {
583                if(NewFamilyCnt != m_Topol.m_FamilyCnt)
584                    ThrowRestoreError("family_cnt");
585            }
586            else
587            {
588                if(m_Topol.m_FamilyCnt >= 0)
589                    ThrowFormatError("variant.family_cnt");
590                m_Topol.m_FamilyCnt = NewFamilyCnt;
591            }
592        }
593        else if(FieldName == "closed")
594        {
595            m_Topol.m_Closed = (Snk->ReadInt() != 0);
596        }
597        else if(FieldName == "sealed")
598        {
599            m_Topol.m_Sealed = (Snk->ReadInt() != 0);
600        }
601        else if(FieldName == "family_array")
602        {
603            s3d_CSysIntps FamilyCnt = Snk->GetRemainInt() / 7;
604            if(FamilyCnt != m_Topol.m_FamilyCnt)
605                ThrowRestoreError("family_cnt");
606
607            m_Topol.m_FamilyArray.Alloc(m_Topol.m_FamilyCnt);
608            int iFamily;
609            for(iFamily = 0; iFamily < m_Topol.m_FamilyCnt; iFamily++)
610            {
611                s3d_CEngMeshFamily *Family = &m_Topol.m_FamilyArray[iFamily];
612                Family->m_VertCnt = Snk->ReadInt();
613                Family->m_VertEssCnt = Snk->ReadInt();
614                Family->m_IdxCnt = Snk->ReadInt();
615                Family->m_IdxEssCnt = Snk->ReadInt();
616                Family->m_BoneIdxCnt = Snk->ReadInt();
617                Family->m_BoneIdxEssCnt = Snk->ReadInt();
618                Family->m_PacketCnt = Snk->ReadInt();
619            }
620        }
621        else if(FieldName == "packet_array")
622        {
623            int PacketCnt = Snk->GetRemainInt() / 6;
624            if(PacketCnt != m_Topol.m_PacketCnt)
625                ThrowRestoreError("packet_cnt");
626
627            s3d_CSharkMeshLoaderBankPacketPtr Bank;
628            if(Restore)
629            {
630                Bank = m_Topol.m_PacketBank;
631                if(!Bank)
632                    ThrowRestoreError("packet_bank");
633            }
634            else
635            {
636                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankPacket;
637                Bank->m_Loader = this;
638                m_Topol.m_PacketBank = Bank;
639            }
640            if(!Bank->m_Data)
641            {
642                Bank->m_Cnt = PacketCnt;
643                Bank->m_Data.Alloc(PacketCnt);
644            }
645            s3d_CDrvMeshPacket *Data = Bank->m_Data;
646
647            int iPacket;
648            for(iPacket = 0; iPacket < PacketCnt; iPacket++)
649            {
650                s3d_CDrvMeshPacket *Packet = &Data[iPacket];
651                Packet->m_VertCnt = Snk->ReadInt();
652                Packet->m_VertEssCnt = Snk->ReadInt();
653                Packet->m_IdxCnt = Snk->ReadInt();
654                Packet->m_IdxEssCnt = Snk->ReadInt();
655                Packet->m_BoneIdxCnt = Snk->ReadInt();
656                Packet->m_BoneIdxEssCnt = Snk->ReadInt();
657            }
658        }
659        else if(FieldName == "bone_idx_array")
660        {
661            int BoneIdxCnt = Snk->GetRemainInt();
662            if(BoneIdxCnt != m_Topol.m_BoneIdxCnt)
663                ThrowRestoreError("bone_idx_cnt");
664
665            s3d_CSharkMeshLoaderBankMeshIdxPtr Bank;
666            if(Restore)
667            {
668                Bank = m_Topol.m_BoneIdxBank;
669                if(!Bank)
670                    ThrowRestoreError("bone_idx_bank");
671            }
672            else
673            {
674                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
675                Bank->m_Loader = this;
676                m_Topol.m_BoneIdxBank = Bank;
677            }
678            if(!Bank->m_Data)
679            {
680                Bank->m_Cnt = BoneIdxCnt;
681                Bank->m_Data.Alloc(BoneIdxCnt);
682            }
683            s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
684            int i;
685            for(i = 0; i < BoneIdxCnt; i++)
686            {
687                int RawBoneIdx = Snk->ReadInt();
688                s3d_CSharkMeshLoaderIdx BoneIdx = s3d_CSharkMeshLoaderIdx(RawBoneIdx);
689                Data[i] = BoneIdx;
690            }
691        }
692        else if(FieldName == "idx_array")
693        {
694            int IdxCnt = Snk->GetRemainInt();
695            if(IdxCnt != m_Topol.m_IdxCnt)
696                ThrowRestoreError("idx_cnt");
697
698            s3d_CSharkMeshLoaderBankMeshIdxPtr Bank;
699            if(Restore)
700            {
701                Bank = m_Topol.m_IdxBank;
702                if(!Bank)
703                    ThrowRestoreError("idx_bank");
704            }
705            else
706            {
707                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
708                Bank->m_Loader = this;
709                m_Topol.m_IdxCnt = IdxCnt;
710                m_Topol.m_IdxBank = Bank;
711            }
712            if(!Bank->m_Data)
713            {
714                Bank->m_Cnt = IdxCnt;
715                Bank->m_Data.Alloc(IdxCnt);
716            }
717            s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
718            int i;
719            for(i = 0; i < IdxCnt; i++)
720            {
721                int RawIdx = Snk->ReadInt();
722                if(RawIdx < 0 || RawIdx >= m_Topol.m_VertCnt)
723                    ThrowFormatError("variant.idx_cnt_array.idx_out_of_range");
724                s3d_CSharkMeshLoaderIdx Idx = s3d_CSharkMeshLoaderIdx(RawIdx);
725                Data[i] = Idx;
726            }
727        }
728        else if(FieldName == "opp_array")
729        {
730            int OppCnt = Snk->GetRemainInt();
731            if(OppCnt != m_Topol.m_IdxEssCnt)
732                ThrowFormatError("opp_array.idx_ess_cnt");
733
734            s3d_CSharkMeshLoaderBankMeshIdxPtr Bank;
735            if(Restore)
736            {
737                Bank = m_Topol.m_OppBank;
738                if(!Bank)
739                    ThrowRestoreError("opp_bank");
740            }
741            else
742            {
743                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
744                Bank->m_Loader = this;
745                m_Topol.m_OppBank = Bank;
746            }
747            if(!Bank->m_Data)
748            {
749                Bank->m_Cnt = OppCnt;
750                Bank->m_Data.Alloc(OppCnt);
751            }
752            s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
753            int i;
754            for(i = 0; i < OppCnt; i++)
755            {
756                int Val = Snk->ReadInt();
757                Data[i] = Val;
758            }
759        }
760        else if(FieldName == "neigh_array")
761        {
762            int NeighCnt = Snk->GetRemainInt();
763            if(NeighCnt != m_Topol.m_IdxEssCnt)
764                ThrowFormatError("neigh_array.idx_ess_cnt");
765
766            s3d_CSharkMeshLoaderBankMeshIdxPtr Bank;
767            if(Restore)
768            {
769                Bank = m_Topol.m_NeighBank;
770                if(!Bank)
771                    ThrowRestoreError("neigh_bank");
772            }
773            else
774            {
775                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
776                Bank->m_Loader = this;
777                m_Topol.m_NeighBank = Bank;
778            }
779            if(!Bank->m_Data)
780            {
781                Bank->m_Cnt = NeighCnt;
782                Bank->m_Data.Alloc(NeighCnt);
783            }
784            s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
785            int i;
786            for(i = 0; i < NeighCnt; i++)
787            {
788                int Val = Snk->ReadInt();
789                Data[i] = Val;
790            }
791        }
792        else if(FieldName == "tex_layer_cnt")
793        {
794            s3d_CSysIntps NewTexLayerCnt = Snk->ReadInt();
795            if(Restore)
796            {
797                if(NewTexLayerCnt != m_TexLayerCnt)
798                    ThrowRestoreError("tex_layer_cnt");
799            }
800            else
801            {
802                if(m_TexLayerCnt >= 0)
803                    ThrowFormatError("variant.tex_layer_cnt");
804                m_TexLayerCnt = NewTexLayerCnt;
805            }
806        }
807        else if(FieldName == "tex_idx_array")
808        {
809            int TexIdxCnt = Snk->GetRemainInt();
810            int ValCnt = -1;
811            if(m_TexLayerCnt >= 0 && m_Topol.m_FamilyCnt >= 0)
812                ValCnt = m_TexLayerCnt * m_Topol.m_FamilyCnt;
813            if(TexIdxCnt != ValCnt)
814                ThrowRestoreError("layer_cnt");
815
816            if(!Restore)
817                m_TexIdxArray.Alloc(TexIdxCnt);
818            int i;
819            for(i = 0; i < TexIdxCnt; i++)
820                m_TexIdxArray[i] = Snk->ReadInt();
821        }
822        else if(FieldName == "sampler_mode_array")
823        {
824            int SampModeCnt = Snk->GetRemainInt();
825            int ValCnt = -1;
826            if(m_TexLayerCnt >= 0 && m_Topol.m_FamilyCnt >= 0)
827                ValCnt = m_TexLayerCnt * m_Topol.m_FamilyCnt;
828            if(SampModeCnt != ValCnt)
829                ThrowRestoreError("layer_cnt");
830
831            if(!Restore)
832                m_SampModeArray.Alloc(SampModeCnt);
833            int i;
834            for(i = 0; i < SampModeCnt; i++)
835            {
836                int Val = Snk->ReadInt();
837                int SampMode = 0;
838                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPX)
839                    SampMode |= s3d_CDrvGfxEng::SampMode_ClampX;
840                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPY)
841                    SampMode |= s3d_CDrvGfxEng::SampMode_ClampY;
842                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_CLAMPZ)
843                    SampMode |= s3d_CDrvGfxEng::SampMode_ClampZ;
844                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORX)
845                    SampMode |= s3d_CDrvGfxEng::SampMode_MirrorX;
846                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORY)
847                    SampMode |= s3d_CDrvGfxEng::SampMode_MirrorY;
848                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_MIRRORZ)
849                    SampMode |= s3d_CDrvGfxEng::SampMode_MirrorZ;
850                if(Val & S3D_SHARK_MESH_LOADER_SAMPLERMODE_FILTER)
851                    SampMode |= s3d_CDrvGfxEng::SampMode_Filter;
852                m_SampModeArray[i] = SampMode;
853            }
854        }
855        else if(FieldName == "frm_cnt")
856        {
857            s3d_CSysIntps NewFrmCnt = Snk->ReadInt();
858            if(Restore)
859            {
860                if(NewFrmCnt != m_FrmCnt)
861                    ThrowRestoreError("frm_cnt");
862            }
863            else
864            {
865                if(m_FrmCnt >= 0)
866                    ThrowFormatError("variant.frm_cnt");
867                m_FrmCnt = NewFrmCnt;
868            }
869        }
870        else if(FieldName == "key_array")
871        {
872            s3d_CSysIntps FrmCnt = Snk->GetRemainFloat();
873            if(FrmCnt != m_FrmCnt)
874                ThrowRestoreError("frm_cnt");
875
876            if(!Restore)
877                m_KeyArray.Alloc(m_FrmCnt);
878            int i;
879            for(i = 0; i < m_FrmCnt; i++)
880                m_KeyArray[i] = Snk->ReadFloat();
881        }
882        else if(FieldName == "bone_wgh_array")
883        {
884            int NewVertCnt = Snk->GetRemainFloat() / 4;
885            if(NewVertCnt != m_Topol.m_VertCnt)
886                ThrowFormatError("bone_wgh_array.value_cnt");
887
888            s3d_CSharkMeshLoaderBankBoneWghPtr Bank;
889            if(Restore)
890            {
891                Bank = m_BoneWghBank;
892                if(!Bank)
893                    ThrowRestoreError("bone_wgh_array");
894            }
895            else
896            {
897                m_BoneWghBankSig = S3D_SYS_NEW s3d_CDrvSig;
898                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankBoneWgh;
899                Bank->m_Loader = this;
900                m_BoneWghBank = Bank;
901            }
902            if(!Bank->m_Data)
903            {
904                Bank->m_Cnt = NewVertCnt;
905                Bank->m_Data.Alloc(NewVertCnt);
906            }
907            s3d_CUtilVec4f *Data = Bank->m_Data;
908            int i;
909            for(i = 0; i < NewVertCnt; i++)
910            {
911                s3d_CUtilVec4f Val;
912                Val.m_x = Snk->ReadFloat();
913                Val.m_y = Snk->ReadFloat();
914                Val.m_z = Snk->ReadFloat();
915                Val.m_w = Snk->ReadFloat();
916                Data[i] = Val;
917            }
918        }
919        else if(FieldName == "bone_subscr_array")
920        {
921            int NewVertCnt = Snk->GetRemainInt() / 4;
922            if(NewVertCnt != m_Topol.m_VertCnt)
923                ThrowFormatError("bone_wgh_array.value_cnt");
924
925            s3d_CSharkMeshLoaderBankBoneSubscrPtr Bank;
926            if(Restore)
927            {
928                Bank = m_BoneSubscrBank;
929                if(!Bank)
930                    ThrowRestoreError("bone_wgh_array");
931            }
932            else
933            {
934                m_BoneSubscrBankSig = S3D_SYS_NEW s3d_CDrvSig;
935                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankBoneSubscr;
936                Bank->m_Loader = this;
937                m_BoneSubscrBank = Bank;
938            }
939            if(!Bank->m_Data)
940            {
941                Bank->m_Cnt = NewVertCnt;
942                Bank->m_Data.Alloc(NewVertCnt);
943            }
944            s3d_CDrvInt32uX4 *Data = Bank->m_Data;
945            int i;
946            for(i = 0; i < NewVertCnt; i++)
947            {
948                s3d_CDrvInt32uX4 Val;
949                Val.m_x = Snk->ReadInt();
950                Val.m_y = Snk->ReadInt();
951                Val.m_z = Snk->ReadInt();
952                Val.m_w = Snk->ReadInt();
953                Data[i] = Val;
954            }
955        }
956        else if(FieldName == "point_array")
957        {
958            int ValCnt = Snk->GetRemainFloat();
959            int VecCnt = -1;
960            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
961                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
962            if(ValCnt != 3 * VecCnt)
963                ThrowFormatError("point_array.value_cnt");
964
965            s3d_CSharkMeshLoaderBankVec3fPtr Bank;
966            if(Restore)
967            {
968                Bank = m_PointBank;
969                if(!Bank)
970                    ThrowRestoreError("point_array");
971            }
972            else
973            {
974                m_PointBankSig = S3D_SYS_NEW s3d_CDrvSig;
975                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
976                Bank->m_Loader = this;
977                m_PointBank = Bank;
978            }
979            if(!Bank->m_Data)
980            {
981                Bank->m_Cnt = VecCnt;
982                Bank->m_Data.Alloc(VecCnt);
983            }
984            s3d_CUtilVec3f *Data = Bank->m_Data;
985            int i;
986            for(i = 0; i < VecCnt; i++)
987            {
988                s3d_CUtilVec3f Val;
989                Val.m_x = Snk->ReadFloat();
990                Val.m_y = Snk->ReadFloat();
991                Val.m_z = Snk->ReadFloat();
992                Data[i] = Val;
993            }
994        }
995        else if(FieldName == "normal_array")
996        {
997            int ValCnt = Snk->GetRemainFloat();
998            int VecCnt = -1;
999            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
1000                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
1001            if(ValCnt != 3 * VecCnt)
1002                ThrowFormatError("normal_array.value_cnt");
1003
1004            s3d_CSharkMeshLoaderBankVec3fPtr Bank;
1005            if(Restore)
1006            {
1007                Bank = m_NormalBank;
1008                if(!Bank)
1009                    ThrowRestoreError("normal_array");
1010            }
1011            else
1012            {
1013                m_NormalBankSig = S3D_SYS_NEW s3d_CDrvSig;
1014                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
1015                Bank->m_Loader = this;
1016                m_NormalBank = Bank;
1017            }
1018            if(!Bank->m_Data)
1019            {
1020                Bank->m_Cnt = VecCnt;
1021                Bank->m_Data.Alloc(VecCnt);
1022            }
1023            s3d_CUtilVec3f *Data = Bank->m_Data;
1024            int i;
1025            for(i = 0; i < VecCnt; i++)
1026            {
1027                s3d_CUtilVec3f Val;
1028                Val.m_x = Snk->ReadFloat();
1029                Val.m_y = Snk->ReadFloat();
1030                Val.m_z = Snk->ReadFloat();
1031                Data[i] = Val;
1032            }
1033        }
1034        else if(FieldName == "tangentu_array")
1035        {
1036            int ValCnt = Snk->GetRemainFloat();
1037            int VecCnt = -1;
1038            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
1039                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
1040            if(ValCnt != 3 * VecCnt)
1041                ThrowFormatError("tangentu_array.value_cnt");
1042
1043            s3d_CSharkMeshLoaderBankVec3fPtr Bank;
1044            if(Restore)
1045            {
1046                Bank = m_TangentUBank;
1047                if(!Bank)
1048                    ThrowRestoreError("tangentu_array");
1049            }
1050            else
1051            {
1052                m_TangentUBankSig = S3D_SYS_NEW s3d_CDrvSig;
1053                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
1054                Bank->m_Loader = this;
1055                m_TangentUBank = Bank;
1056            }
1057            if(!Bank->m_Data)
1058            {
1059                Bank->m_Cnt = VecCnt;
1060                Bank->m_Data.Alloc(VecCnt);
1061            }
1062            s3d_CUtilVec3f *Data = Bank->m_Data;
1063            int i;
1064            for(i = 0; i < VecCnt; i++)
1065            {
1066                s3d_CUtilVec3f Val;
1067                Val.m_x = Snk->ReadFloat();
1068                Val.m_y = Snk->ReadFloat();
1069                Val.m_z = Snk->ReadFloat();
1070                Data[i] = Val;
1071            }
1072        }
1073        else if(FieldName == "tangentv_array")
1074        {
1075            int ValCnt = Snk->GetRemainFloat();
1076            int VecCnt = -1;
1077            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
1078                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
1079            if(ValCnt != 3 * VecCnt)
1080                ThrowFormatError("tangentv_array.value_cnt");
1081
1082            s3d_CSharkMeshLoaderBankVec3fPtr Bank;
1083            if(Restore)
1084            {
1085                Bank = m_TangentVBank;
1086                if(!Bank)
1087                    ThrowRestoreError("tangentv_array");
1088            }
1089            else
1090            {
1091                m_TangentVBankSig = S3D_SYS_NEW s3d_CDrvSig;
1092                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
1093                Bank->m_Loader = this;
1094                m_TangentVBank = Bank;
1095            }
1096            if(!Bank->m_Data)
1097            {
1098                Bank->m_Cnt = VecCnt;
1099                Bank->m_Data.Alloc(VecCnt);
1100            }
1101            s3d_CUtilVec3f *Data = Bank->m_Data;
1102            int i;
1103            for(i = 0; i < VecCnt; i++)
1104            {
1105                s3d_CUtilVec3f Val;
1106                Val.m_x = Snk->ReadFloat();
1107                Val.m_y = Snk->ReadFloat();
1108                Val.m_z = Snk->ReadFloat();
1109                Data[i] = Val;
1110            }
1111        }
1112        else if(FieldName == "coloralpha_array")
1113        {
1114            int ValCnt = Snk->GetRemainFloat();
1115            int VecCnt = -1;
1116            if(m_Topol.m_VertCnt >= 0 && m_FrmCnt >= 0)
1117                VecCnt = m_Topol.m_VertCnt * m_FrmCnt;
1118            if(ValCnt != 4 * VecCnt)
1119                ThrowFormatError("coloralpha_array.value_cnt");
1120
1121            s3d_CSharkMeshLoaderBankVec4fPtr Bank;
1122            if(Restore)
1123            {
1124                Bank = m_ColorAlphaBank;
1125                if(!Bank)
1126                    ThrowRestoreError("coloralpha_array");
1127            }
1128            else
1129            {
1130                m_ColorAlphaBankSig = S3D_SYS_NEW s3d_CDrvSig;
1131                Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec4f;
1132                Bank->m_Loader = this;
1133                m_ColorAlphaBank = Bank;
1134            }
1135            if(!Bank->m_Data)
1136            {
1137                Bank->m_Cnt = VecCnt;
1138                Bank->m_Data.Alloc(VecCnt);
1139            }
1140            s3d_CUtilVec4f *Data = Bank->m_Data;
1141            int i;
1142            for(i = 0; i < VecCnt; i++)
1143            {
1144                s3d_CUtilVec4f Val;
1145                Val.m_x = Snk->ReadFloat();
1146                Val.m_y = Snk->ReadFloat();
1147                Val.m_z = Snk->ReadFloat();
1148                Val.m_w = Snk->ReadFloat();
1149                Data[i] = Val;
1150            }
1151        }
1152        else if(FieldName == "tex_attr_cnt")
1153        {
1154            s3d_CSysIntps NewTexAttrCnt = Snk->ReadInt();
1155            if(Restore)
1156            {
1157                if(NewTexAttrCnt != m_TexAttrCnt)
1158                    ThrowRestoreError("tex_attr_cnt");
1159            }
1160            else
1161            {
1162                if(m_TexAttrCnt >= 0)
1163                    ThrowFormatError("variant.tex_attr_cnt");
1164                m_TexAttrCnt = NewTexAttrCnt;
1165            }
1166        }
1167        else if(FieldName == "tex_coord_array")
1168        {
1169            int VecCnt = Snk->GetRemainFloat() / 2;
1170            int TexAttrCnt = m_TexAttrCnt;
1171            int FrmCnt = m_FrmCnt;
1172            int VertCnt = m_Topol.m_VertCnt;
1173            int AttrVecCnt = FrmCnt * VertCnt;
1174            if(VecCnt != TexAttrCnt * AttrVecCnt)
1175                ThrowFormatError("tex_layer_array.texcoord_cnt");
1176
1177            if(!Restore)
1178                m_TexAttrArray.Alloc(TexAttrCnt);
1179
1180            int i;
1181            for(i = 0; i < m_TexAttrCnt; i++)
1182            {
1183                s3d_CSharkMeshLoaderAttr *TexAttr
1184                    = &m_TexAttrArray[i];
1185                s3d_CSharkMeshLoaderBankVec2fPtr Bank;
1186                if(Restore)
1187                {
1188                    Bank = TexAttr->m_Bank;
1189                    if(!Bank)
1190                        ThrowRestoreError("texattr_array");
1191                }
1192                else
1193                {
1194                    Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec2f;
1195                    Bank->m_Loader = this;
1196                    TexAttr->m_Bank = Bank;
1197                }
1198                if(!Bank->m_Data)
1199                {
1200                    Bank->m_Cnt = AttrVecCnt;
1201                    Bank->m_Data.Alloc(AttrVecCnt);
1202                }
1203                s3d_CUtilVec2f *Data = Bank->m_Data;
1204                int j;
1205                for(j = 0; j < AttrVecCnt; j++)
1206                {
1207                    s3d_CUtilVec2f Val;
1208                    Val.m_x = Snk->ReadFloat();
1209                    Val.m_y = Snk->ReadFloat();
1210                    Data[j] = Val;
1211                }
1212            }
1213        }
1214        else if(FieldName == "mtl_array")
1215        {
1216            int MtlCnt = Snk->GetRemainStr();
1217            if(MtlCnt != m_Topol.m_FamilyCnt)
1218                ThrowFormatError("tex_layer_array.mtl_cnt");
1219            if(!Restore)
1220            {
1221                m_MtlPtrArray.Alloc(MtlCnt);
1222                m_MtlArray.Alloc(MtlCnt);
1223            }
1224            s3d_CSysIntps j;
1225            for(j = 0; j < MtlCnt; j++)
1226            {
1227                s3d_CUtilStr MtlStr = Snk->ReadStr();
1228                s3d_CUtilAtomPtr Mtl = m_AtomMgr->GetAtom(MtlStr);
1229                m_MtlPtrArray[j] = Mtl;
1230                m_MtlArray[j] = Mtl;
1231            }
1232        }
1233        else if(FieldName == "frict_array")
1234        {
1235            int FrictCnt = Snk->GetRemainFloat();
1236            if(FrictCnt != m_Topol.m_FamilyCnt)
1237                ThrowFormatError("tex_layer_array.frict_cnt");
1238            if(!Restore)
1239                m_FrictArray.Alloc(FrictCnt);
1240            s3d_CSysIntps j;
1241            for(j = 0; j < FrictCnt; j++)
1242                m_FrictArray[j] = Snk->ReadFloat();
1243        }
1244        else if(FieldName == "softness_array")
1245        {
1246            int SoftnessCnt = Snk->GetRemainFloat();
1247            if(SoftnessCnt != m_Topol.m_FamilyCnt)
1248                ThrowFormatError("tex_layer_array.softness_cnt");
1249            if(!Restore)
1250                m_SoftnessArray.Alloc(SoftnessCnt);
1251            s3d_CSysIntps j;
1252            for(j = 0; j < SoftnessCnt; j++)
1253                m_SoftnessArray[j] = Snk->ReadFloat();
1254        }
1255        else if(FieldName == "bounce_array")
1256        {
1257            int BounceCnt = Snk->GetRemainFloat();
1258            if(BounceCnt != m_Topol.m_FamilyCnt)
1259                ThrowFormatError("tex_layer_array.bounce_cnt");
1260            if(!Restore)
1261                m_BounceArray.Alloc(BounceCnt);
1262            s3d_CSysIntps j;
1263            for(j = 0; j < BounceCnt; j++)
1264                m_BounceArray[j] = Snk->ReadFloat();
1265        }
1266        else if(FieldName == "prim_sphere_center_radius_array")
1267        {
1268            s3d_CSysIntps GeoSphereCnt = Snk->GetRemainFloat() / 4;
1269            if(Restore)
1270            {
1271                if(GeoSphereCnt != m_PrimSphereCnt)
1272                    ThrowRestoreError("sphere_cnt");
1273            }
1274            else
1275            {
1276                m_PrimSphereCnt = GeoSphereCnt;
1277                m_PrimSphereArray.Alloc(GeoSphereCnt);
1278            }
1279            s3d_CEngGeoSphere *Target = m_PrimSphereArray;
1280            s3d_CSysIntps j;
1281            for(j = 0; j < GeoSphereCnt; j++)
1282            {
1283                Target->m_FamilyIdx = 0;
1284                Target->m_Cen.m_x = Snk->ReadFloat();
1285                Target->m_Cen.m_y = Snk->ReadFloat();
1286                Target->m_Cen.m_z = Snk->ReadFloat();
1287                Target->m_Radius = Snk->ReadFloat();
1288                Target++;
1289            }
1290        }
1291        else if(FieldName == "prim_sphere_family_idx_array")
1292        {
1293            s3d_CSysIntps GeoSphereCnt = Snk->GetRemainInt();
1294            if(GeoSphereCnt != m_PrimSphereCnt)
1295                ThrowFormatError("prim_sphere.ct");
1296            s3d_CEngGeoSphere *Target = m_PrimSphereArray;
1297            s3d_CSysIntps j;
1298            for(j = 0; j < GeoSphereCnt; j++)
1299            {
1300                Target->m_FamilyIdx = Snk->ReadInt();
1301                Target++;
1302            }
1303        }
1304        else if(FieldName == "prim_capsule_start_end_radius_array")
1305        {
1306            s3d_CSysIntps GeoCapsuleCnt = Snk->GetRemainFloat() / 7;
1307            if(Restore)
1308            {
1309                if(GeoCapsuleCnt != m_PrimCapsuleCnt)
1310                    ThrowRestoreError("capsule_cnt");
1311            }
1312            else
1313            {
1314                m_PrimCapsuleCnt = GeoCapsuleCnt;
1315                m_PrimCapsuleArray.Alloc(GeoCapsuleCnt);
1316            }
1317            s3d_CEngGeoCapsule *Target = m_PrimCapsuleArray;
1318            s3d_CSysIntps j;
1319            for(j = 0; j < GeoCapsuleCnt; j++)
1320            {
1321                Target->m_FamilyIdx = 0;
1322                Target->m_Start.m_x = Snk->ReadFloat();
1323                Target->m_Start.m_y = Snk->ReadFloat();
1324                Target->m_Start.m_z = Snk->ReadFloat();
1325                Target->m_End.m_x = Snk->ReadFloat();
1326                Target->m_End.m_y = Snk->ReadFloat();
1327                Target->m_End.m_z = Snk->ReadFloat();
1328                Target->m_Radius = Snk->ReadFloat();
1329                Target++;
1330            }
1331        }
1332        else if(FieldName == "prim_capsule_family_idx_array")
1333        {
1334            s3d_CSysIntps GeoCapsuleCnt = Snk->GetRemainInt();
1335            if(GeoCapsuleCnt != m_PrimCapsuleCnt)
1336                ThrowFormatError("prim_capsule.ct");
1337            s3d_CEngGeoCapsule *Target = m_PrimCapsuleArray;
1338            s3d_CSysIntps j;
1339            for(j = 0; j < GeoCapsuleCnt; j++)
1340            {
1341                Target->m_FamilyIdx = Snk->ReadInt();
1342                Target++;
1343            }
1344        }
1345        else if(FieldName == "could_more_prim")
1346            m_CouldMorePrim = (Snk->ReadInt() != 0);
1347        Snk->EndField();
1348    }
1349
1350    if(!Restore)
1351    {
1352        if(m_Topol.m_VertCnt < 0)
1353            m_Topol.m_VertCnt = 0;
1354        if(m_Topol.m_VertEssCnt < 0)
1355            m_Topol.m_VertEssCnt = 0;
1356        if(m_Topol.m_IdxCnt < 0)
1357            m_Topol.m_IdxCnt = 0;
1358        if(m_Topol.m_IdxEssCnt < 0)
1359            m_Topol.m_IdxEssCnt = 0;
1360        if(m_Topol.m_BoneIdxCnt < 0)
1361            m_Topol.m_BoneIdxCnt = 0;
1362        if(m_Topol.m_BoneIdxEssCnt < 0)
1363            m_Topol.m_BoneIdxEssCnt = 0;
1364        if(m_Topol.m_PacketCnt < 0)
1365            m_Topol.m_PacketCnt = 0;
1366        if(m_Topol.m_FamilyCnt < 0)
1367            m_Topol.m_FamilyCnt = 0;
1368        if(m_FrmCnt < 0)
1369            m_FrmCnt = 0;
1370        if(m_TexLayerCnt < 0)
1371            m_TexLayerCnt = 0;
1372        if(m_TexAttrCnt < 0)
1373            m_TexAttrCnt = 0;
1374
1375        m_BoneWghBankSig = S3D_SYS_NEW s3d_CDrvSig;
1376        m_BoneSubscrBankSig = S3D_SYS_NEW s3d_CDrvSig;
1377        if(m_FrmCnt == 1)
1378        {
1379            m_PointBankSig = S3D_SYS_NEW s3d_CDrvSig;
1380            m_NormalBankSig = S3D_SYS_NEW s3d_CDrvSig;
1381            m_ColorAlphaBankSig = S3D_SYS_NEW s3d_CDrvSig;
1382            m_TangentUBankSig = S3D_SYS_NEW s3d_CDrvSig;
1383            m_TangentVBankSig = S3D_SYS_NEW s3d_CDrvSig;
1384            int iTexAttr;
1385            for(iTexAttr = 0; iTexAttr < m_TexAttrCnt; iTexAttr++)
1386            {
1387                m_TexAttrArray[iTexAttr].m_BankSig
1388                    = S3D_SYS_NEW s3d_CDrvSig;
1389            }
1390        }
1391    }
1392}
1393
1394void s3d_CSharkMeshLoaderVariant::ThrowFormatError(s3d_CUtilStr_cr Kind)
1395{
1396    s3d_CUtilMsg e;
1397    e.m_Code = "eng/model/std/SHARK_MESH_LOADER.format";
1398    e.m_StdTempl = "Model variant \"[1]\" has an illegal format "
1399                    "concerning \"[2]\".";
1400    e.AddInfo(m_Info);
1401    e.AddInfo(m_ResName);
1402    e.AddInfo(Kind);
1403    s3d_UtilMsgReportFatal(m_MsgHandler, e);
1404}
1405
1406void s3d_CSharkMeshLoaderVariant::ThrowRestoreError(s3d_CUtilStr_cr Kind)
1407{
1408    s3d_CUtilMsg e;
1409    e.m_Code = "eng/model/std/SHARK_MESH_LOADER.format";
1410    e.m_StdTempl = "Model variant \"[1]\" is restored, "
1411                    "but the new data is different concerning \"[2]\".";
1412    e.AddInfo(m_Info);
1413    e.AddInfo(m_ResName);
1414    e.AddInfo(Kind);
1415    s3d_UtilMsgReportFatal(m_MsgHandler, e);
1416}
1417
1418void s3d_CSharkMeshLoaderVariant::LoaderPerform()
1419{
1420    Load(true);
1421}
1422
1423void s3d_CSharkMeshLoaderVariant::ResChanged()
1424{
1425    if(m_Changed)
1426        m_Changed->ChangedPerform();
1427}
1428
1429s3d_CEngMeshData *s3d_CSharkMeshLoaderVariant::EvalMeshDataBase(
1430        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage)
1431{
1432    bool Dyn = (m_FrmCnt > 1);
1433
1434    int TexAttrCnt = m_TexAttrCnt;
1435
1436    s3d_CEngMeshAttr *MeshTexAttrArray
1437                = new(MemPool) s3d_CEngMeshAttr[TexAttrCnt];
1438    int iTexAttr;
1439    for(iTexAttr = 0; iTexAttr < TexAttrCnt; iTexAttr++)
1440    {
1441        s3d_CSharkMeshLoaderAttr *TexAttr
1442                = &m_TexAttrArray[iTexAttr];
1443        s3d_CEngMeshAttr *MeshTexAttr = &MeshTexAttrArray[iTexAttr];
1444        MeshTexAttr->m_BankDyn = Dyn;
1445        MeshTexAttr->m_BankSig = TexAttr->m_BankSig;
1446        MeshTexAttr->m_Bank = TexAttr->m_Bank;
1447    }
1448
1449    s3d_CEngMeshData *MeshData = new(MemPool) s3d_CEngMeshData;
1450    MeshData->m_Info = m_Info.GetChars();
1451    MeshData->m_Desc = m_ResName.GetChars();
1452    MeshData->m_Usage = Usage;
1453    MeshData->m_MeshOwner = this;
1454    MeshData->m_Topol.m_TopolSig = m_Topol.m_TopolSig;
1455    MeshData->m_Topol.m_VertCnt = m_Topol.m_VertCnt;
1456    MeshData->m_Topol.m_VertEssCnt = m_Topol.m_VertEssCnt;
1457    MeshData->m_Topol.m_IdxCnt = m_Topol.m_IdxCnt;
1458    MeshData->m_Topol.m_IdxEssCnt = m_Topol.m_IdxEssCnt;
1459    MeshData->m_Topol.m_BoneIdxCnt = m_Topol.m_BoneIdxCnt;
1460    MeshData->m_Topol.m_BoneIdxEssCnt = m_Topol.m_BoneIdxEssCnt;
1461    MeshData->m_Topol.m_FamilyCnt = m_Topol.m_FamilyCnt;
1462    MeshData->m_Topol.m_PacketCnt = m_Topol.m_PacketCnt;
1463    MeshData->m_Topol.m_UseSubscr = (m_BoneSubscrBank != 0);
1464    MeshData->m_Topol.m_Closed = m_Topol.m_Closed;
1465    MeshData->m_Topol.m_Sealed = m_Topol.m_Sealed;
1466    MeshData->m_Topol.m_FamilyArray = m_Topol.m_FamilyArray;
1467    MeshData->m_Topol.m_PacketBank = m_Topol.m_PacketBank;
1468    MeshData->m_Topol.m_BoneIdxBank = m_Topol.m_BoneIdxBank;
1469    MeshData->m_Topol.m_IdxBank = m_Topol.m_IdxBank;
1470    MeshData->m_Topol.m_OppBank = m_Topol.m_OppBank;
1471    MeshData->m_Topol.m_NeighBank = m_Topol.m_NeighBank;
1472    MeshData->m_BoneWghAttr.m_BankDyn = Dyn;
1473    MeshData->m_BoneWghAttr.m_BankSig = m_BoneWghBankSig;
1474    MeshData->m_BoneWghAttr.m_Bank = m_BoneWghBank;
1475    MeshData->m_BoneSubscrAttr.m_BankDyn = Dyn;
1476    MeshData->m_BoneSubscrAttr.m_BankSig = m_BoneSubscrBankSig;
1477    MeshData->m_BoneSubscrAttr.m_Bank = m_BoneSubscrBank;
1478    MeshData->m_PointAttr.m_BankDyn = Dyn;
1479    MeshData->m_PointAttr.m_BankSig = m_PointBankSig;
1480    MeshData->m_PointAttr.m_Bank = m_PointBank;
1481    MeshData->m_NormalAttr.m_BankDyn = Dyn;
1482    MeshData->m_NormalAttr.m_BankSig = m_NormalBankSig;
1483    MeshData->m_NormalAttr.m_Bank = m_NormalBank;
1484    MeshData->m_TangentUAttr.m_BankDyn = Dyn;
1485    MeshData->m_TangentUAttr.m_BankSig = m_TangentUBankSig;
1486    MeshData->m_TangentUAttr.m_Bank = m_TangentUBank;
1487    MeshData->m_TangentVAttr.m_BankDyn = Dyn;
1488    MeshData->m_TangentVAttr.m_BankSig = m_TangentVBankSig;
1489    MeshData->m_TangentVAttr.m_Bank = m_TangentVBank;
1490    MeshData->m_ColorAlphaAttr.m_BankDyn = Dyn;
1491    MeshData->m_ColorAlphaAttr.m_BankSig = m_ColorAlphaBankSig;
1492    MeshData->m_ColorAlphaAttr.m_Bank = m_ColorAlphaBank;
1493    MeshData->m_TexAttrCnt = TexAttrCnt;
1494    MeshData->m_TexAttrArray = MeshTexAttrArray;
1495    return MeshData;
1496}
1497
1498s3d_CEngMeshData *s3d_CSharkMeshLoaderVariant::EvalMeshDataFull(
1499        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
1500        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
1501        s3d_CEngModelCtx *ModelCtx)
1502{
1503    s3d_CEngMeshData *MeshData = EvalMeshDataBase(MemPool, Usage);
1504
1505    int FrmCnt = m_FrmCnt;
1506    if(ModelCtx && FrmCnt > 1)
1507    {
1508        s3d_CEngActu *Actu = ModelCtx->GetAnimActu(0);
1509        float Phase = 0;
1510        if(Actu)
1511            Phase = Actu->GetVal();
1512
1513        s3d_CSysIntps iKit = SearchKitIdx(m_FrmCnt, m_KeyArray, Phase);
1514        float KitFrac = 0;
1515        if(iKit > 0)
1516        {
1517            float KeyA = m_KeyArray[iKit - 1];
1518            float KeyB = m_KeyArray[iKit];
1519            if(KeyA != KeyB)
1520                KitFrac = (Phase - KeyA) / (KeyB - KeyA);
1521        }
1522
1523        s3d_CSharkMeshLoaderInterp::EvalFrm(
1524                MsgHandler, Info, MemPool,
1525                FrmCnt, iKit, KitFrac, MeshData);
1526    }
1527
1528    return MeshData;
1529}
1530
1531s3d_CSysIntps s3d_CSharkMeshLoaderVariant::SearchKitIdx(
1532        s3d_CSysIntps KeyCnt, float *KeyArray, float Phase)
1533{
1534    s3d_CSysIntps From = 0;
1535    s3d_CSysIntps To = KeyCnt;
1536    while(To > From)
1537    {
1538        s3d_CSysIntps Mid = (From + To) >> 1;
1539        if(KeyArray[Mid] >= Phase)
1540            To = Mid;
1541        else
1542            From = Mid + 1;
1543    }
1544    return From;
1545}
1546*/
1547///////////////////////////////////////////////////////////////////////////////
1548
1549S3D_UTIL_RTTI_TABLE_DEFINE_BEGIN(s3d_CSharkMeshLoader)
1550S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CEngModel)
1551S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompUtilSerImmut)
1552S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompUtilUniqueBase)
1553S3D_UTIL_RTTI_TABLE_DEFINE_END
1554
1555s3d_CSharkMeshLoader::s3d_CSharkMeshLoader(
1556        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
1557        bool Bare,
1558        s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr,
1559        s3d_CUtilStr_cr ResName)
1560{
1561    m_MsgHandler = MsgHandler;
1562    m_Info = Info;
1563    m_Bare = Bare;
1564    m_AtomMgr = AtomMgr;
1565    m_ResMgr = ResMgr;
1566    m_ResName = ResName;
1567
1568    m_NotifRecip.Assign(this, &s3d_CSharkMeshLoader::ResChanged);
1569
1570    m_Loaded = false;
1571
1572    // Data:
1573    m_RangeStart = 0;
1574    m_RangeEnd = 0;
1575    m_BoundCen = 0;
1576    m_BoundExt = 0;
1577    m_BoneCnt = 0;
1578    m_BoneNameArray.Reset();
1579    m_BoneTransfArray.Reset();
1580    m_TexNameCnt = 0;
1581    m_TexNameArray.Reset();
1582/*    m_VariantDescCnt = 0;
1583    m_VariantDescArray.Reset();
1584    m_VariantCnt = 0;
1585    m_VariantArray.Reset();
1586    m_VariantIdxGeo = -1;*/
1587
1588        m_MeshSig = S3D_SYS_NEW s3d_CDrvSig;
1589        m_TopolSig = S3D_SYS_NEW s3d_CDrvSig;
1590
1591//      use_triangle_strips = false;
1592}
1593
1594s3d_CSharkMeshLoader::~s3d_CSharkMeshLoader()
1595{
1596}
1597
1598s3d_CUtilStr s3d_CSharkMeshLoader::GetInfo()
1599{
1600    return m_Info;
1601}
1602
1603s3d_CUtilStr s3d_CSharkMeshLoader::GetDesc()
1604{
1605    return m_ResName;
1606}
1607
1608void s3d_CSharkMeshLoader::RegisterNotif(s3d_CUtilNotifRecip *Recip)
1609{
1610    m_NotifMgr.Register(Recip);
1611}
1612
1613int s3d_CSharkMeshLoader::GetAnimActuCnt()
1614{
1615    if(m_RangeStart < m_RangeEnd)
1616        return 1;
1617    else
1618        return 0;
1619}
1620
1621s3d_CUtilStr s3d_CSharkMeshLoader::GetAnimActuName(int Idx)
1622{
1623    return 0;
1624}
1625
1626void s3d_CSharkMeshLoader::GetAnimActuRange(int Idx, float &Start, float &End)
1627{
1628    CheckLoad();
1629
1630    Start = m_RangeStart;
1631    End = m_RangeEnd;
1632}
1633
1634int s3d_CSharkMeshLoader::GetAnimPosCnt()
1635{
1636    CheckLoad();
1637
1638    return m_BoneCnt;
1639}
1640
1641s3d_CUtilStr s3d_CSharkMeshLoader::GetAnimPosName(int Idx)
1642{
1643    CheckLoad();
1644
1645    if(s3d_SysIsValidArrayIdx(Idx, m_BoneCnt))
1646        return m_BoneNameArray[Idx];
1647    return 0;
1648}
1649
1650int s3d_CSharkMeshLoader::GetTexCnt()
1651{
1652    CheckLoad();
1653
1654    return m_TexNameCnt;
1655}
1656
1657s3d_CUtilStr s3d_CSharkMeshLoader::GetTexName(int Idx)
1658{
1659    CheckLoad();
1660
1661    if(s3d_SysIsValidArrayIdx(Idx, m_TexNameCnt))
1662        return m_TexNameArray[Idx];
1663    return "";
1664}
1665
1666void s3d_CSharkMeshLoader::GetBound(
1667                s3d_CUtilVec3f &Cen, s3d_CUtilVec3f &Ext)
1668{
1669    CheckLoad();
1670
1671    Cen = m_BoundCen;
1672    Ext = m_BoundExt;
1673}
1674
1675void s3d_CSharkMeshLoader::GetMeshCompos(
1676        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
1677        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
1678        s3d_CUtilMat4x4f_cr Map, s3d_CUtilVec3f_cr Ext,
1679        s3d_CUtilVec3f_cr Prec, s3d_CEngModelCtx *ModelCtx,
1680        bool NeedMeshData,
1681        s3d_CEngMeshCompos &MeshCompos)
1682{
1683    CheckLoad();
1684
1685        GetMeshComposBase(MemPool,Usage,MeshCompos);
1686
1687        // GAMETOOLS: no tenemos variantes: son el mismo fichero!
1688/*    float MeshPrec = 0;
1689    if(m_VariantCnt > 1)
1690        MeshPrec = CalcMeshPrec(Map, Prec);
1691
1692    s3d_CSysIntps VariantIdx = SearchVariantIdxPrec(Usage, MeshPrec);
1693    if(VariantIdx < 0)
1694        return;
1695
1696    MeshCompos.m_BoundCen = m_BoundCen;
1697    MeshCompos.m_BoundExt = m_BoundExt;
1698    MeshCompos.m_BoneRefTransfCnt = m_BoneCnt;
1699    MeshCompos.m_BoneRefTransfArray = m_BoneTransfArray;
1700
1701    s3d_CSharkMeshLoaderVariant *Variant = m_VariantArray[VariantIdx];
1702    Variant->GetMeshComposFull(MsgHandler, Info, MemPool,
1703                Usage, ModelCtx, NeedMeshData, MeshCompos);
1704
1705    s3d_CEngMeshData *MeshData = MeshCompos.m_MeshData;
1706    if(MeshData)
1707    {
1708        MeshData->m_BoundCen = m_BoundCen;
1709        MeshData->m_BoundExt = m_BoundExt;
1710        MeshData->m_Topol.m_BoneCnt = m_BoneCnt;
1711    }*/
1712}
1713
1714void s3d_CSharkMeshLoader::GetMeshComposBase(
1715        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
1716        s3d_CEngMeshCompos &MeshCompos)
1717{
1718        // construir un mesh compos fake por ahora!
1719        MeshCompos.m_BoundCen = m_BoundCen;
1720    MeshCompos.m_BoundExt = m_BoundExt;
1721        MeshCompos.m_BoneRefTransfCnt = 0;
1722
1723    MeshCompos.m_MeshSig = m_MeshSig;
1724    MeshCompos.m_TexFamilyCnt = 1; //m_Topol.m_FamilyCnt;
1725    MeshCompos.m_TexLayerCnt = 1; //m_TexLayerCnt;
1726    MeshCompos.m_TexIdxArray = 0; //m_TexIdxArray;
1727//    MeshCompos.m_SampModeArray = m_SampModeArray;
1728
1729//    bool Dyn = (m_FrmCnt > 1);
1730        bool Dyn = false; // creo que deberia ser true para poder cambiar de lod mas eficientemente
1731    s3d_CEngMeshData *MeshData = new(MemPool) s3d_CEngMeshData;
1732        MeshData->m_BoundCen = m_BoundCen;
1733    MeshData->m_BoundExt = m_BoundExt;
1734    MeshData->m_Info = m_Info.GetChars();
1735    MeshData->m_Desc = m_ResName.GetChars();
1736    MeshData->m_Usage = Usage;
1737        MeshData->m_MeshOwner = this;
1738    MeshData->m_Topol.m_TopolSig = m_TopolSig;
1739    MeshData->m_Topol.m_VertCnt = m_GeoMesh->mVertexBuffer->mVertexCount; //m_Topol.m_VertCnt;
1740    MeshData->m_Topol.m_VertEssCnt = MeshData->m_Topol.m_VertCnt; //m_Topol.m_VertEssCnt;
1741    MeshData->m_Topol.m_IdxCnt = m_IdxBank->m_Cnt; //m_Topol.m_IdxCnt;
1742    MeshData->m_Topol.m_IdxEssCnt = MeshData->m_Topol.m_IdxCnt; //m_Topol.m_IdxEssCnt;
1743    MeshData->m_Topol.m_BoneIdxCnt = 0; //m_Topol.m_BoneIdxCnt;
1744    MeshData->m_Topol.m_BoneIdxEssCnt = 0; //m_Topol.m_BoneIdxEssCnt;
1745    MeshData->m_Topol.m_UseSubscr = false; //(m_BoneSubscrBank != 0); // necesario (creo) para huesos!
1746    MeshData->m_Topol.m_Closed = false; //m_Topol.m_Closed;
1747    MeshData->m_Topol.m_Sealed = false; //m_Topol.m_Sealed;
1748        MeshData->m_Topol.m_FamilyArray = new(MemPool) s3d_CEngMeshFamily[m_GeoMesh->mSubMeshCount]; //m_Topol.m_FamilyArray;
1749        MeshData->m_Topol.m_FamilyCnt = m_GeoMesh->mSubMeshCount;
1750        for (int i=0; i<m_GeoMesh->mSubMeshCount; i++)
1751        {
1752                MeshData->m_Topol.m_FamilyArray[i].m_BoneIdxCnt = 0;
1753                MeshData->m_Topol.m_FamilyArray[i].m_BoneIdxEssCnt = 0;
1754                MeshData->m_Topol.m_FamilyArray[i].m_IdxCnt = m_GeoMesh->mSubMesh[i].mIndexCount;
1755                MeshData->m_Topol.m_FamilyArray[i].m_IdxEssCnt = m_GeoMesh->mSubMesh[i].mIndexCount;
1756                MeshData->m_Topol.m_FamilyArray[i].m_PacketCnt = 1;
1757                MeshData->m_Topol.m_FamilyArray[i].m_VertCnt = m_GeoMesh->mSubMesh[i].mVertexBuffer->mVertexCount;
1758                MeshData->m_Topol.m_FamilyArray[i].m_VertEssCnt = MeshData->m_Topol.m_FamilyArray[i].m_VertCnt;
1759        }
1760
1761 /*   MeshData->m_Topol.m_VertCnt = 3;
1762    MeshData->m_Topol.m_VertEssCnt = 3;
1763    MeshData->m_Topol.m_IdxCnt = 3;
1764    MeshData->m_Topol.m_IdxEssCnt = 3;
1765    MeshData->m_Topol.m_BoneIdxCnt = 0; //m_Topol.m_BoneIdxCnt;
1766    MeshData->m_Topol.m_BoneIdxEssCnt = 0; //m_Topol.m_BoneIdxEssCnt;
1767    MeshData->m_Topol.m_UseSubscr = false; //(m_BoneSubscrBank != 0); // necesario (creo) para huesos!
1768    MeshData->m_Topol.m_Closed = false; //m_Topol.m_Closed;
1769    MeshData->m_Topol.m_Sealed = false; //m_Topol.m_Sealed;
1770        MeshData->m_Topol.m_FamilyArray = new(MemPool) s3d_CEngMeshFamily[1]; //m_Topol.m_FamilyArray;
1771        MeshData->m_Topol.m_FamilyCnt = 1;
1772        MeshData->m_Topol.m_FamilyArray[0].m_BoneIdxCnt = 0;
1773        MeshData->m_Topol.m_FamilyArray[0].m_BoneIdxEssCnt = 0;
1774        MeshData->m_Topol.m_FamilyArray[0].m_IdxCnt = 3;
1775        MeshData->m_Topol.m_FamilyArray[0].m_IdxEssCnt = 3;
1776        MeshData->m_Topol.m_FamilyArray[0].m_PacketCnt = 1;
1777        MeshData->m_Topol.m_FamilyArray[0].m_VertCnt = 3;
1778        MeshData->m_Topol.m_FamilyArray[0].m_VertEssCnt = 3;*/
1779
1780
1781//      MeshData->m_Topol.m_FamilyArray = m_FamilyArray;
1782        {
1783/*              s3d_CSharkMeshLoaderBankPacket *Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankPacket;             
1784                Bank->m_Loader = this;
1785                Bank->m_Cnt = 1;
1786                Bank->m_Data.Alloc(Bank->m_Cnt);
1787        s3d_CDrvMeshPacket *Data = Bank->m_Data;
1788        for(int iPacket = 0; iPacket < Bank->m_Cnt; iPacket++)
1789        {
1790            s3d_CDrvMeshPacket *Packet = &Data[iPacket];
1791            Packet->m_VertCnt = 3;
1792            Packet->m_VertEssCnt = 3;
1793            Packet->m_IdxCnt = 3;
1794            Packet->m_IdxEssCnt = 3;
1795            Packet->m_BoneIdxCnt = 0;
1796            Packet->m_BoneIdxEssCnt = 0;
1797        }
1798                MeshData->m_Topol.m_PacketBank = Bank;
1799                MeshData->m_Topol.m_PacketCnt = 1;*/
1800                MeshData->m_Topol.m_PacketBank = m_PacketsBank;
1801            MeshData->m_Topol.m_PacketCnt = m_GeoMesh->mSubMeshCount; //m_Topol.m_PacketCnt;
1802        }
1803        {
1804/*              s3d_CSharkMeshLoaderBankMeshIdx *Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
1805                Bank->m_Loader = this;
1806                Bank->m_Cnt = 0;
1807        Bank->m_Data.Alloc(0);
1808        s3d_CSharkMeshLoaderIdx *Data = Bank->m_Data;
1809//        for(int i = 0; i < BoneIdxCnt; i++)
1810//        {
1811//            int RawBoneIdx = Snk->ReadInt();
1812//            s3d_CSharkMeshLoaderIdx BoneIdx = s3d_CSharkMeshLoaderIdx(RawBoneIdx);
1813//            Data[i] = BoneIdx;
1814//        }*/
1815                MeshData->m_Topol.m_BoneIdxBank = 0; //Bank;
1816        }
1817        {
1818/*              s3d_CSharkMeshLoaderBankMeshIdx *Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
1819                Bank->m_Loader = this;
1820        Bank->m_Cnt = 3;
1821        Bank->m_Data.Alloc(Bank->m_Cnt);
1822                Bank->m_Data[0] = 0;
1823                Bank->m_Data[1] = 1;
1824                Bank->m_Data[2] = 2;
1825                MeshData->m_Topol.m_IdxBank = Bank;*/
1826                MeshData->m_Topol.m_IdxBank = m_IdxBank;
1827        }
1828        {
1829                MeshData->m_Topol.m_OppBank = 0;
1830/*              MeshData->m_Topol.m_OppBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
1831                MeshData->m_Topol.m_OppBank->m_Cnt = 3;
1832                MeshData->m_Topol.m_OppBank->m_Data.Alloc(MeshData->m_Topol.m_OppBank->m_Cnt); 
1833                s3d_CSharkMeshLoaderIdx *Data = MeshData->m_Topol.m_OppBank->m_Data;
1834                Data[0] = -1;
1835                Data[1] = -1;
1836                Data[2] = -1;*/
1837        }
1838        {
1839                MeshData->m_Topol.m_NeighBank = 0;
1840/*              MeshData->m_Topol.m_NeighBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
1841                MeshData->m_Topol.m_NeighBank->m_Cnt = 3;
1842                MeshData->m_Topol.m_NeighBank->m_Data.Alloc(MeshData->m_Topol.m_NeighBank->m_Cnt);     
1843                s3d_CSharkMeshLoaderIdx *Data = MeshData->m_Topol.m_NeighBank->m_Data;
1844                Data[0] = -1;
1845                Data[1] = -1;
1846                Data[2] = -1;*/
1847        }
1848    MeshData->m_BoneWghAttr.m_BankDyn = Dyn;
1849    MeshData->m_BoneWghAttr.m_BankSig = 0; //S3D_SYS_NEW s3d_CDrvSig;
1850    MeshData->m_BoneWghAttr.m_Bank = 0;
1851    MeshData->m_BoneSubscrAttr.m_BankDyn = Dyn;
1852    MeshData->m_BoneSubscrAttr.m_BankSig = 0;
1853    MeshData->m_BoneSubscrAttr.m_Bank = 0;     
1854        {
1855/*              static s3d_CDrvSig *PointAttrSig = S3D_SYS_NEW s3d_CDrvSig;
1856        MeshData->m_PointAttr.m_BankSig = PointAttrSig;
1857        s3d_CSharkMeshLoaderBankVec3f *Bank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
1858        Bank->m_Loader = this;
1859        Bank->m_Cnt = 3;
1860        Bank->m_Data.Alloc(Bank->m_Cnt);
1861        s3d_CUtilVec3f *Data = Bank->m_Data;
1862                {
1863            s3d_CUtilVec3f Val;
1864            Val.m_x = 0;
1865            Val.m_y = 0;
1866            Val.m_z = 0;
1867            Data[0] = Val;
1868                }
1869                {
1870            s3d_CUtilVec3f Val;
1871            Val.m_x = 1;
1872            Val.m_y = 0;
1873            Val.m_z = 0;
1874            Data[1] = Val;
1875                }
1876                {
1877            s3d_CUtilVec3f Val;
1878            Val.m_x = 0;
1879            Val.m_y = 1;
1880            Val.m_z = 0;
1881            Data[2] = Val;
1882                }
1883                MeshData->m_PointAttr.m_Bank = Bank;*/         
1884                MeshData->m_PointAttr.m_BankDyn = Dyn;
1885                MeshData->m_PointAttr.m_BankSig = m_PointBankSig;
1886                MeshData->m_PointAttr.m_Bank = m_PointBank;
1887        }
1888        {
1889                MeshData->m_NormalAttr.m_BankDyn = Dyn;
1890                MeshData->m_NormalAttr.m_BankSig = m_NormalBankSig;
1891                MeshData->m_NormalAttr.m_Bank = m_NormalBank;
1892        }
1893    MeshData->m_TangentUAttr.m_BankDyn = Dyn;
1894    MeshData->m_TangentUAttr.m_BankSig = 0; //m_TangentUBankSig;
1895    MeshData->m_TangentUAttr.m_Bank = 0; //m_TangentUBank;
1896    MeshData->m_TangentVAttr.m_BankDyn = Dyn;
1897    MeshData->m_TangentVAttr.m_BankSig = 0; //m_TangentVBankSig;
1898    MeshData->m_TangentVAttr.m_Bank = 0; //m_TangentVBank;
1899    MeshData->m_ColorAlphaAttr.m_BankDyn = Dyn;
1900    MeshData->m_ColorAlphaAttr.m_BankSig = 0; //m_ColorAlphaBankSig;
1901    MeshData->m_ColorAlphaAttr.m_Bank = 0; //m_ColorAlphaBank;
1902        {
1903/*              s3d_CSharkMeshLoaderBankVec2f *TexAttrBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec2f;
1904                TexAttrBank->m_Loader = this;
1905                TexAttrBank->m_Cnt = MeshData->m_Topol.m_VertCnt;
1906                TexAttrBank->m_Data.Alloc(MeshData->m_Topol.m_VertCnt);
1907
1908                s3d_CUtilVec2f *Data = TexAttrBank->m_Data;
1909                {
1910            s3d_CUtilVec2f Val;
1911            Val.m_x = 0;
1912            Val.m_y = 0;
1913            Data[0] = Val;
1914                }       
1915                {
1916            s3d_CUtilVec2f Val;
1917            Val.m_x = 1;
1918            Val.m_y = 0;
1919            Data[1] = Val;
1920                }       
1921                {
1922            s3d_CUtilVec2f Val;
1923            Val.m_x = 1;
1924            Val.m_y = 1;
1925            Data[2] = Val;
1926                }       
1927
1928                int TexAttrCnt = 1; // we always will have just one texture coord set
1929                s3d_CEngMeshAttr *MeshTexAttrArray = new(MemPool) s3d_CEngMeshAttr[1];
1930//              m_TexAttrArray.Alloc(1);
1931
1932//              s3d_CSharkMeshLoaderAttr *TexAttr = &m_TexAttrArray[0];
1933                s3d_CEngMeshAttr *MeshTexAttr = &MeshTexAttrArray[0];
1934                MeshTexAttr->m_BankDyn = Dyn;
1935                static s3d_CDrvSig *TexAttrSig = S3D_SYS_NEW s3d_CDrvSig;
1936                MeshTexAttr->m_BankSig = TexAttrSig;
1937                MeshTexAttr->m_Bank = TexAttrBank;
1938                MeshData->m_TexAttrArray = MeshTexAttrArray;*/
1939               
1940            MeshData->m_TexAttrArray = m_TexAttrArray;         
1941                MeshData->m_TexAttrCnt = 1;
1942        }
1943
1944        MeshCompos.m_MeshData = MeshData;
1945}
1946
1947
1948void s3d_CSharkMeshLoader::GetAvailMeshComposArray(
1949        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
1950        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage,
1951        s3d_CEngMeshComposArray &MeshComposArray)
1952{
1953    CheckLoad();
1954
1955    s3d_CEngMeshCompos MeshCompos;
1956        GetMeshComposBase(MemPool,Usage,MeshCompos);
1957    MeshComposArray.InsertBack(MemPool, MeshCompos);
1958
1959        // GAMETOOLS: no tenemos variantes, son la misma malla!
1960
1961/*    s3d_CSysIntps iVariantDesc;
1962    for(iVariantDesc = 0; iVariantDesc < m_VariantDescCnt; iVariantDesc++)
1963    {
1964        s3d_CSharkMeshLoaderVariantDesc *VariantDesc
1965                = &m_VariantDescArray[iVariantDesc];
1966        if(VariantDesc->m_Usage != Usage)
1967            continue;
1968        s3d_CSysIntps VariantIdx = VariantDesc->m_VariantIdx;
1969        if(VariantIdx < 0 || VariantIdx >= m_VariantCnt)
1970            continue;
1971        s3d_CSharkMeshLoaderVariant *Variant = m_VariantArray[VariantIdx];
1972
1973        s3d_CEngMeshCompos MeshCompos;
1974        MeshCompos.m_BoundCen = m_BoundCen;
1975        MeshCompos.m_BoundExt = m_BoundExt;
1976        MeshCompos.m_BoneRefTransfCnt = m_BoneCnt;
1977        MeshCompos.m_BoneRefTransfArray = m_BoneTransfArray;
1978
1979        Variant->GetMeshComposBase(MemPool, Usage, MeshCompos);
1980
1981        s3d_CEngMeshData *MeshData = MeshCompos.m_MeshData;
1982        if(MeshData)
1983        {
1984            MeshData->m_BoundCen = m_BoundCen;
1985            MeshData->m_BoundExt = m_BoundExt;
1986            MeshData->m_Topol.m_BoneCnt = m_BoneCnt;
1987        }
1988
1989        MeshComposArray.InsertBack(MemPool, MeshCompos);
1990    }*/
1991}
1992
1993s3d_CEngGeoData *s3d_CSharkMeshLoader::GetGeoData(
1994        s3d_CUtilMsgHandler *MsgHandler, const s3d_CSysChar *Info,
1995        s3d_CUtilMemPool *MemPool, s3d_CUtilAtom *Usage)
1996{
1997    CheckLoad();
1998
1999        // GAMETOOLS: no tenemos variantes, con la misma malla!
2000        return 0;
2001
2002/*    s3d_CSysIntps VariantIdx = SearchVariantIdxPrec(Usage, 0);
2003    if(VariantIdx < 0)
2004        return 0;
2005
2006    s3d_CSharkMeshLoaderVariant *Variant = m_VariantArray[VariantIdx];
2007    return Variant->GetGeoData(MsgHandler, Info, MemPool, Usage);*/
2008}
2009
2010bool s3d_CSharkMeshLoader::VisibCheckInf(
2011        s3d_CUtilMemPool *MemPool, s3d_CUtilVec3f_cr RelRefPoint)
2012{
2013    return true;
2014}
2015
2016void s3d_CSharkMeshLoader::VisibAddBoundTest(
2017        s3d_CUtilMemPool *MemPool,
2018        s3d_CEngBoundTestArray *BoundTestArray,
2019        s3d_CUtilVec3f_cr RelRefPoint,
2020        s3d_CUtilVec3f_cr BoundTransl, s3d_CUtilQuatf_cr BoundQuat)
2021{
2022}
2023
2024void s3d_CSharkMeshLoader::Reduce()
2025{
2026    s3d_CUtilMsg m;
2027    m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.model_reduce";
2028    m.m_StdTempl = "Reducing standard model \"[1]\".";
2029    m.AddInfo(m_Info);
2030    m.AddInfo(m_ResName);
2031    s3d_UtilMsgReportNote(m_MsgHandler, m);
2032
2033        // GAMETOOLS: no tenemos variantes, son la misma malla!
2034        // LO QUE HACE ESTO ES LIBERAR LOS DATOS QUE YA NO HACE FALTA TENERLOS EN MEMORIA
2035
2036/*    int iVariant;
2037    for(iVariant = 0; iVariant < m_VariantCnt; iVariant++)
2038    {
2039        s3d_CSharkMeshLoaderVariant *Variant = m_VariantArray[iVariant];
2040        Variant->Reduce();
2041    }*/
2042}
2043
2044void s3d_CSharkMeshLoader::ResChanged()
2045{
2046    Unload();
2047
2048    m_NotifMgr.PerformNotif();
2049}
2050
2051void s3d_CSharkMeshLoader::ChangedPerform()
2052{
2053    Unload();
2054   
2055    m_NotifMgr.PerformNotif();
2056}
2057
2058void s3d_CSharkMeshLoader::Unload()
2059{
2060    /*
2061    s3d_CUtilMsg m;
2062    m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.model_destroy";
2063    m.m_StdTempl = "Unloading standard model \"[1]\".";
2064    m.AddInfo(m_Info);
2065    m.AddInfo(m_ResName);
2066    s3d_UtilMsgReportNote(m_MsgHandler, m);
2067    */
2068
2069    m_RangeStart = 0;
2070    m_RangeEnd = 0;
2071    m_BoundCen = 0;
2072    m_BoundExt = 0;
2073    m_BoneCnt = 0;
2074    m_BoneNameArray.Reset();
2075    m_BoneTransfArray.Reset();
2076    m_TexNameCnt = 0;
2077    m_TexNameArray.Reset();
2078/*    m_VariantCnt = 0;
2079    m_VariantDescArray.Reset();*/
2080
2081    m_Loaded = false;
2082}
2083
2084void s3d_CSharkMeshLoader::CheckLoad()
2085{
2086    if(!m_Loaded)
2087        Load();
2088}
2089
2090void s3d_CSharkMeshLoader::Load()
2091{
2092    s3d_CUtilMsg m;
2093    m.m_Code = "shark_mesh_loader.model_load";
2094    m.m_StdTempl = "Loading standard model \"[1]\".";
2095    m.AddInfo(m_Info);
2096    m.AddInfo(m_ResName);
2097    s3d_UtilMsgReportNote(m_MsgHandler, m);
2098
2099    m_Loaded = true;
2100
2101        m_GeoMesh = geo_mesh_loader.load((char*)m_ResName.GetChars()); 
2102
2103        if (m_GeoMesh)
2104        {
2105                ReadModelGT();
2106                m_TexNameCnt = 1;
2107                m_TexNameArray.Alloc(m_TexNameCnt);
2108                m_TexNameArray[0] = "stdtex:level/texture/Devil_diffuse_Atomic-Design.tga";
2109//              m_TexNameArray[1] = "stdtex:level/texture/Head_07_Devil_normal.tga";
2110        }
2111       
2112
2113/*    int Generosity = 0;
2114    s3d_CUtilStr ResInfo;
2115    s3d_CUtilStreamPtr ResStream;
2116    bool Final = false;
2117    m_ResMgr->GetResource(
2118            m_Info, m_ResName, true, Generosity,
2119            ResInfo, ResStream, Final, &m_NotifRecip);
2120
2121    if(ResStream && ResStream->GetSize() > 0)
2122    {
2123        s3d_CUtilSnkSeqReadPtr Snk;
2124        int SnkFormat = 0;
2125        s3d_CUtilSnkWork::CreateSeqReadStream(m_MsgHandler, m_Info,
2126                ResStream, m_Bare, SnkFormat, Snk);
2127
2128        s3d_CUtilStr Format;
2129        while(Snk->GetRemainField() > 0)
2130        {
2131            s3d_CUtilStr FieldName = Snk->BeginField();
2132            if(FieldName == "format")
2133            {
2134                Format = Snk->ReadStr();
2135            }
2136            else if(FieldName == "data")
2137            {
2138                if(Format == S3D_SHARK_MESH_LOADER_MODEL_SNKFORMAT)
2139                {
2140                    Snk->BeginChunk();
2141                    ReadModel(Snk);
2142                    Snk->EndChunk();
2143                }
2144                else
2145                {
2146                    s3d_CUtilMsg e;
2147                    e.m_Code =
2148                            "eng/posgen/std/eng_posgen_std_model.model_format";
2149                    e.m_StdTempl = "Found format \"[2]\" instead of \"[1]\".";
2150                    e.AddInfo(m_Info);
2151                    e.AddInfo(S3D_SHARK_MESH_LOADER_MODEL_SNKFORMAT);
2152                    e.AddInfo(Format);
2153                    s3d_UtilMsgReportError(m_MsgHandler, e);
2154                }
2155            }
2156            Snk->EndField();
2157        }
2158        if(Format.IsEmpty())
2159        {
2160            s3d_CUtilMsg e;
2161            e.m_Code = "eng/posgen/std/eng_posgen_std_model.variant_no_format";
2162            e.m_StdTempl = "No format \"[1]\" found.";
2163            e.AddInfo(m_Info);
2164            e.AddInfo(S3D_SHARK_MESH_LOADER_MODEL_SNKFORMAT);
2165            s3d_UtilMsgReportError(m_MsgHandler, e);
2166        }
2167
2168        Snk->Finish();
2169    }
2170
2171    // Load variants:
2172
2173    s3d_CUtilStr ModelResSuffix = s3d_CUtilFilesystem::GetSuffix(m_ResName);
2174    s3d_CUtilStr ModelResStem = s3d_CUtilFilesystem::GetWithoutSuffix(
2175            m_ResName);
2176
2177    m_VariantArray.Alloc(m_VariantCnt);
2178    s3d_CSysIntps iVariant;
2179    for(iVariant = 0; iVariant < m_VariantCnt; iVariant++)
2180    {
2181        s3d_CUtilStr VariantResStem = ModelResStem + "$" +
2182                s3d_CUtilStrUtil::StrOfInt(iVariant);
2183        s3d_CUtilStr VariantResName = VariantResStem + ModelResSuffix;
2184
2185        s3d_CSharkMeshLoaderVariantPtr Variant
2186                = S3D_SYS_NEW s3d_CSharkMeshLoaderVariant(
2187                        m_MsgHandler, m_Info, m_Bare,
2188                        m_AtomMgr, m_ResMgr, VariantResName, this);
2189        m_VariantArray[iVariant] = Variant;
2190    }*/
2191}
2192
2193/*void s3d_CSharkMeshLoader::ReadModel(
2194        s3d_CUtilSnkSeqRead *Snk)
2195{
2196    m_RangeStart = 0;
2197    m_RangeEnd = 0;
2198
2199    m_BoundCen = 0;
2200    m_BoundExt = 0;
2201
2202    m_BoneCnt = -1;
2203
2204    m_BoneNameArray.Reset();
2205    m_BoneTransfArray.Reset();
2206    m_TexNameArray.Reset();
2207
2208    s3d_CUtilArray<s3d_CSharkMeshLoaderVariantDesc> VariantDescArray;
2209    s3d_CUtilPtrArray<s3d_CSharkMeshLoaderVariant> VariantArray;
2210
2211    bool HasTexCnt = false;
2212    bool HasVariant = false;
2213    bool HasVariantDesc = false;
2214
2215    while(Snk->GetRemainField() > 0)
2216    {
2217        s3d_CUtilStr FieldName = Snk->BeginField();
2218        if(FieldName == "name")
2219            m_ModelName = Snk->ReadStr();
2220        else if(FieldName == "range")
2221        {
2222            m_RangeStart = Snk->ReadFloat();
2223            m_RangeEnd = Snk->ReadFloat();
2224        }
2225        else if(FieldName == "bound")
2226        {
2227            m_BoundCen.m_x = Snk->ReadFloat();
2228            m_BoundCen.m_y = Snk->ReadFloat();
2229            m_BoundCen.m_z = Snk->ReadFloat();
2230            m_BoundExt.m_x = Snk->ReadFloat();
2231            m_BoundExt.m_y = Snk->ReadFloat();
2232            m_BoundExt.m_z = Snk->ReadFloat();
2233        }
2234        else if(FieldName == "bone_cnt")
2235        {
2236            if(m_BoneCnt >= 0)
2237                ThrowFormatError("bone_cnt");
2238            m_BoneCnt = Snk->ReadInt();
2239        }
2240        else if(FieldName == "bone_name_array")
2241        {
2242            int BoneNameCnt = Snk->GetRemainStr();
2243            if(BoneNameCnt != m_BoneCnt)
2244                ThrowFormatError("bone_name_array");
2245            m_BoneNameArray.Alloc(m_BoneCnt);
2246            int i;
2247            for(i = 0; i < m_BoneCnt; i++)
2248                m_BoneNameArray[i] = Snk->ReadStr();
2249        }
2250        else if(FieldName == "bone_transf_array")
2251        {
2252            int BoneTransfCnt = Snk->GetRemainFloat() / 7;
2253            if(BoneTransfCnt != m_BoneCnt)
2254                ThrowFormatError("bone_transf_array");
2255            m_BoneTransfArray.Alloc(m_BoneCnt);
2256            int i;
2257            for(i = 0; i < m_BoneCnt; i++)
2258            {
2259                s3d_CUtilTranslQuatf Transf;
2260                Transf.m_Transl.m_x = Snk->ReadFloat();
2261                Transf.m_Transl.m_y = Snk->ReadFloat();
2262                Transf.m_Transl.m_z = Snk->ReadFloat();
2263                Transf.m_Quat.m_x = Snk->ReadFloat();
2264                Transf.m_Quat.m_y = Snk->ReadFloat();
2265                Transf.m_Quat.m_z = Snk->ReadFloat();
2266                Transf.m_Quat.m_w = Snk->ReadFloat();
2267                m_BoneTransfArray[i] = Transf;
2268            }
2269        }
2270        else if(FieldName == "tex_name_array")
2271        {
2272            if(HasTexCnt)
2273                ThrowFormatError("tex_name_array");
2274            HasTexCnt = true;
2275            m_TexNameCnt = Snk->GetRemainStr();
2276            if(m_TexNameArray)
2277                ThrowFormatError("tex_name_array");
2278            m_TexNameArray.Alloc(m_TexNameCnt);
2279            int i;
2280            for(i = 0; i < m_TexNameCnt; i++)
2281                m_TexNameArray[i] = Snk->ReadStr();
2282        }
2283        else if(FieldName == "variant_cnt")
2284        {
2285            if(HasVariant)
2286                ThrowFormatError("variant");
2287            HasVariant = true;
2288            int NewVariantCnt = Snk->ReadInt();
2289            m_VariantCnt = NewVariantCnt;
2290        }
2291        else if(FieldName == "variantdesc_array")
2292        {
2293            if(HasVariantDesc)
2294                ThrowFormatError("variantdesc_array");
2295            HasVariantDesc = true;
2296            int NewVariantDescCnt = Snk->GetRemainChunk();
2297            m_VariantDescCnt = NewVariantDescCnt;
2298            m_VariantDescArray.Alloc(m_VariantDescCnt);
2299            int iVariantDesc;
2300            for(iVariantDesc = 0; iVariantDesc < m_VariantDescCnt;
2301                    iVariantDesc++)
2302            {
2303                Snk->BeginChunk();
2304                ReadVariantDesc(Snk, m_VariantDescArray[iVariantDesc]);
2305                Snk->EndChunk();
2306            }
2307        }
2308        Snk->EndField();
2309    }
2310}*/
2311
2312void s3d_CSharkMeshLoader::ReadModelGT()
2313{
2314        if (m_GeoMesh->mSubMeshCount>1)
2315                ThrowFormatError("Only meshes composed by 1 submesh are supported.");
2316
2317/*      if (!m_GeoMesh->mVertexBuffer || (m_GeoMesh->mVertexBuffer && m_GeoMesh->mVertexBuffer->mVertexCount==0))
2318                m_GeoMesh = m_GeoMesh->toSharedVertex(); // the original mesh must be deleted! MEMORY LEAK!
2319*/
2320//      assert(!m_GeoMesh->mVertexBuffer || (m_GeoMesh->mVertexBuffer && m_GeoMesh->mVertexBuffer->mVertexCount==0));
2321/*      if (m_GeoMesh->mSubMesh[0].mType==Geometry::GEO_TRIANGLE_STRIPS)
2322                use_triangle_strips = true;*/
2323
2324        if (geo_mesh_loader.GetLodStripsData()==NULL)
2325                ThrowFormatError("Only mesh models with LOD info are supported");               
2326
2327    m_RangeStart = 0; // parece que estos e refiere a las animaciones
2328    m_RangeEnd = 0;
2329
2330    m_BoundCen = 0;
2331    m_BoundExt = 0;
2332
2333    m_BoneCnt = -1;
2334
2335    m_BoneNameArray.Reset();
2336    m_BoneTransfArray.Reset();
2337    m_TexNameArray.Reset();
2338
2339    bool HasTexCnt = false;
2340    bool HasVariant = false;
2341    bool HasVariantDesc = false;
2342
2343        m_ModelName = "GtModel";
2344
2345        m_BoundCen.m_x = (m_GeoMesh->mMeshBounds.minX + m_GeoMesh->mMeshBounds.maxX) / 2;
2346        m_BoundCen.m_y = (m_GeoMesh->mMeshBounds.minY + m_GeoMesh->mMeshBounds.maxY) / 2;
2347        m_BoundCen.m_z = (m_GeoMesh->mMeshBounds.minZ + m_GeoMesh->mMeshBounds.maxZ) / 2;
2348        m_BoundExt.m_x = fabsf(m_GeoMesh->mMeshBounds.minX - m_GeoMesh->mMeshBounds.maxX);
2349        m_BoundExt.m_y = fabsf(m_GeoMesh->mMeshBounds.minY - m_GeoMesh->mMeshBounds.maxY);
2350        m_BoundExt.m_z = fabsf(m_GeoMesh->mMeshBounds.minZ - m_GeoMesh->mMeshBounds.maxZ);
2351
2352        // VERTEX BUFFER INFO
2353        // alloc vertex buffer
2354    m_PointBankSig = S3D_SYS_NEW s3d_CDrvSig;
2355    m_PointBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
2356    m_PointBank->m_Loader = this;
2357    m_PointBank->m_Cnt = m_GeoMesh->mVertexBuffer->mVertexCount;
2358    m_PointBank->m_Data.Alloc(m_GeoMesh->mVertexBuffer->mVertexCount);
2359
2360        // alloc normal buffer
2361    m_NormalBankSig = S3D_SYS_NEW s3d_CDrvSig;
2362    m_NormalBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec3f;
2363    m_NormalBank->m_Loader = this;
2364    m_NormalBank->m_Cnt = m_GeoMesh->mVertexBuffer->mVertexCount;
2365    m_NormalBank->m_Data.Alloc(m_GeoMesh->mVertexBuffer->mVertexCount);
2366
2367        // alloc tex buffer
2368        m_TexAttrArray = S3D_SYS_NEW s3d_CEngMeshAttr;
2369    m_TexAttrArray->m_BankSig = S3D_SYS_NEW s3d_CDrvSig;
2370    s3d_CSharkMeshLoaderBankVec2f *tBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankVec2f;
2371    tBank->m_Loader = this;
2372    tBank->m_Cnt = m_GeoMesh->mVertexBuffer->mVertexCount;
2373    tBank->m_Data.Alloc(m_GeoMesh->mVertexBuffer->mVertexCount);
2374        m_TexAttrArray->m_Bank = tBank;
2375
2376    s3d_CUtilVec3f *vData = m_PointBank->m_Data;
2377    s3d_CUtilVec3f *nData = m_NormalBank->m_Data;
2378    s3d_CUtilVec2f *tData = tBank->m_Data;
2379    for(int i = 0; i < m_GeoMesh->mVertexBuffer->mVertexCount; i++)
2380    {
2381        s3d_CUtilVec3f Val;
2382        Val.m_x = m_GeoMesh->mVertexBuffer->mPosition[i].x;
2383        Val.m_y = m_GeoMesh->mVertexBuffer->mPosition[i].y;
2384        Val.m_z = m_GeoMesh->mVertexBuffer->mPosition[i].z;
2385        vData[i] = Val;
2386
2387        Val.m_x = m_GeoMesh->mVertexBuffer->mNormal[i].x;
2388        Val.m_y = m_GeoMesh->mVertexBuffer->mNormal[i].y;
2389        Val.m_z = m_GeoMesh->mVertexBuffer->mNormal[i].z;
2390        nData[i] = Val;
2391
2392        s3d_CUtilVec2f Val2;
2393        Val2.m_x = m_GeoMesh->mVertexBuffer->mTexCoords[i].x;
2394        Val2.m_y = m_GeoMesh->mVertexBuffer->mTexCoords[i].y;
2395        tData[i] = Val2;
2396    }
2397
2398        // INDICES
2399        m_IdxBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
2400        m_IdxBank->m_Loader = this;
2401    m_IdxBank->m_Cnt = 0;
2402
2403        for (int i=0; i<m_GeoMesh->mSubMeshCount; i++)
2404                m_IdxBank->m_Cnt += m_GeoMesh->mSubMesh[i].mIndexCount;
2405
2406        m_IdxBank->m_Data.Alloc(m_IdxBank->m_Cnt);
2407
2408        for (int i=0, k=0; i<m_GeoMesh->mSubMeshCount; i++)
2409        {
2410                for (int j=0; j<m_GeoMesh->mSubMesh[i].mIndexCount; j++, k++)
2411                {
2412                        int RawIdx = m_GeoMesh->mSubMesh[i].mIndex[j];
2413                        if (RawIdx < 0 || RawIdx >= m_GeoMesh->mVertexBuffer->mVertexCount)
2414                                ThrowFormatError("m_GeoMesh->mSubMesh[i].mIndex[j] out_of_range");
2415
2416                        s3d_CSharkMeshLoaderIdx Idx = s3d_CSharkMeshLoaderIdx(RawIdx);
2417                        m_IdxBank->m_Data[k] = Idx;
2418                }
2419        }
2420
2421        // BONE INDICES
2422        /* nuevo de los huesos!*/
2423/*      if (m_GeoMesh->hasSkeleton)
2424        {
2425                m_BoneCnt = m_GeoMesh->mBones.size();
2426                m_BoneIdxBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankMeshIdx;
2427                m_BoneIdxBank->m_Loader = this;
2428                m_BoneIdxBank->m_Cnt = 0;
2429
2430                m_BoneIdxBank->m_Data.Alloc(m_GeoMesh->mSubMesh[0].m
2431        }
2432       
2433*/
2434
2435        /* */
2436
2437
2438//      // FAMILIES
2439//      m_FamilyArray = new s3d_CEngMeshFamily[m_GeoMesh->mSubMeshCount]; //m_Topol.m_FamilyArray;
2440//      for (int i=0; i<m_GeoMesh->mSubMeshCount; i++)
2441//      {
2442//              m_FamilyArray[i].m_BoneIdxCnt = 0;
2443//              m_FamilyArray[i].m_BoneIdxEssCnt = 0;
2444//              m_FamilyArray[i].m_IdxCnt = m_GeoMesh->mSubMesh[i].mIndexCount;
2445//              m_FamilyArray[i].m_IdxEssCnt = m_GeoMesh->mSubMesh[i].mIndexCount;
2446//              m_FamilyArray[i].m_PacketCnt = 1;
2447//              m_FamilyArray[i].m_VertCnt = m_GeoMesh->mSubMesh[i].mVertexBuffer->mVertexCount;
2448//              m_FamilyArray[i].m_VertEssCnt = m_FamilyArray[i].m_VertCnt;
2449//      }
2450
2451        // PACKETS
2452
2453        m_PacketsBank = S3D_SYS_NEW s3d_CSharkMeshLoaderBankPacket;             
2454        m_PacketsBank->m_Loader = this;
2455        m_PacketsBank->m_Cnt = m_GeoMesh->mSubMeshCount; // always assume 1 packet per family
2456        m_PacketsBank->m_Data.Alloc(m_PacketsBank->m_Cnt);
2457    s3d_CDrvMeshPacket *Data = m_PacketsBank->m_Data;
2458    for(int iPacket = 0; iPacket < m_PacketsBank->m_Cnt; iPacket++)
2459    {
2460        s3d_CDrvMeshPacket *Packet = &Data[iPacket];
2461                Packet->m_VertCnt = m_GeoMesh->mSubMesh[iPacket].mVertexBuffer->mVertexCount;
2462        Packet->m_VertEssCnt = Packet->m_VertCnt;
2463        Packet->m_IdxCnt = m_GeoMesh->mSubMesh[iPacket].mIndexCount;
2464        Packet->m_IdxEssCnt = Packet->m_IdxCnt;
2465        Packet->m_BoneIdxCnt = 0;
2466        Packet->m_BoneIdxEssCnt = 0;
2467    }
2468
2469 /*   while(Snk->GetRemainField() > 0)
2470    {
2471        s3d_CUtilStr FieldName = Snk->BeginField();
2472        if(FieldName == "name")
2473            m_ModelName = Snk->ReadStr();
2474        else if(FieldName == "range")
2475        {
2476            m_RangeStart = Snk->ReadFloat();
2477            m_RangeEnd = Snk->ReadFloat();
2478        }
2479        else if(FieldName == "bound")
2480        {
2481            m_BoundCen.m_x = Snk->ReadFloat();
2482            m_BoundCen.m_y = Snk->ReadFloat();
2483            m_BoundCen.m_z = Snk->ReadFloat();
2484            m_BoundExt.m_x = Snk->ReadFloat();
2485            m_BoundExt.m_y = Snk->ReadFloat();
2486            m_BoundExt.m_z = Snk->ReadFloat();
2487        }
2488        else if(FieldName == "bone_cnt")
2489        {
2490            if(m_BoneCnt >= 0)
2491                ThrowFormatError("bone_cnt");
2492            m_BoneCnt = Snk->ReadInt();
2493        }
2494        else if(FieldName == "bone_name_array")
2495        {
2496            int BoneNameCnt = Snk->GetRemainStr();
2497            if(BoneNameCnt != m_BoneCnt)
2498                ThrowFormatError("bone_name_array");
2499            m_BoneNameArray.Alloc(m_BoneCnt);
2500            int i;
2501            for(i = 0; i < m_BoneCnt; i++)
2502                m_BoneNameArray[i] = Snk->ReadStr();
2503        }
2504        else if(FieldName == "bone_transf_array")
2505        {
2506            int BoneTransfCnt = Snk->GetRemainFloat() / 7;
2507            if(BoneTransfCnt != m_BoneCnt)
2508                ThrowFormatError("bone_transf_array");
2509            m_BoneTransfArray.Alloc(m_BoneCnt);
2510            int i;
2511            for(i = 0; i < m_BoneCnt; i++)
2512            {
2513                s3d_CUtilTranslQuatf Transf;
2514                Transf.m_Transl.m_x = Snk->ReadFloat();
2515                Transf.m_Transl.m_y = Snk->ReadFloat();
2516                Transf.m_Transl.m_z = Snk->ReadFloat();
2517                Transf.m_Quat.m_x = Snk->ReadFloat();
2518                Transf.m_Quat.m_y = Snk->ReadFloat();
2519                Transf.m_Quat.m_z = Snk->ReadFloat();
2520                Transf.m_Quat.m_w = Snk->ReadFloat();
2521                m_BoneTransfArray[i] = Transf;
2522            }
2523        }
2524        else if(FieldName == "tex_name_array")
2525        {
2526            if(HasTexCnt)
2527                ThrowFormatError("tex_name_array");
2528            HasTexCnt = true;
2529            m_TexNameCnt = Snk->GetRemainStr();
2530            if(m_TexNameArray)
2531                ThrowFormatError("tex_name_array");
2532            m_TexNameArray.Alloc(m_TexNameCnt);
2533            int i;
2534            for(i = 0; i < m_TexNameCnt; i++)
2535                m_TexNameArray[i] = Snk->ReadStr();
2536        }
2537        else if(FieldName == "variant_cnt")
2538        {
2539            if(HasVariant)
2540                ThrowFormatError("variant");
2541            HasVariant = true;
2542            int NewVariantCnt = Snk->ReadInt();
2543            m_VariantCnt = NewVariantCnt;
2544        }
2545        else if(FieldName == "variantdesc_array")
2546        {
2547            if(HasVariantDesc)
2548                ThrowFormatError("variantdesc_array");
2549            HasVariantDesc = true;
2550            int NewVariantDescCnt = Snk->GetRemainChunk();
2551            m_VariantDescCnt = NewVariantDescCnt;
2552            m_VariantDescArray.Alloc(m_VariantDescCnt);
2553            int iVariantDesc;
2554            for(iVariantDesc = 0; iVariantDesc < m_VariantDescCnt;
2555                    iVariantDesc++)
2556            {
2557                Snk->BeginChunk();
2558                ReadVariantDesc(Snk, m_VariantDescArray[iVariantDesc]);
2559                Snk->EndChunk();
2560            }
2561        }
2562        Snk->EndField();
2563    }*/
2564}
2565
2566/*
2567void s3d_CSharkMeshLoader::ReadVariantDesc(
2568        s3d_CUtilSnkSeqRead *Snk,
2569        s3d_CSharkMeshLoaderVariantDesc &VariantDesc)
2570{
2571    while(Snk->GetRemainField() > 0)
2572    {
2573        s3d_CUtilStr FieldName = Snk->BeginField();
2574        if(FieldName == "usage")
2575        {
2576            s3d_CUtilStr UsageStr = Snk->ReadStr();
2577            VariantDesc.m_Usage = m_AtomMgr->GetAtom(UsageStr);
2578        }
2579        else if(FieldName == "prec")
2580            VariantDesc.m_Prec = Snk->ReadFloat();
2581        else if(FieldName == "variant_idx")
2582            VariantDesc.m_VariantIdx = Snk->ReadInt();
2583        Snk->EndField();
2584    }
2585}*/
2586
2587void s3d_CSharkMeshLoader::ThrowFormatError(s3d_CUtilStr_cr Kind)
2588{
2589    s3d_CUtilMsg e;
2590    e.m_Code = "eng/model/std/SHARK_MESH_LOADER.format";
2591    e.m_StdTempl = "Model \"[1]\" has an illegal format "
2592                    "concerning \"[2]\".";
2593    e.AddInfo(m_Info);
2594    e.AddInfo(m_ModelName);
2595    e.AddInfo(Kind);
2596    s3d_UtilMsgReportFatal(m_MsgHandler, e);
2597}
2598/*
2599s3d_CSysIntps s3d_CSharkMeshLoader::SearchVariantIdxPrec(
2600        s3d_CUtilAtom *Usage, float Prec)
2601{
2602    if(!Usage)
2603        return -1;
2604
2605    s3d_CSysIntps BestBelowVariantIdx = -1;
2606    float BestBelowPrec = -FLT_MAX;
2607    s3d_CSysIntps BestAboveVariantIdx = -1;
2608    float BestAbovePrec = FLT_MAX;
2609    s3d_CSysIntps iVariantDesc;
2610    for(iVariantDesc = 0; iVariantDesc < m_VariantDescCnt; iVariantDesc++)
2611    {
2612        s3d_CSharkMeshLoaderVariantDesc *VariantDesc =
2613                &m_VariantDescArray[iVariantDesc];
2614        if(VariantDesc->m_Usage == Usage)
2615        {
2616            float VariantPrec = VariantDesc->m_Prec;
2617            if(VariantPrec <= Prec)
2618            {
2619                if(VariantPrec > BestBelowPrec)
2620                {
2621                    BestBelowVariantIdx = VariantDesc->m_VariantIdx;
2622                    BestBelowPrec = VariantPrec;
2623                }
2624            }
2625            else
2626            {
2627                if(VariantPrec < BestAbovePrec)
2628                {
2629                    BestAboveVariantIdx = VariantDesc->m_VariantIdx;
2630                    BestAbovePrec = VariantPrec;
2631                }
2632            }
2633        }
2634    }
2635    if(BestBelowVariantIdx >= 0)
2636        return BestBelowVariantIdx;
2637    else
2638        return BestAboveVariantIdx;
2639}*/
2640
2641float s3d_CSharkMeshLoader::CalcMeshPrec(
2642                        s3d_CUtilMat4x4f_cr Map, s3d_CUtilVec3f_cr Prec)
2643{
2644    if(Map == 0)
2645        return 0;
2646    if(Prec == 0)
2647        return 0;
2648    s3d_CUtilMat3x3f Deriv = Map.MulOneProjDeriv(m_BoundCen);
2649    s3d_CUtilVec3f Scale = Deriv.RowGetSumAbsComp();
2650    float MeshPrec = Prec.CompDiv(Scale).GetMinComp();
2651    return MeshPrec;
2652}
2653
2654///////////////////////////////////////////////////////////////////////////////
2655/*@{
2656
2657@declare{comp.class}{SHARK_MESH_LOADER.modelsuppl}{}
2658
2659Supplier for standard models as written by the prepare tool.
2660@p
2661
2662@}*/
2663///////////////////////////////////////////////////////////////////////////////
2664
2665S3D_UTIL_RTTI_TABLE_DEFINE_BEGIN(s3d_CSharkMeshLoaderSuppl)
2666S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompSuppl)
2667S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompSetup)
2668S3D_UTIL_RTTI_TABLE_DEFINE_END
2669
2670s3d_CSharkMeshLoaderSuppl::s3d_CSharkMeshLoaderSuppl()
2671{
2672}
2673
2674s3d_CSharkMeshLoaderSuppl::s3d_CSharkMeshLoaderSuppl(
2675        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
2676        bool Bare, s3d_CUtilAtomMgr *AtomMgr, s3d_CCompResMgr *ResMgr)
2677{
2678    m_Bare = Bare;
2679    m_AtomMgr = AtomMgr;
2680    m_ResMgr = ResMgr;
2681}
2682
2683void s3d_CSharkMeshLoaderSuppl::SetupInit(
2684        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
2685        s3d_CCompSuppl *FetchSuppl, s3d_CUtilSnkChunk *Param)
2686{
2687    s3d_CUtilSnkExtract SnkExtract;
2688    SnkExtract.Assign(MsgHandler, Param);
2689
2690    /*@{ @declare{comp.param}{shark_mesh_loader.modelsuppl.env}{$ [str]}
2691    @}*/
2692    s3d_CUtilStr EnvIdent, EnvInfo;
2693    SnkExtract.ExtractStr(EnvInfo, EnvIdent, "env", true);
2694
2695    SnkExtract.CheckForUnknown();
2696
2697    s3d_CCompEnvPtr Env = s3d_CompSupplObjT<s3d_CCompEnv>(
2698            MsgHandler, EnvInfo, FetchSuppl,
2699            EnvIdent, S3D_GENERAL_INTEROP_INTERF);
2700    if(!Env)
2701        return;
2702
2703    m_Bare = Env->m_Bare;
2704    m_AtomMgr = Env->m_AtomMgr;
2705    m_ResMgr = Env->m_ResMgr;
2706}
2707
2708void s3d_CSharkMeshLoaderSuppl::SetupDone()
2709{
2710}
2711
2712s3d_CCompObjPtr s3d_CSharkMeshLoaderSuppl::SupplObj(
2713        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
2714        s3d_CUtilStr_cr Ident, s3d_CUtilStr_cr Version)
2715{
2716    if(Ident.IsEmpty())
2717        return 0;
2718
2719    s3d_CUtilMsg m;
2720    m.m_Code = "eng/model/std/SHARK_MESH_LOADER_model.create_model";
2721    m.m_StdTempl = "Creating standard model \"[1]\". "
2722            "The model is not loaded yet. ";
2723    m.AddInfo(Info);
2724    m.AddInfo(Ident);
2725    s3d_UtilMsgReportNote(MsgHandler, m);
2726
2727    s3d_CSharkMeshLoaderPtr Model = S3D_SYS_NEW s3d_CSharkMeshLoader(
2728            MsgHandler, Info, m_Bare, m_AtomMgr, m_ResMgr, Ident);
2729    return Model.Get();
2730}
2731
2732void s3d_CSharkMeshLoader::LoaderPerform()
2733{
2734    Load();
2735}
2736
2737
2738///////////////////////////////////////////////////////////////////////////////
Note: See TracBrowser for help on using the repository browser.