plugins/archivewad/archive.cpp

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #include "archive.h"
  23
  24 #include "idatastream.h"
  25 #include "cmdlib.h"
  26 #include "bytestreamutils.h"
  27 #include <algorithm>
  28 #include "stream/filestream.h"
  29
  30 #include "iarchive.h"
  31
  32 #include "archivelib.h"
  33
  34 #include "plugin.h"
  35
  36 #include <map>
  37 #include "string/string.h"
  38
  39 #include "wad.h"
  40
  41 class WadArchive : public Archive
  42 {
  43   class wad_record_t
  44   {
  45   public:
  46     wad_record_t(unsigned int position, unsigned int stream_size, unsigned int file_size)
  47       : m_position(position), m_stream_size(stream_size), m_file_size(file_size)
  48     {}
  49     unsigned int m_position;
  50     unsigned int m_stream_size;
  51     unsigned int m_file_size;
  52   };
  53
  54   enum EWadVersion
  55   {
  56     eNotValid,
  57     eWAD2,
  58     eWAD3,
  59   };
  60
  61   typedef std::map<CopiedString, wad_record_t, StringLessNoCase> files_t;
  62   files_t m_files;
  63   CopiedString m_name;
  64   FileInputStream m_wadfile;
  65
  66   EWadVersion wad_version(const char* identification)
  67   {
  68     if(strncmp(identification, "WAD2", 4) == 0)
  69       return eWAD2;
  70     if(strncmp(identification, "WAD3", 4) == 0)
  71       return eWAD3;
  72     return eNotValid;
  73   }
  74
  75   const char* type_for_version(EWadVersion version)
  76   {
  77     switch(version)
  78     {
  79     case eWAD2:
  80       return ".mip";
  81     case eWAD3:
  82       return ".hlw";
  83     default:
  84       break;
  85     }
  86     return "";
  87   }
  88
  89   int miptex_type_for_version(EWadVersion version)
  90   {
  91     switch(version)
  92     {
  93     case eWAD2:
  94       return TYP_MIPTEX;
  95     case eWAD3:
  96       return 67;
  97     default:
  98       break;
  99     }
 100     return -1;
 101   }
 102
 103 public:
 104   WadArchive(const char* name)
 105     : m_name(name), m_wadfile(name)
 106   {
 107     if(!m_wadfile.failed())
 108     {
 109       wadinfo_t wadinfo;
 110       istream_read_wadinfo(m_wadfile, wadinfo);
 111
 112       EWadVersion version = wad_version(wadinfo.identification);
 113       int miptexType = miptex_type_for_version(version);
 114
 115       if(version != eNotValid)
 116       {
 117         m_wadfile.seek(wadinfo.infotableofs);
 118
 119         for(int i = 0; i < wadinfo.numlumps; ++i)
 120         {
 121           char buffer[32];
 122           lumpinfo_t lumpinfo;
 123           istream_read_lumpinfo(m_wadfile, lumpinfo);
 124           if(lumpinfo.type == miptexType)
 125           {
 126             strcpy(buffer, "textures/");
 127             strcat(buffer, lumpinfo.name);
 128             strcat(buffer, type_for_version(version));
 129             m_files.insert(files_t::value_type(buffer, wad_record_t(lumpinfo.filepos, lumpinfo.disksize, lumpinfo.size)));
 130           }
 131         }
 132       }
 133     }
 134   }
 135
 136   void release()
 137   {
 138     delete this;
 139   }
 140   ArchiveFile* openFile(const char* name)
 141   {
 142     files_t::iterator i = m_files.find(name);
 143     if(i != m_files.end())
 144     {
 145       return StoredArchiveFile::create(name, m_name.c_str(), i->second.m_position, i->second.m_stream_size, i->second.m_file_size);
 146     }
 147     return 0;
 148   }
 149   virtual ArchiveTextFile* openTextFile(const char* name)
 150   {
 151     files_t::iterator i = m_files.find(name);
 152     if(i != m_files.end())
 153     {
 154       return StoredArchiveTextFile::create(name, m_name.c_str(), i->second.m_position, i->second.m_stream_size);
 155     }
 156     return 0;
 157   }
 158   bool containsFile(const char* name)
 159   {
 160     return m_files.find(name) != m_files.end();
 161   }
 162   void forEachFile(VisitorFunc visitor, const char* root)
 163   {
 164     if(root[0] == '\0')
 165     {
 166       if(visitor.directory("textures/", 1))
 167         return;
 168     }
 169     else if(strcmp(root, "textures/") != 0)
 170     {
 171       return;
 172     }
 173
 174     for(files_t::iterator i = m_files.begin(); i != m_files.end(); ++i)
 175       visitor.file(i->first.c_str());
 176   }
 177 };
 178
 179
 180 Archive* OpenArchive(const char* name)
 181 {
 182   return new WadArchive(name);
 183 }
 184
 185 #if 0
 186
 187 class TestArchive
 188 {
 189   class TestVisitor : public Archive::IVisitor
 190   {
 191   public:
 192     void visit(const char* name)
 193     {
 194       int bleh = 0;
 195     }
 196   };
 197 public:
 198   TestArchive()
 199   {
 200     {
 201     Archive* archive = OpenArchive("");
 202     archive->release();
 203     }
 204     {
 205     Archive* archive = OpenArchive("NONEXISTANTFILE");
 206     archive->release();
 207     }
 208     {
 209     Archive* archive = OpenArchive("c:/quake/id1/quake101.wad");
 210     ArchiveFile* file = archive->openFile("textures/sky1.mip");
 211     if(file != 0)
 212     {
 213       unsigned char* buffer = new unsigned char[file->size()];
 214       file->getInputStream().read((InputStream::byte_type*)buffer, file->size());
 215       delete[] buffer;
 216       file->release();
 217     }
 218     TestVisitor visitor;
 219     archive->forEachFile(Archive::VisitorFunc(&visitor, Archive::eFilesAndDirectories, 1), "");
 220     archive->forEachFile(Archive::VisitorFunc(&visitor, Archive::eFilesAndDirectories, 0), "");
 221     archive->forEachFile(Archive::VisitorFunc(&visitor, Archive::eFilesAndDirectories, 0), "textures/");
 222     archive->forEachFile(Archive::VisitorFunc(&visitor, Archive::eFilesAndDirectories, 1), "textures/");
 223     archive->release();
 224     }
 225   }
 226 };
 227
 228 TestArchive g_test;
 229
 230 #endif