← Back to branch summary

~om26er/ubuntu/oneiric/nux/sru-819721

« back to all changes in this revision

Viewing changes to NuxMesh/NTextureArchiveManager.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-11-18 19:17:32 UTC
  • Revision ID: james.westby@ubuntu.com-20101118191732-rn35790vekj6o4my
Tags: upstream-0.9.4
Import upstream version 0.9.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxMesh/NTextureArchiveManager.cpp
 
1
/*
 
2
 * Copyright 2010 Inalogic Inc.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify it
 
5
 * under the terms of the GNU Lesser General Public License version 3, as
 
6
 * published by the  Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful, but
 
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
10
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
 
11
 * PURPOSE.  See the applicable version of the GNU Lesser General Public
 
12
 * License for more details.
 
13
 *
 
14
 * You should have received a copy of both the GNU Lesser General Public
 
15
 * License version 3 along with this program.  If not, see
 
16
 * <http://www.gnu.org/licenses/>
 
17
 *
 
18
 * Authored by: Jay Taoko <jay.taoko_AT_gmail_DOT_com>
 
19
 *
 
20
 */
 
21
 
 
22
 
 
23
#include "NuxCore/NuxCore.h"
 
24
 
 
25
#include "NuxCore/FilePath.h"
 
26
#include "NuxImage/Tga.h"
 
27
#include "NuxImage/ImageSurface.h"
 
28
#include "NuxImage/NITX.h"
 
29
#include "NTextureArchiveManager.h"
 
30
 
 
31
#include "NuxCore/TinyXML/tinyxml.h"
 
32
 
 
33
namespace nux
 
