prj/cam/src/render/texsave.cpp

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6 // $Header: r:/t2repos/thief2/src/render/texsave.cpp,v 1.4 1998/10/05 17:28:29 mahk Exp $
   7 // editorlevel file format and save/load code
   8
   9 //  Tag: Families      (FAMILY)
  10 //    contains a header and then a list of the current families
  11 //  Tag: Textures      (TXLIST)
  12 //    resname memory block for the textures in memory
  13
  14 #include <lg.h>
  15 #include <mprintf.h>
  16 #include <timer.h>
  17
  18 #include <lresdisk.h>
  19
  20 #include <tagfile.h>
  21 #include <vernum.h>
  22
  23 #include <family.h>
  24 #include <csg.h>
  25
  26 #include <status.h>
  27 #include <texsave.h>
  28 #include <texprop.h>
  29
  30 // Must be last header
  31 #include <dbmem.h>
  32
  33
  34 static BOOL texsave_enabled = TRUE;
  35
  36 /////////////////////////
  37 // generic block header stuff for lists of same size records
  38
  39 // put at the top of each string block
  40 typedef struct {
  41    int size_per;
  42    int elem_cnt;
  43 } blockHeader;
  44
  45 // SAVE
  46 static BOOL _saveGenericBlocked(ITagFile *file, blockHeader *hdr, void *mem, TagFileTag *tag, TagVersion *ver)
  47 {
  48    int write_sz;
  49    BOOL rv=FALSE;
  50
  51    if (file->OpenBlock(tag,ver)!=S_OK) return FALSE;
  52    write_sz=hdr->elem_cnt*hdr->size_per;
  53    if (file->Write((char*)hdr,sizeof(blockHeader))==sizeof(blockHeader))
  54       if (file->Write((char*)mem,write_sz)==write_sz)
  55          rv=TRUE;
  56    file->CloseBlock();
  57    return rv;
  58 }
  59
  60 // LOAD
  61 static void *_loadGenericBlocked(ITagFile *file, TagFileTag *tag, TagVersion *ver, TagVersion *newver, blockHeader *hdr)
  62 {
  63    char *mem=NULL;
  64
  65    if (file->OpenBlock(tag,newver)!=S_OK) return NULL;
  66    if (file->Read((char*)hdr,sizeof(blockHeader))==sizeof(blockHeader))
  67    {
  68       int read_sz=hdr->elem_cnt*hdr->size_per;
  69       mem=(char*)Malloc(read_sz);
  70       if (mem!=NULL)
  71          if (file->Read(mem,read_sz)!=read_sz)
  72          {
  73             Free(mem);    // we are gonna return failure
  74             mem=NULL;     // but lets free our memory block first
  75          }
  76    }
  77    file->CloseBlock();
  78    return mem;
  79 }
  80
  81 /////////////////////////
  82 // Family List:
  83 static TagVersion FamilyVer={1,0};
  84 static TagFileTag FamilyTag={"FAMILY"};
  85
  86 // SAVE
  87 static BOOL _saveAllFamilies(ITagFile *file)
  88 {
  89    blockHeader theHdr;
  90    void *mem=family_name_block_build(&theHdr.elem_cnt,&theHdr.size_per);
  91    if (mem)
  92    {
  93       BOOL rv=_saveGenericBlocked(file,&theHdr,mem,&FamilyTag,&FamilyVer);
  94       Free(mem);  // allocated by block build
  95       return rv;
  96    }
  97    return FALSE;
  98 }
  99
 100 // LOAD
 101 static BOOL _loadAllFamilies(ITagFile *file)
 102 {
 103    TagVersion LocalVer=FamilyVer;
 104    blockHeader theHdr;
 105    void *mem=NULL;
 106
 107    mem=_loadGenericBlocked(file,&FamilyTag,&FamilyVer,&LocalVer,&theHdr);
 108    if (mem!=NULL)
 109    {
 110       BOOL rv=family_name_block_parse(theHdr.elem_cnt,theHdr.size_per,mem);
 111       Free(mem);
 112       return rv;
 113    }
 114    return FALSE;
 115 }
 116
 117 /////////////////////////
 118 // Textures:
 119 static TagVersion TextureVer={1,0};
 120 static TagFileTag TextureTag={"TXLIST"};
 121
 122 // SAVE
 123 static BOOL _saveAllTextures(ITagFile *file)
 124 {
 125    void *mem=familyDiskTexBlockBuild();
 126    if (mem!=NULL)
 127    {
 128       BOOL rv;
 129       int size=ResBlockSize(mem);
 130       if (file->OpenBlock(&TextureTag,&TextureVer)!=S_OK) return FALSE;
 131       rv=(file->Write((char*)mem,size)==size);
 132       file->CloseBlock();
 133       Free(mem);
 134       return rv;
 135    }
 136    return FALSE;
 137 }
 138
 139 // LOAD
 140 static BOOL _loadAllTextures(ITagFile *file)
 141 {
 142    TagVersion LocalVer=TextureVer;
 143    BOOL rv=FALSE;
 144    void *mem;
 145    int size;
 146
 147    if (file->OpenBlock(&TextureTag,&LocalVer)!=S_OK) return FALSE;
 148    size=file->BlockSize(file->CurrentBlock());
 149    mem=(void *)Malloc(size);
 150    rv=(file->Read((char *)mem,size)==size);
 151    Assrt(size==ResBlockSize(mem));
 152    file->CloseBlock();
 153    if (rv)           // successfully read the data, now lets try to load
 154       rv=familyDiskTexBlockLoad(mem);  // the resnameblock in for real...
 155    Free(mem);  // since we malloced it and dont need it any more
 156    return rv;
 157 }
 158
 159
 160
 161 ////////////////////////
 162 // MAIN STUFF
 163 // these are the actual calls made by the outside world
 164
 165 BOOL texture_Save(ITagFile *file)
 166 {
 167    if (!texsave_enabled)
 168       return FALSE;
 169
 170    BOOL rv = FALSE;
 171    rv |= _saveAllFamilies(file);
 172    rv |= _saveAllTextures(file);
 173    if (!rv)
 174       Warning(("Some texture component of the file saved incorrectly"));
 175    return rv;
 176 }
 177
 178 BOOL texture_Load(ITagFile *file)
 179 {
 180    if (!texsave_enabled)
 181       return FALSE;
 182
 183    BOOL rv = FALSE;
 184
 185    rv |= _loadAllFamilies(file);
 186    rv |= _loadAllTextures(file);
 187 #ifdef COMPARE_RES
 188    // The theory is that we don't need this any more...
 189    txtprop_load();
 190 #endif
 191    if (texmemSpaceOverrun())
 192    {
 193       mprintf("HEY! YOU! Out of Texture Slots!\n");
 194       texmemSpaceOverrun()=0; // well, reset it, at least
 195    }  // hateful syntax, i know, sorry, will fix someday - dc
 196
 197    if (!rv)
 198       Warning(("Some texture component of the file loaded incorrectly"));
 199
 200    return rv;
 201 }
 202
 203
 204 BOOL texture_EnableSaveLoad(BOOL enabled)
 205 {
 206    BOOL old = texsave_enabled;
 207    texsave_enabled= enabled;
 208    return old;
 209 }