34
{
 
35
 
 
36
  bool IsUITextureArchive (const TCHAR *ArchiveFileName)
 
37
  {
 
38
    NSerializer *fileStream = GFileManager.CreateFileReader (ArchiveFileName, NSerializer::Read | NSerializer::Write);
 
39
 
 
40
    fileStream->Seek (0, NSerializer::SeekStart);
 
41
 
 
42
    unsigned int FileTag;
 
43
    fileStream->Serialize ( (char *) &FileTag, sizeof (FileTag) );
 
44
    fileStream->Close();
 
45
 
 
46
    if (FileTag != UITEXTUREARCHIVETAG)
 
47
    {
 
48
      return false;
 
49
    }
 
50
 
 
51
    return true;
 
52
  }
 
53
 
 
54
  NUITextureArchiver::NUITextureArchiver (const TCHAR *ArchiveFileName)
 
55
  {
 
56
    if (IsUITextureArchive (ArchiveFileName) )
 
57
      LoadUIArchive (ArchiveFileName, m_ArchiveTextureArray);
 
58
  }
 
59
 
 
60
  NUITextureArchiver::~NUITextureArchiver()
 
61
  {
 
62
    int num = m_ArchiveTextureArray.size();
 
63
 
 
64
    for (int n = 0; n < num; n++)
 
65
    {
 
66
      delete m_ArchiveTextureArray[n]->BaseTexture;
 
67
      delete m_ArchiveTextureArray[n];
 
68
    }
 
69
 
 
70
    m_ArchiveTextureArray.clear();
 
71
  }
 
72
 
 
73
  NBitmapData *NUITextureArchiver::ExtractTextureStyle (const TCHAR *Style)
 
74
  {
 
75
    int num = m_ArchiveTextureArray.size();
 
76
 
 
77
    for (int n = 0; n < num; n++)
 
78
    {
 
79
      if (Stricmp (m_ArchiveTextureArray[n]->Style.GetTCharPtr(), Style) == 0)
 
80
      {
 
81
        return m_ArchiveTextureArray[n]->BaseTexture;
 
82
      }
 
83
    }
 
84
 
 
85
    return 0;
 
86
  }
 
87
 
 
88
  NBitmapData *NUITextureArchiver::GetTexture (t_u32 index)
 
89
  {
 
90
    nuxAssert (index >= 0);
 
91
    nuxAssert (index < m_ArchiveTextureArray.size() );
 
92
 
 
93
    if ( (index < 0) || (index > m_ArchiveTextureArray.size() ) )
 
94
      return 0;
 
95
 
 
96
    return m_ArchiveTextureArray[index]->BaseTexture;
 
97
  }
 
98
 
 
99
  int NUITextureArchiver::GetNumTexture()
 
100
  {
 
101
    return m_ArchiveTextureArray.size();
 
102
  }
 
103
 
 
104
// XMLUIFile format:
 
105
//
 
106
//  <PaintData>
 
107
//      <Image Name="Stroke_10pxrad_2px.tga" type="Stroke" style="eSTROKE_CORNER_ROUND10" border_left="10" border_right="10" border_top="10" border_bottom="10" border_only="true" />
 
108
//      <Image Name="Stroke_4pxrad_2px.tga" type="Stroke" style="eSTROKE_CORNER_ROUND4" border_left="4" border_right="4" border_top="4" border_bottom="4" border_only="true" />
 
109
//  </PaintData>
 
110
 
 
111
  bool LoadXMLUITextures (const char *XMLUIFile, std::vector<ArchiveTextureData *>& ArchTexArray)
 
112
  {
 
113
    FilePath m_FilePath;
 
114
    m_FilePath.AddSearchPath (TEXT ("") ); // for case where fully qualified path is given
 
115
    m_FilePath.AddSearchPath (TEXT (".") );
 
116
 
 
117
#ifdef NUX_OS_LINUX
 
118
    m_FilePath.AddSearchPath (TEXT (PKGDATADIR"/UITextures") );
 
119
#else
 
120
    m_FilePath.AddSearchPath (TEXT ("./Data/UITextures") );
 
121
    m_FilePath.AddSearchPath (TEXT ("../Data/UITextures") );
 
122
    m_FilePath.AddSearchPath (TEXT ("../../Data/UITextures") );
 
123
#endif
 
124
    std::string file_search = XMLUIFile;
 
125
    NString painter_filename = m_FilePath.GetFile (file_search.c_str() );
 
126
 
 
127
    if (painter_filename == "")
 
128
    {
 
129
      printf (TEXT ("Unable to locate %s ...\n"), file_search.c_str() );
 
130
      return false;
 
131
    }
 
132
 
 
133
    TiXmlDocument doc (painter_filename.GetTCharPtr() );
 
134
    doc.LoadFile();
 
135
    TiXmlHandle docHandle ( &doc );
 
136
    TiXmlElement *data = docHandle.FirstChild ("PaintData").Element();
 
137
    TiXmlElement *image = 0;
 
138
 
 
139
    for (image = data->FirstChildElement ("Image"); image; image = image->NextSiblingElement ("Image") )
 
140
    {
 
141
      ArchiveTextureData *pimage = new ArchiveTextureData;
 
142
      Memset (pimage, 0, sizeof (ArchiveTextureData) );
 
143
 
 
144
      const char *StyleName = image->Attribute ("style");
 
145
 
 
146
      pimage->Style = StyleName;
 
147
 
 
148
      // If the attributes border_left, border_right, border_top, border_bottom are not present, assume they are equal to 0;
 
149
      pimage->border_left = pimage->border_right = pimage->border_top = pimage->border_bottom = 0;
 
150
 
 
151
      image->Attribute ("border_left", &pimage->border_left);
 
152
      image->Attribute ("border_right", &pimage->border_right);
 
153
      image->Attribute ("border_top",  &pimage->border_top);
 
154
      image->Attribute ("border_bottom", &pimage->border_bottom);
 
155
 
 
156
 
 
157
      const char *draw_borders_only = image->Attribute ("border_only");
 
158
 
 
159
      if (draw_borders_only == 0)
 
160
      {
 
161
        pimage->draw_borders_only = true;
 
162
      }
 
163
      else
 
164
      {
 
165
        if (strcmp ("false", draw_borders_only) == 0)
 
166
        {
 
167
          pimage->draw_borders_only = false;
 
168
        }
 
169
        else
 
170
        {
 
171
          pimage->draw_borders_only = true;
 
172
        }
 
173
      }
 
174
 
 
175
      const char *filename = image->Attribute ("Name");
 
176
 
 
177
      NString filepath = m_FilePath.GetFile (filename);
 
178
 
 
179
      pimage->SourceFile = filename;
 
180
 
 
181
      if (filepath == TEXT ("") )
 
182
      {
 
183
        pimage->BaseTexture = 0;
 
184
      }
 
185
      else
 
186
      {
 
187
        pimage->BaseTexture = LoadImageFile (filepath.GetTCharPtr() );
 
188
      }
 
189
 
 
190
      pimage->ArchiveOffset = 0;
 
191
      ArchTexArray.push_back (pimage);
 
192
    }
 
193
 
 
194
    return true;
 
195
  }
 
196
 
 
197
// Archive only 2D texture. Do not archive Volumes or Cubemaps
 
198
  bool CreateUITextureArchive (const TCHAR *XMLUIFile, const TCHAR *ArchiveName)
 
199
  {
 
200
    std::vector<ArchiveTextureData *> ArchTexArray;
 
201
 
 
202
    if (!LoadXMLUITextures (XMLUIFile, ArchTexArray) )
 
203
      return false;
 
204
 
 
205
    NSerializer *fileStream = GFileManager.CreateFileWriter (ArchiveName, NSerializer::Read | NSerializer::Write | NSerializer::OverWriteReadOnly);
 
206
 
 
207
    fileStream->Seek (0, NSerializer::SeekStart);
 
208
 
 
209
    t_s64 OFFSET = 0;
 
210
    int numtexture = ArchTexArray.size();
 
211
 
 
212
    unsigned int FileTag = UITEXTUREARCHIVETAG;  // inalogic user interface texture archive
 
213
    unsigned int FileVersion = UITEXTUREARCHIVEVERSION;  // inalogic user interface texture archive
 
214
 
 
215
    // write tag
 
216
    fileStream->Serialize ( (char *) &FileTag,     sizeof (FileTag) );
 
217
    OFFSET += sizeof (FileTag);
 
218
    fileStream->Serialize ( (char *) &FileVersion,     sizeof (FileVersion) );
 
219
    OFFSET += sizeof (FileVersion);
 
220
 
 
221
    // write num textures
 
222
    fileStream->Serialize ( (char *) &numtexture,     sizeof (numtexture) );
 
223
    OFFSET += sizeof (numtexture);
 
224
 
 
225
    for (int i = 0; i < numtexture; i++)
 
226
    {
 
227
      fileStream->Serialize ( (char *) TCHAR_TO_ANSI (ArchTexArray[i]->Style.GetTCharPtr() ), (t_u32) ArchTexArray[i]->Style.Length() + 1);
 
228
      OFFSET += ArchTexArray[i]->Style.Length() + 1;
 
229
      fileStream->Serialize ( (char *) TCHAR_TO_ANSI (ArchTexArray[i]->SourceFile.GetTCharPtr() ), (t_u32) ArchTexArray[i]->SourceFile.Length() + 1);
 
230
      OFFSET += ArchTexArray[i]->SourceFile.Length() + 1;
 
231
 
 
232
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->border_left),     sizeof (ArchTexArray[i]->border_left) );
 
233
      OFFSET += sizeof (ArchTexArray[i]->border_left);
 
234
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->border_right),     sizeof (ArchTexArray[i]->border_right) );
 
235
      OFFSET += sizeof (ArchTexArray[i]->border_right);
 
236
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->border_top),     sizeof (ArchTexArray[i]->border_top) );
 
237
      OFFSET += sizeof (ArchTexArray[i]->border_top);
 
238
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->border_bottom),     sizeof (ArchTexArray[i]->border_bottom) );
 
239
      OFFSET += sizeof (ArchTexArray[i]->border_bottom);
 
240
 
 
241
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->ArchiveOffset), sizeof (ArchTexArray[i]->ArchiveOffset) );
 
242
      OFFSET += sizeof (ArchTexArray[i]->ArchiveOffset);
 
243
    }
 
244
 
 
245
    unsigned int NumArchived = 0;
 
246
 
 
247
    for (int i = 0; i < numtexture; i++)
 
248
    {
 
249
#ifdef NUX_OS_LINUX
 
250
      NFileName Filename (TEXT (PKGDATADIR"/UITextures") );
 
251
#else
 
252
      NFileName Filename (TEXT ("../../Data/UITextures/") );
 
253
#endif
 
254
      Filename += ArchTexArray[i]->SourceFile.GetTCharPtr();
 
255
      NBitmapData *BaseTexture = LoadImageFile (Filename.GetTCharPtr() );
 
256
 
 
257
      if (BaseTexture)
 
258
      {
 
259
        TextureArchiveAdd_ver_0_0_1 (fileStream, BaseTexture, ArchTexArray[i]->SourceFile.GetTCharPtr(), OFFSET);
 
260
        ++NumArchived;
 
261
        ArchTexArray[i]->ArchiveOffset = OFFSET;
 
262
      }
 
263
      else
 
264
      {
 
265
        ArchTexArray[i]->ArchiveOffset = 0xFFFFFFFF;
 
266
      }
 
267
    }
 
268
 
 
269
    // Second pass with the header where we write the offset to the texture data
 
270
    fileStream->Seek (sizeof (FileTag) + sizeof (FileVersion), NSerializer::SeekStart);
 
271
    // Write the true number of textures that has been archived.
 
272
    fileStream->Serialize ( (char *) &NumArchived,     sizeof (NumArchived) );
 
273
 
 
274
    for (int i = 0; i < numtexture; i++)
 
275
    {
 
276
      fileStream->Serialize ( (char *) TCHAR_TO_ANSI (ArchTexArray[i]->Style.GetTCharPtr() ), (t_u32) ArchTexArray[i]->Style.Length() + 1);
 
277
      fileStream->Serialize ( (char *) TCHAR_TO_ANSI (ArchTexArray[i]->SourceFile.GetTCharPtr() ), (t_u32) ArchTexArray[i]->SourceFile.Length() + 1);
 
278
 
 
279
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->border_left),   sizeof (ArchTexArray[i]->border_left) );
 
280
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->border_right),  sizeof (ArchTexArray[i]->border_right) );
 
281
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->border_top),    sizeof (ArchTexArray[i]->border_top) );
 
282
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->border_bottom), sizeof (ArchTexArray[i]->border_bottom) );
 
283
 
 
284
      int ddd = ArchTexArray[i]->ArchiveOffset;
 
285
      fileStream->Serialize ( (char *) & (ArchTexArray[i]->ArchiveOffset), sizeof (ArchTexArray[i]->ArchiveOffset) );
 
286
      ddd = fileStream->Tell();
 
287
    }
 
288
 
 
289
    fileStream->Close();
 
290
    return true;
 
291
  }
 
292
 
 
293
  bool LoadUIArchive (const TCHAR *ArchiveName, std::vector<ArchiveTextureData *>& ArchTexArray)
 
294
  {
 
295
    NSerializer *fileStream = GFileManager.CreateFileReader (TCHAR_TO_ANSI (ArchiveName), NSerializer::Read | NSerializer::Write);
 
296
 
 
297
    fileStream->Seek (0, NSerializer::SeekStart);
 
298
 
 
299
    int OFFSET = 0;
 
300
    int numtexture = 0;
 
301
 
 
302
    unsigned int FileTag;
 
303
    unsigned int FileVersion;
 
304
    fileStream->Serialize ( (char *) &FileTag, sizeof (FileTag) );
 
305
    fileStream->Serialize ( (char *) &FileVersion, sizeof (FileVersion) );
 
306
 
 
307
    if (FileTag != UITEXTUREARCHIVETAG)
 
308
    {
 
309
      nuxAssertMsg (0, TEXT ("[ReadArchive] File: %s is not a texture archive."), ArchiveName);
 
310
      return false;
 
311
    }
 
312
 
 
313
    fileStream->Serialize ( (char *) &numtexture, sizeof (numtexture) );
 
314
    OFFSET = fileStream->Tell();
 
315
 
 
316
    char CharBuffer[2048];
 
317
 
 
318
    for (int i = 0; i < numtexture; i++)
 
319
    {
 
320
      int c = 0;
 
321
 
 
322
      do
 
323
      {
 
324
        fileStream->Serialize (&CharBuffer[c], 1);
 
325
        c++;
 
326
      }
 
327
      while (CharBuffer[c-1] != 0);
 
328
 
 
329
      CharBuffer[c] = 0; // add null terminating char
 
330
      NString Style = CharBuffer;
 
331
 
 
332
      c = 0;
 
333
 
 
334
      do
 
335
      {
 
336
        fileStream->Serialize (&CharBuffer[c], 1);
 
337
        c++;
 
338
      }
 
339
      while (CharBuffer[c-1] != 0);
 
340
 
 
341
      CharBuffer[c] = 0; // add null terminating char
 
342
      NString SourceFile = CharBuffer;
 
343
 
 
344
      unsigned int border_left;
 
345
      unsigned int border_right;
 
346
      unsigned int border_top;
 
347
      unsigned int border_bottom;
 
348
 
 
349
      fileStream->Serialize ( (char *) &border_left,   sizeof (border_left) );
 
350
      fileStream->Serialize ( (char *) &border_right,  sizeof (border_right) );
 
351
      fileStream->Serialize ( (char *) &border_top,    sizeof (border_top) );
 
352
      fileStream->Serialize ( (char *) &border_bottom, sizeof (border_bottom) );
 
353
 
 
354
 
 
355
      unsigned int DataOffset;
 
356
      fileStream->Serialize ( (char *) &DataOffset, sizeof (DataOffset) );
 
357
 
 
358
      int CurrentPos = fileStream->Tell();
 
359
 
 
360
      //nuxDebugMsg(TEXT("%s - %s"), Style.GetTCharPtr(), SourceFile.GetTCharPtr());
 
361
      if (DataOffset == 0xFFFFFFFF)
 
362
      {
 
363
        nuxDebugMsg (TEXT ("[LoadUIArchive] Can't find file %s in UI archive %s. Skipping..."), SourceFile.GetTCharPtr(), ArchiveName);
 
364
      }
 
365
 
 
366
      NBitmapData *BaseTexture = TextureArchiveLoad_ver_0_0_1 (fileStream, DataOffset);
 
367
 
 
368
      ArchiveTextureData *pimage = new ArchiveTextureData;
 
369
      pimage->SourceFile = SourceFile;
 
370
      pimage->Style = Style;
 
371
      pimage->BaseTexture = BaseTexture;
 
372
      pimage->border_left = border_left;
 
373
      pimage->border_right = border_right;
 
374
      pimage->border_top = border_top;
 
375
      pimage->border_bottom = border_bottom;
 
376
 
 
377
      ArchTexArray.push_back (pimage);
 
378
 
 
379
      // Go back in the header section
 
380
      fileStream->Seek (CurrentPos, NSerializer::SeekStart);
 
381
    }
 
382
 
 
383
    fileStream->Close();
 
384
    return true;
 
385
  }
 
386
 
 
387
//NTextureArchiveManager ////////////////////////////////////////////
 
388
 
 
389
  NTextureArchiveManager::NTextureArchiveManager()
 
390
    :   m_isLoaded (false)
 
391
    ,   m_FileStream (0)
 
392
    ,   m_NumberOfTextures (0)
 
393
  {
 
394
 
 
395
  }
 
396
 
 
397
  NTextureArchiveManager::~NTextureArchiveManager()
 
398
  {
 
399
    if (m_FileStream)
 
400
    {
 
401
      m_FileStream->Close();
 
402
      delete m_FileStream;
 
403
    }
 
404
  }
 
405
 
 
406
  bool NTextureArchiveManager::CreateTextureArchiveFile (const TCHAR *TextureArchiveFilename)
 
407
  {
 
408
#define CHECK_ITX_WRITE_ERROR /*if(m_FileStream.bad()) {m_FileStream->close(); nuxAssertMsg(0, TEXT("[CreateTextureArchiveFile] Write Error.")); return false;}*/
 
409
 
 
410
    m_FileStream = GFileManager.CreateFileWriter (TCHAR_TO_ANSI (TextureArchiveFilename), NSerializer::Read | NSerializer::Write);
 
411
 
 
412
    if (!m_FileStream)
 
413
    {
 
414
      nuxAssertMsg (0, TEXT ("[CreateTextureArchiveFile] Can't open file: %s"), TextureArchiveFilename);
 
415
      m_isLoaded = false;
 
416
      return false;
 
417
    }
 
418
 
 
419
    m_FileStream->Seek (0, NSerializer::SeekStart);
 
420
    unsigned int ArchiveTag = TEXTUREARCHIVETAG;
 
421
    unsigned int ArchiveFormatVersion = TEXTUREARCHIVEVERSION;
 
422
    m_NumberOfTextures = 0;
 
423
    NTimeStamp TimeStamp;
 
424
    TimeStamp.GetTime();
 
425
 
 
426
    m_FileStream->Serialize ( (char *) &ArchiveTag,            sizeof (ArchiveTag) );
 
427
    CHECK_ITX_WRITE_ERROR;
 
428
    m_FileStream->Serialize ( (char *) &ArchiveFormatVersion,  sizeof (ArchiveFormatVersion) );
 
429
    CHECK_ITX_WRITE_ERROR;
 
430
 
 
431
    // Date Created
 
432
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Year,   sizeof (TimeStamp.m_Year) );
 
433
    CHECK_ITX_WRITE_ERROR;
 
434
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Month,  sizeof (TimeStamp.m_Month) );
 
435
    CHECK_ITX_WRITE_ERROR;
 
436
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Day,    sizeof (TimeStamp.m_Day) );
 
437
    CHECK_ITX_WRITE_ERROR;
 
438
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Hour,   sizeof (TimeStamp.m_Hour) );
 
439
    CHECK_ITX_WRITE_ERROR;
 
440
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Minute, sizeof (TimeStamp.m_Minute) );
 
441
    CHECK_ITX_WRITE_ERROR;
 
442
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Second, sizeof (TimeStamp.m_Second) );
 
443
    CHECK_ITX_WRITE_ERROR;
 
444
    m_FileStream->Serialize ( (char *) &TimeStamp.m_MicroSecond, sizeof (TimeStamp.m_MicroSecond) );
 
445
    CHECK_ITX_WRITE_ERROR;
 
446
 
 
447
    // Date Modified
 
448
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Year,   sizeof (TimeStamp.m_Year) );
 
449
    CHECK_ITX_WRITE_ERROR;
 
450
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Month,  sizeof (TimeStamp.m_Month) );
 
451
    CHECK_ITX_WRITE_ERROR;
 
452
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Day,    sizeof (TimeStamp.m_Day) );
 
453
    CHECK_ITX_WRITE_ERROR;
 
454
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Hour,   sizeof (TimeStamp.m_Hour) );
 
455
    CHECK_ITX_WRITE_ERROR;
 
456
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Minute, sizeof (TimeStamp.m_Minute) );
 
457
    CHECK_ITX_WRITE_ERROR;
 
458
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Second, sizeof (TimeStamp.m_Second) );
 
459
    CHECK_ITX_WRITE_ERROR;
 
460
    m_FileStream->Serialize ( (char *) &TimeStamp.m_MicroSecond, sizeof (TimeStamp.m_MicroSecond) );
 
461
    CHECK_ITX_WRITE_ERROR;
 
462
 
 
463
    // Number of Textures in the archives
 
464
    m_FileStream->Serialize ( (char *) &m_NumberOfTextures,        sizeof (m_NumberOfTextures) );
 
465
    CHECK_ITX_WRITE_ERROR;
 
466
 
 
467
 
 
468
    m_CurrentTextureArchive = TextureArchiveFilename;
 
469
    m_isLoaded = true;
 
470
#undef CHECK_ITX_WRITE_ERROR
 
471
    return true;
 
472
  }
 
473
 
 
474
  bool NTextureArchiveManager::AddTextureToArchive (const TCHAR *SourceFolder, const TCHAR *TextureFilename)
 
475
  {
 
476
    if (!m_FileStream)
 
477
    {
 
478
      nuxAssertMsg (0, TEXT ("[NTextureArchiveManager::AddTextureToArchive] Cannot add texture to archive. Load texture archive first.") );
 
479
      return false;
 
480
    }
 
481
 
 
482
    NFileName Filename;
 
483
 
 
484
    if ( (SourceFolder != 0) && (NString (SourceFolder) != NString (TEXT ("") ) ) )
 
485
    {
 
486
      Filename = SourceFolder;
 
487
      Filename.RemoveBackSlashAtEnd();
 
488
      Filename.RemoveSlashAtEnd();
 
489
      Filename.AddSlashAtEnd();
 
490
    }
 
491
 
 
492
    Filename += TextureFilename;
 
493
    NBitmapData *BaseTexture = LoadImageFile (Filename.GetTCharPtr() );
 
494
 
 
495
    if (BaseTexture == 0)
 
496
      return false;
 
497
 
 
498
    t_s64 Offset = 0;
 
499
    TextureArchiveAdd_ver_0_0_1 (m_FileStream, BaseTexture, TextureFilename, Offset);
 
500
    m_NumberOfTextures++;
 
501
 
 
502
    // Update the "last modified" date and the number of textures in the archive.
 
503
    m_FileStream->Seek (TEXTUREACHIVEHEADER_SIZE, NSerializer::SeekStart);
 
504
 
 
505
    NTimeStamp TimeStamp;
 
506
    TimeStamp.GetTime();
 
507
 
 
508
    // Date Modified
 
509
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Year,   sizeof (TimeStamp.m_Year) );
 
510
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Month,  sizeof (TimeStamp.m_Month) );
 
511
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Day,    sizeof (TimeStamp.m_Day) );
 
512
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Hour,   sizeof (TimeStamp.m_Hour) );
 
513
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Minute, sizeof (TimeStamp.m_Minute) );
 
514
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Second, sizeof (TimeStamp.m_Second) );
 
515
    m_FileStream->Serialize ( (char *) &TimeStamp.m_MicroSecond, sizeof (TimeStamp.m_MicroSecond) );
 
516
 
 
517
    // Number of Textures in the archives
 
518
    m_FileStream->Serialize ( (char *) &m_NumberOfTextures,        sizeof (m_NumberOfTextures) );
 
519
 
 
520
    return true;
 
521
  }
 
522
 
 
523
  bool NTextureArchiveManager::LoadTextureArchiveFile (const TCHAR *Filename)
 
524
  {
 
525
    return true;
 
526
  }
 
527
 
 
528
  bool NTextureArchiveManager::CloseTextureArchiveFile()
 
529
  {
 
530
    if (m_FileStream)
 
531
      m_FileStream->Close();
 
532
 
 
533
    NUX_SAFE_DELETE (m_FileStream);
 
534
    m_CurrentTextureArchive = TEXT ("");
 
535
    m_isLoaded = false;
 
536
    return true;
 
537
  }
 
538
 
 
539
  bool NTextureArchiveManager::PointToFirstTexture()
 
540
  {
 
541
    nuxAssert (m_FileStream);
 
542
 
 
543
    if (m_FileStream == 0)
 
544
      return false;
 
545
 
 
546
    m_FileStream->Seek (0, NSerializer::SeekStart);
 
547
    unsigned int ArchiveTag = 0;
 
548
    unsigned int ArchiveFormatVersion = 0;
 
549
    //unsigned int NumTextures = 0;
 
550
    NTimeStamp TimeStamp;
 
551
 
 
552
 
 
553
    m_FileStream->Serialize ( (char *) &ArchiveTag,            sizeof (ArchiveTag) ); // should be 0x20787469
 
554
    m_FileStream->Serialize ( (char *) &ArchiveFormatVersion,  sizeof (ArchiveFormatVersion) );
 
555
    nuxDebugMsg (TEXT ("File Tag:         %c%c%c%c"),
 
556
                 (ArchiveTag & 0xFF),
 
557
                 (ArchiveTag & 0xFF00) >> 8,
 
558
                 (ArchiveTag & 0xFF0000) >> 16,
 
559
                 (ArchiveTag & 0xFF000000) >> 24);
 
560
    nuxDebugMsg (TEXT ("File Version:     %c.%c.%c.%c"),
 
561
                 (ArchiveFormatVersion & 0xFF),
 
562
                 (ArchiveFormatVersion & 0xFF00) >> 8,
 
563
                 (ArchiveFormatVersion & 0xFF0000) >> 16,
 
564
                 (ArchiveFormatVersion & 0xFF000000) >> 24);
 
565
 
 
566
    // Date Created
 
567
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Year,   sizeof (TimeStamp.m_Year) );
 
568
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Month,  sizeof (TimeStamp.m_Month) );
 
569
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Day,    sizeof (TimeStamp.m_Day) );
 
570
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Hour,   sizeof (TimeStamp.m_Hour) );
 
571
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Minute, sizeof (TimeStamp.m_Minute) );
 
572
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Second, sizeof (TimeStamp.m_Second) );
 
573
    m_FileStream->Serialize ( (char *) &TimeStamp.m_MicroSecond, sizeof (TimeStamp.m_MicroSecond) );
 
574
    nuxDebugMsg (TEXT ("File created on:  %d/%d/%d at %d:%d:%d"), TimeStamp.m_Year, TimeStamp.m_Month, TimeStamp.m_Day, TimeStamp.m_Hour, TimeStamp.m_Minute, TimeStamp.m_Second);
 
575
 
 
576
    // Date Modified
 
577
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Year,   sizeof (TimeStamp.m_Year) );
 
578
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Month,  sizeof (TimeStamp.m_Month) );
 
579
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Day,    sizeof (TimeStamp.m_Day) );
 
580
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Hour,   sizeof (TimeStamp.m_Hour) );
 
581
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Minute, sizeof (TimeStamp.m_Minute) );
 
582
    m_FileStream->Serialize ( (char *) &TimeStamp.m_Second, sizeof (TimeStamp.m_Second) );
 
583
    m_FileStream->Serialize ( (char *) &TimeStamp.m_MicroSecond, sizeof (TimeStamp.m_MicroSecond) );
 
584
    nuxDebugMsg (TEXT ("Last modified on: %d/%d/%d at %d:%d:%d"), TimeStamp.m_Year, TimeStamp.m_Month, TimeStamp.m_Day, TimeStamp.m_Hour, TimeStamp.m_Minute, TimeStamp.m_Second);
 
585
 
 
586
    // Number of Textures in the archives
 
587
    m_FileStream->Serialize ( (char *) &m_NumberOfTextures,        sizeof (m_NumberOfTextures) );
 
588
 
 
589
    return true;
 
590
  }
 
591
 
 
592
  void NTextureArchiveManager::PrintArchiveContent (const TCHAR *TextureArchiveFilename)
 
593
  {
 
594
    if (m_FileStream)
 
595
      m_FileStream->Close();
 
596
 
 
597
    m_FileStream = GFileManager.CreateFileReader (TextureArchiveFilename, NSerializer::NoOverWrite | NSerializer::Read | NSerializer::Write);
 
598
 
 
599
 
 
600
    PointToFirstTexture();
 
601
 
 
602
    for (unsigned int i = 0; i < m_NumberOfTextures; i++)
 
603
    {
 
604
      TextureArchiveInfo_ver_0_0_1 TextureArchiveInfo;
 
605
      TextureArchiveGetInfo_ver_0_0_1 (m_FileStream, TextureArchiveInfo);
 
606
      nuxDebugMsg (TEXT ("File:     %s"), ANSI_TO_TCHAR (TextureArchiveInfo.Name.GetTCharPtr() ) );
 
607
      nuxDebugMsg (TEXT ("---------------------------------------------") );
 
608
      nuxDebugMsg (TEXT ("      Type:       %s"), (TextureArchiveInfo.Type == ARCH_TEXTURE2D) ? TEXT ("Texture2D") :
 
609
                   (TextureArchiveInfo.Type == ARCH_CUBEMAP) ? TEXT ("Cubemap Texture") :
 
610
                   (TextureArchiveInfo.Type == ARCH_VOLUME) ? TEXT ("Volume Texture") :
 
611
                   TEXT ("Unknown Texture")  );
 
612
      nuxDebugMsg (TEXT ("      Format:     %s"), GPixelFormats[TextureArchiveInfo.Format].Name);
 
613
      nuxDebugMsg (TEXT ("      Width:      %d"), TextureArchiveInfo.Width);
 
614
      nuxDebugMsg (TEXT ("      Height:     %d"), TextureArchiveInfo.Height);
 
615
      nuxDebugMsg (TEXT ("      Depth:      %d"), TextureArchiveInfo.Depth);
 
616
      nuxDebugMsg (TEXT ("      NumMipmap:  %d"), TextureArchiveInfo.NumMipmap);
 
617
      nuxDebugMsg (TEXT ("      Size:       %d"), TextureArchiveInfo.Size);
 
618
    }
 
619
 
 
620
    CloseTextureArchiveFile();
 
621
  }
 
622
 
 
623
 
 
624
  void NTextureArchiveManager::TraverseTextures (const TCHAR *TextureArchiveFilename)
 
625
  {
 
626
    if (m_FileStream)
 
627
      m_FileStream->Close();
 
628
 
 
629
    m_FileStream = GFileManager.CreateFileReader (TextureArchiveFilename, NSerializer::NoOverWrite | NSerializer::Read | NSerializer::Write);
 
630
 
 
631
    PointToFirstTexture();
 
632
 
 
633
    for (unsigned int i = 0; i < m_NumberOfTextures; i++)
 
634
    {
 
635
      unsigned int Offset = m_FileStream->Tell();
 
636
      TextureArchiveLoad_ver_0_0_1 (m_FileStream, Offset);
 
637
    }
 
638
 
 
639
    CloseTextureArchiveFile();
 
640
  }
 
641
 
 
642
  NBitmapData *NTextureArchiveManager::LoadBitmapArchive (const TCHAR *TextureArchiveFilename, const TCHAR *Filename)
 
643
  {
 
644
    if (m_FileStream)
 
645
      m_FileStream->Close();
 
646
 
 
647
    m_FileStream = GFileManager.CreateFileReader (TextureArchiveFilename, NSerializer::NoOverWrite | NSerializer::Read | NSerializer::Write);
 
648
 
 
649
    PointToFirstTexture();
 
650
 
 
651
    for (unsigned int i = 0; i < m_NumberOfTextures; i++)
 
652
    {
 
653
      TextureArchiveInfo_ver_0_0_1 TextureArchiveInfo;
 
654
      TextureArchiveGetInfo_ver_0_0_1 (m_FileStream, TextureArchiveInfo);
 
655
 
 
656
      if (Stricmp (Filename, TextureArchiveInfo.Name.GetTCharPtr() ) == 0)
 
657
      {
 
658
        return TextureArchiveLoad_ver_0_0_1 (m_FileStream, TextureArchiveInfo.FilePointer);
 
659
      }
 
660
    }
 
661
 
 
662
    CloseTextureArchiveFile();
 
663
    return 0;
 
664
  }
 
665
 
 
666
 
 
667
}