zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2025-01-30 05:10:48 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Roll back filesystem changes. These were causing instabilities in the master branch that were interfering with development.

Browse source
This commit is contained in:
Rachael Alexanderson 2025-01-03 09:02:12 -05:00
parent 786bfa6419
commit f3b0c3ac5e
No known key found for this signature in database
GPG key ID: 26A8ACCE97115EE0
90 changed files with 1352 additions and 1585 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/CMakeLists.txt
View file

@ -1096,7 +1096,6 @@ set (PCH_SOURCES
common/engine/cycler.cpp
common/engine/d_event.cpp
common/engine/date.cpp
common/engine/filesys_doom.cpp
common/engine/stats.cpp
common/engine/sc_man.cpp
common/engine/palettecontainer.cpp
@ -1231,7 +1230,6 @@ set( GAME_SOURCES
common/filesystem/source/file_whres.cpp
common/filesystem/source/file_ssi.cpp
common/filesystem/source/file_hog.cpp
common/filesystem/source/file_hog2.cpp
common/filesystem/source/file_mvl.cpp
common/filesystem/source/file_directory.cpp
common/filesystem/source/resourcefile.cpp

2
src/am_map.cpp
View file

@ -845,7 +845,7 @@ static void AM_ParseArrow(TArray<mline_t> &Arrow, const char *lumpname)
{
const int R = int((8 * PLAYERRADIUS) / 7);
FScanner sc;
int lump = fileSystem.CheckNumForAnyName(lumpname);
int lump = fileSystem.CheckNumForFullName(lumpname, true);
if (lump >= 0)
{
sc.OpenLumpNum(lump);

7
src/common/audio/music/i_music.cpp
View file

@ -53,6 +53,9 @@
#include "s_music.h"
#include "filereadermusicinterface.h"
using namespace FileSys;
void I_InitSoundFonts();
EXTERN_CVAR (Int, snd_samplerate)
@ -185,7 +188,7 @@ static void SetupGenMidi()
static void SetupWgOpn()
{
int lump = fileSystem.FindFile("xg.wopn");
int lump = fileSystem.CheckNumForFullName("xg.wopn");
if (lump < 0)
{
return;
@ -310,7 +313,7 @@ static ZMusic_MidiSource GetMIDISource(const char *fn)
if (src.Compare("*") == 0) src = mus_playing.name;
auto lump = fileSystem.CheckNumForName(src.GetChars(), ns_music);
if (lump < 0) lump = fileSystem.FindFile(src.GetChars());
if (lump < 0) lump = fileSystem.CheckNumForFullName(src.GetChars());
if (lump < 0)
{
Printf("Cannot find MIDI lump %s.\n", src.GetChars());

8
src/common/audio/music/i_soundfont.cpp
View file

@ -298,7 +298,7 @@ FileReader FPatchSetReader::OpenFile(const char *name)
FLumpPatchSetReader::FLumpPatchSetReader(const char *filename)
{
mLumpIndex = fileSystem.FindFile(filename);
mLumpIndex = fileSystem.CheckNumForFullName(filename);
mBasePath = filename;
FixPathSeperator(mBasePath);
@ -314,9 +314,9 @@ FileReader FLumpPatchSetReader::OpenMainConfigFile()
FileReader FLumpPatchSetReader::OpenFile(const char *name)
{
FString path;
if (IsAbsPath(name)) return FileReader(); // no absolute paths in the virtual file system.
if (IsAbsPath(name)) return FileReader(); // no absolute paths in the lump directory.
path = mBasePath + name;
auto index = fileSystem.FindFile(path.GetChars());
auto index = fileSystem.CheckNumForFullName(path.GetChars());
if (index < 0) return FileReader();
return fileSystem.ReopenFileReader(index);
}
@ -472,7 +472,7 @@ FSoundFontReader *FSoundFontManager::OpenSoundFont(const char *const name, int a
// To avoid clashes this will only be done if the name has the '.cfg' extension.
// Sound fonts cannot be loaded this way.
const char *p = name + strlen(name) - 4;
if (p > name && !stricmp(p, ".cfg") && fileSystem.FindFile(name) >= 0)
if (p > name && !stricmp(p, ".cfg") && fileSystem.CheckNumForFullName(name) >= 0)
{
return new FLumpPatchSetReader(name);
}

4
src/common/audio/music/music.cpp
View file

@ -114,7 +114,7 @@ static FileReader OpenMusic(const char* musicname)
{
int lumpnum;
lumpnum = mus_cb.FindMusic(musicname);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForName(musicname, ns_music);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForName(musicname, FileSys::ns_music);
if (lumpnum == -1)
{
Printf("Music \"%s\" not found\n", musicname);
@ -143,7 +143,7 @@ bool MusicExists(const char* music_name)
{
int lumpnum;
lumpnum = mus_cb.FindMusic(music_name);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForName(music_name, ns_music);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForName(music_name, FileSys::ns_music);
if (lumpnum != -1 && fileSystem.FileLength(lumpnum) != 0)
return true;
}

10
src/common/console/c_bind.cpp
View file

@ -730,15 +730,15 @@ void ReadBindings(int lump, bool override)
void C_SetDefaultKeys(const char* baseconfig)
{
auto lump = fileSystem.FindFile("engine/commonbinds.txt");
auto lump = fileSystem.CheckNumForFullName("engine/commonbinds.txt");
if (lump >= 0)
{
// Bail out if a mod tries to override this. Main game resources are allowed to do this, though.
auto fileno2 = fileSystem.GetFileContainer(lump);
if (fileno2 > fileSystem.GetMaxBaseNum())
if (fileno2 > fileSystem.GetMaxIwadNum())
{
I_FatalError("File %s is overriding core lump %s.",
fileSystem.GetContainerFullName(fileno2), "engine/commonbinds.txt");
fileSystem.GetResourceFileFullName(fileno2), "engine/commonbinds.txt");
}
ReadBindings(lump, true);
@ -748,7 +748,7 @@ void C_SetDefaultKeys(const char* baseconfig)
while ((lump = fileSystem.FindLumpFullName(baseconfig, &lastlump)) != -1)
{
// Read this only from the main game resources.
if (fileSystem.GetFileContainer(lump) <= fileSystem.GetMaxBaseNum())
if (fileSystem.GetFileContainer(lump) <= fileSystem.GetMaxIwadNum())
ReadBindings(lump, true);
}
@ -758,7 +758,7 @@ void C_SetDefaultKeys(const char* baseconfig)
// [SW] - We need to check to see the origin of the DEFBINDS... if it
// Comes from an IWAD/IPK3/IPK7 allow it to override the users settings...
// If it comes from a user mod however, don't.
if (fileSystem.GetFileContainer(lump) > fileSystem.GetMaxBaseNum())
if (fileSystem.GetFileContainer(lump) > fileSystem.GetMaxIwadNum())
ReadBindings(lump, false);
else
ReadBindings(lump, true);

6
src/common/console/c_enginecmds.cpp
View file

@ -233,18 +233,18 @@ CCMD (wdir)
if (argv.argc() != 2) wadnum = -1;
else
{
wadnum = fileSystem.CheckIfContainerLoaded (argv[1]);
wadnum = fileSystem.CheckIfResourceFileLoaded (argv[1]);
if (wadnum < 0)
{
Printf ("%s must be loaded to view its directory.\n", argv[1]);
return;
}
}
for (int i = 0; i < fileSystem.GetFileCount(); ++i)
for (int i = 0; i < fileSystem.GetNumEntries(); ++i)
{
if (wadnum == -1 || fileSystem.GetFileContainer(i) == wadnum)
{
Printf ("%10ld %s\n", fileSystem.FileLength(i), fileSystem.GetFileName(i));
Printf ("%10ld %s\n", fileSystem.FileLength(i), fileSystem.GetFileFullName(i));
}
}
}

2
src/common/cutscenes/movieplayer.cpp
View file

@ -508,7 +508,7 @@ public:
}
if (!MusicStream)
{
Printf(PRINT_BOLD, "Failed to decode %s\n", fileSystem.GetFileName(soundtrack));
Printf(PRINT_BOLD, "Failed to decode %s\n", fileSystem.GetFileFullName(soundtrack, false));
}
}
animtex.SetSize(AnimTexture::VPX, width, height);

648
src/common/engine/filesys_doom.cpp
View file

@ -1,648 +0,0 @@
/*
** filesys_doom.cpp
**
** the very special lump name lookup code for Doom's short names.
** Not useful in a generic system.
**
**---------------------------------------------------------------------------
** Copyright 1998-2016 Randy Heit
** Copyright 2005-2024 Christoph Oelckers
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
**
*/
#include "filesystem.h"
#include "printf.h"
//==========================================================================
//
//
//
//==========================================================================
void FileSystem::InitHashChains()
{
Super::InitHashChains();
unsigned NumEntries = GetFileCount();
for (unsigned i = 0; i < (unsigned)NumEntries; i++)
{
files[i].HashFirst = files[i].HashNext = NULL_INDEX;
}
// Now set up the chains
for (unsigned i = 0; i < (unsigned)NumEntries; i++)
{
if (files[i].Namespace == ns_hidden || files[i].ShortName[0] == 0) continue;
unsigned j = FileSys::MakeHash(files[i].ShortName, 8) % NumEntries;
files[i].HashNext = files[j].HashFirst;
files[j].HashFirst = i;
}
}
//==========================================================================
//
//
//
//==========================================================================
static void UpperCopy(char* to, const char* from)
{
int i;
for (i = 0; i < 8 && from[i]; i++)
to[i] = toupper(from[i]);
for (; i < 8; i++)
to[i] = 0;
to[8] = 0;
}
//==========================================================================
//
//
//
//==========================================================================
void FileSystem::SetupName(int fileindex)
{
const char* name = GetFileName(fileindex);
int containerflags = GetContainerFlags(GetFileContainer(fileindex));
int lflags = GetFileFlags(fileindex);
if ((containerflags & wadflags) == wadflags)
{
UpperCopy(files[fileindex].ShortName, name);
}
else if ((lflags & FileSys::RESFF_EMBEDDED) || !*name)
{
files[fileindex].Namespace = ns_hidden;
}
else
{
if (lflags & FileSys::RESFF_FULLPATH) files[fileindex].Flags |= LUMPF_FULLPATH; // copy for easier access in lookup function.
auto slash = strrchr(name, '/');
auto base = slash ? (slash + 1) : name;
UpperCopy(files[fileindex].ShortName, base);
auto dot = strrchr(files[fileindex].ShortName, '.');
if (dot) while (*dot) *dot++ = 0;
}
}
//==========================================================================
//
// IsMarker
//
// (from BOOM)
//
//==========================================================================
inline bool FileSystem::IsMarker(int lump, const char* marker) noexcept
{
auto name = files[lump].ShortName;
if (name[0] == marker[0])
{
return (!strcmp(name, marker) ||
(marker[1] == '_' && !strcmp(name + 1, marker)));
}
else return false;
}
//==========================================================================
//
// SetNameSpace
//
// Sets namespace information for the lumps. It always looks for the first
// x_START and the last x_END lump, except when loading flats. In this case
// F_START may be absent and if that is the case all lumps with a size of
// 4096 will be flagged appropriately.
//
//==========================================================================
// This class was supposed to be local in the function but GCC
// does not like that.
struct Marker
{
int markertype;
int index;
};
void FileSystem::SetNamespace(int filenum, const char* startmarker, const char* endmarker, namespace_t space, FileSys::FileSystemMessageFunc Printf, bool flathack)
{
using FileSys::FSMessageLevel;
bool warned = false;
int numstartmarkers = 0, numendmarkers = 0;
TArray<Marker> markers;
int FirstLump = GetFirstEntry(filenum);
int LastLump = GetLastEntry(filenum);
auto FileName = GetContainerName(filenum);
for (int i = FirstLump; i <= LastLump; i++)
{
if (IsMarker(i, startmarker))
{
Marker m = { 0, i };
markers.push_back(m);
numstartmarkers++;
}
else if (IsMarker(i, endmarker))
{
Marker m = { 1, i };
markers.push_back(m);
numendmarkers++;
}
}
if (numstartmarkers == 0)
{
if (numendmarkers == 0) return; // no markers found
if (Printf)
Printf(FSMessageLevel::Warning, "%s: %s marker without corresponding %s found.\n", FileName, endmarker, startmarker);
if (flathack)
{
// We have found no F_START but one or more F_END markers.
// mark all lumps before the last F_END marker as potential flats.
unsigned int end = markers[markers.size() - 1].index;
for (int ii = FirstLump; ii <= LastLump; ii++)
{
if (FileLength(ii) == 4096)
{
// We can't add this to the flats namespace but
// it needs to be flagged for the texture manager.
if (Printf) Printf(FSMessageLevel::DebugNotify, "%s: Marking %s as potential flat\n", FileName, files[ii].ShortName);
files[ii].Namespace = ns_maybeflat;
}
}
}
return;
}
size_t i = 0;
while (i < markers.size())
{
int start, end;
if (markers[i].markertype != 0)
{
if (Printf) Printf(FSMessageLevel::Warning, "%s: %s marker without corresponding %s found.\n", FileName, endmarker, startmarker);
i++;
continue;
}
start = int(i++);
// skip over subsequent x_START markers
while (i < markers.size() && markers[i].markertype == 0)
{
if (Printf) Printf(FSMessageLevel::Warning, "%s: duplicate %s marker found.\n", FileName, startmarker);
i++;
continue;
}
// same for x_END markers
while (i < markers.size() - 1 && (markers[i].markertype == 1 && markers[i + 1].markertype == 1))
{
if (Printf) Printf(FSMessageLevel::Warning, "%s: duplicate %s marker found.\n", FileName, endmarker);
i++;
continue;
}
// We found a starting marker but no end marker. Ignore this block.
if (i >= markers.size())
{
if (Printf) Printf(FSMessageLevel::Warning, "%s: %s marker without corresponding %s found.\n", FileName, startmarker, endmarker);
end = LastLump + 1;
}
else
{
end = markers[i++].index;
}
// we found a marked block
if (Printf) Printf(FSMessageLevel::DebugNotify, "%s: Found %s block at (%d-%d)\n", FileName, startmarker, markers[start].index, end);
for (int j = markers[start].index + 1; j < end; j++)
{
if (files[j].Namespace != ns_global)
{
if (!warned && Printf)
{
Printf(FSMessageLevel::Warning, "%s: Overlapping namespaces found (lump %d)\n", FileName, j);
}
warned = true;
}
else if (space == ns_sprites && FileLength(j) < 8)
{
// sf 26/10/99:
// ignore sprite lumps smaller than 8 bytes (the smallest possible)
// in size -- this was used by some dmadds wads
// as an 'empty' graphics resource
if (Printf) Printf(FSMessageLevel::DebugWarn, "%s: Skipped empty sprite %s (lump %d)\n", FileName, files[j].ShortName, j);
}
else
{
files[j].Namespace = space;
}
}
}
}
//==========================================================================
//
// W_SkinHack
//
// Tests a wad file to see if it contains an S_SKIN marker. If it does,
// every lump in the wad is moved into a new namespace. Because skins are
// only supposed to replace player sprites, sounds, or faces, this should
// not be a problem. Yes, there are skins that replace more than that, but
// they are such a pain, and breaking them like this was done on purpose.
// This also renames any S_SKINxx lumps to just S_SKIN.
//
//==========================================================================
void FileSystem::SkinHack(int filenum, FileSys::FileSystemMessageFunc Printf)
{
using FileSys::FSMessageLevel;
// this being static is not a problem. The only relevant thing is that each skin gets a different number.
bool skinned = false;
bool hasmap = false;
int FirstLump = GetFirstEntry(filenum);
int LastLump = GetLastEntry(filenum);
auto FileName = GetContainerName(filenum);
for (int i = FirstLump; i <= LastLump; i++)
{
auto lump = &files[i];
if (!strnicmp(lump->ShortName, "S_SKIN", 6))
{ // Wad has at least one skin.
lump->ShortName[6] = 0;
lump->ShortName[7] = 0;
if (!skinned)
{
skinned = true;
for (int j = FirstLump; j <= LastLump; j++)
{
files[j].Namespace = skin_namespc;
}
skin_namespc++;
}
}
// needless to say, this check is entirely useless these days as map names can be more diverse..
if ((lump->ShortName[0] == 'M' &&
lump->ShortName[1] == 'A' &&
lump->ShortName[2] == 'P' &&
lump->ShortName[3] >= '0' && lump->ShortName[3] <= '9' &&
lump->ShortName[4] >= '0' && lump->ShortName[4] <= '9' &&
lump->ShortName[5] == '\0')
||
(lump->ShortName[0] == 'E' &&
lump->ShortName[1] >= '0' && lump->ShortName[1] <= '9' &&
lump->ShortName[2] == 'M' &&
lump->ShortName[3] >= '0' && lump->ShortName[3] <= '9' &&
lump->ShortName[4] == '\0'))
{
hasmap = true;
}
}
if (skinned && hasmap && Printf)
{
Printf(FSMessageLevel::Attention, "%s: The maps will not be loaded because it has a skin.\n", FileName);
Printf(FSMessageLevel::Attention, "You should remove the skin from the wad to play these maps.\n");
}
}
//==========================================================================
//
//
//
//==========================================================================
void FileSystem::SetupNamespace(int filenum, FileSys::FileSystemMessageFunc Printf)
{
int flags = GetContainerFlags(filenum);
// Set namespace for entries from WADs.
if ((flags & wadflags) == wadflags)
{
SetNamespace(filenum, "S_START", "S_END", ns_sprites, Printf);
SetNamespace(filenum, "F_START", "F_END", ns_flats, Printf, true);
SetNamespace(filenum, "C_START", "C_END", ns_colormaps, Printf);
SetNamespace(filenum, "A_START", "A_END", ns_acslibrary, Printf);
SetNamespace(filenum, "TX_START", "TX_END", ns_newtextures, Printf);
SetNamespace(filenum, "V_START", "V_END", ns_strifevoices, Printf);
SetNamespace(filenum, "HI_START", "HI_END", ns_hires, Printf);
SetNamespace(filenum, "VX_START", "VX_END", ns_voxels, Printf);
SkinHack(filenum, Printf);
}
else if (!(flags & FResourceFile::NO_FOLDERS))
{
int FirstLump = GetFirstEntry(filenum);
int LastLump = GetLastEntry(filenum);
auto FileName = GetContainerName(filenum);
for (int i = FirstLump; i <= LastLump; i++)
{
auto lump = &files[i];
auto LongName = GetFileName(i);
// Map some directories to WAD namespaces.
// Note that some of these namespaces don't exist in WADS.
// CheckNumForName will handle any request for these namespaces accordingly.
int Namespace = !strncmp(LongName, "flats/", 6) ? ns_flats :
!strncmp(LongName, "textures/", 9) ? ns_newtextures :
!strncmp(LongName, "hires/", 6) ? ns_hires :
!strncmp(LongName, "sprites/", 8) ? ns_sprites :
!strncmp(LongName, "voxels/", 7) ? ns_voxels :
!strncmp(LongName, "colormaps/", 10) ? ns_colormaps :
!strncmp(LongName, "acs/", 4) ? ns_acslibrary :
!strncmp(LongName, "voices/", 7) ? ns_strifevoices :
!strncmp(LongName, "patches/", 8) ? ns_patches :
!strncmp(LongName, "graphics/", 9) ? ns_graphics :
!strncmp(LongName, "sounds/", 7) ? ns_sounds :
!strncmp(LongName, "music/", 6) ? ns_music :
!strchr(LongName, '/') ? ns_global :
ns_hidden;
lump->Namespace = Namespace;
switch (Namespace)
{
case ns_hidden:
memset(lump->ShortName, 0, sizeof(lump->ShortName));
break;
case ns_sprites:
case ns_voxels:
case ns_hires:
// Since '\' can't be used as a file name's part inside a ZIP
// we have to work around this for sprites because it is a valid
// frame character.
for (auto& c : lump->ShortName)
{
if (c == '^') c = '\\';
}
break;
}
}
}
}
//==========================================================================
//
//
//
//==========================================================================
bool FileSystem::InitFiles(std::vector<std::string>& filenames, FileSys::FileSystemFilterInfo* filter, FileSys::FileSystemMessageFunc Printf, bool allowduplicates)
{
if (!Super::InitFiles(filenames, filter, Printf, allowduplicates)) return false;
files.Resize(GetFileCount());
memset(files.Data(), 0, sizeof(files[0]) * files.size());
int numfiles = GetFileCount();
for (int i = 0; i < numfiles; i++)
{
SetupName(i);
}
int numresfiles = GetContainerCount();
for (int i = 0; i < numresfiles; i++)
{
SetupNamespace(i, Printf);
}
return true;
}
//==========================================================================
//
// CheckNumForName
//
// Returns -1 if name not found. The version with a third parameter will
// look exclusively in the specified wad for the lump.
//
// [RH] Changed to use hash lookup ala BOOM instead of a linear search
// and namespace parameter
//==========================================================================
int FileSystem::CheckNumForName(const char* name, int space) const
{
char uname[9];
uint32_t i;
if (name == nullptr)
{
return -1;
}
// Let's not search for names that are longer than 8 characters and contain path separators
// They are almost certainly full path names passed to this function.
if (strlen(name) > 8 && strpbrk(name, "/."))
{
return -1;
}
UpperCopy(uname, name);
i = files[FileSys::MakeHash(uname, 8) % files.Size()].HashFirst;
while (i != NULL_INDEX)
{
auto& lump = files[i];
if (!memcmp(lump.ShortName, uname, 8))
{
if (lump.Namespace == space) break;
// If the lump is from one of the special namespaces exclusive to Zips
// the check has to be done differently:
// If we find a lump with this name in the global namespace that does not come
// from a Zip return that. WADs don't know these namespaces and single lumps must
// work as well.
if (space > ns_specialzipdirectory && lump.Namespace == ns_global && !(lump.Flags & LUMPF_FULLPATH))
break;
}
i = lump.HashNext;
}
return i != NULL_INDEX ? i : -1;
}
int FileSystem::CheckNumForName(const char* name, int space, int rfnum, bool exact) const
{
char uname[9];
uint32_t i;
if (rfnum < 0)
{
return CheckNumForName(name, space);
}
UpperCopy(uname, name);
i = files[FileSys::MakeHash(uname, 8) % files.Size()].HashFirst;
// If exact is true if will only find lumps in the same WAD, otherwise
// also those in earlier WADs.
while (i != NULL_INDEX &&
(memcmp(files[i].ShortName, uname, 8) || files[i].Namespace != space ||
(exact ? (GetFileContainer(i) != rfnum) : (GetFileContainer(i) > rfnum))))
{
i = files[i].HashNext;
}
return i != NULL_INDEX ? i : -1;
}
//==========================================================================
//
// GetNumForName
//
// Calls CheckNumForName, but bombs out if not found.
//
//==========================================================================
int FileSystem::GetNumForName(const char* name, int space) const
{
int i;
i = CheckNumForName(name, space);
if (i == -1)
throw FileSys::FileSystemException("GetNumForName: %s not found!", name);
return i;
}
//==========================================================================
//
// returns a modifiable pointer to the short name
//
// should only be called before the hash chains are set up.
// If done later this needs rehashing.
//
// This is for custom setup through postprocessFunc
//
//==========================================================================
char* FileSystem::GetShortName(int i)
{
if ((unsigned)i >= files.Size())
throw FileSys::FileSystemException("GetShortName: Invalid index");
return files[i].ShortName;
}
//==========================================================================
//
// W_FindLump
//
// Find a named lump. Specifically allows duplicates for merging of e.g.
// SNDINFO lumps.
//
//==========================================================================
int FileSystem::FindLump(const char* name, int* lastlump, bool anyns)
{
if ((size_t)*lastlump >= files.size()) return -1;
char name8[9];
UpperCopy(name8, name);
assert(lastlump != nullptr && *lastlump >= 0);
const int last = (int)files.size();
for(int lump = *lastlump; lump < last; lump++)
{
const FileEntry* const lump_p = &files[lump];
if ((anyns || lump_p->Namespace == ns_global) && !memcmp(lump_p->ShortName, name8, 8))
{
*lastlump = lump + 1;
return lump;
}
}
*lastlump = last;
return -1;
}
//==========================================================================
//
// W_FindLumpMulti
//
// Find a named lump. Specifically allows duplicates for merging of e.g.
// SNDINFO lumps. Returns everything having one of the passed names.
//
//==========================================================================
int FileSystem::FindLumpMulti(const char** names, int* lastlump, bool anyns, int* nameindex)
{
assert(lastlump != nullptr && *lastlump >= 0);
int last = files.Size();
for (int lump = *lastlump; lump < last; lump++)
{
auto lump_p = &files[lump];
if (anyns || lump_p->Namespace == ns_global)
{
for (const char** name = names; *name != nullptr; name++)
{
if (!strnicmp(*name, lump_p->ShortName, 8))
{
*lastlump = lump + 1;
if (nameindex != nullptr) *nameindex = int(name - names);
return lump;
}
}
}
}
*lastlump = last;
return -1;
}
//==========================================================================
//
// This function combines lookup from regular lists and Doom's special one.
//
//==========================================================================
int FileSystem::CheckNumForAnyName(const char* name, namespace_t namespc) const
{
if (name != NULL)
{
// Check short names first to avoid interference from short names in the real file system.
if (strlen(name) <= 8 && !strpbrk(name, "./"))
{
return CheckNumForName(name, namespc);
}
int lookup = Super::FindFile(name, false);
if (lookup >= 0) return lookup;
}
return -1;
}

126
src/common/engine/filesystem.h
View file

@ -1,129 +1,7 @@
#pragma once
#include "fs_filesystem.h"
using FileSys::FileSystem;
using FileSys::FResourceFile;
// [RH] Namespaces from BOOM.
// These are needed here in the low level part so that WAD files can be properly set up.
enum namespace_t : int {
ns_hidden = -1,
ns_global = 0,
ns_sprites,
ns_flats,
ns_colormaps,
ns_acslibrary,
ns_newtextures,
ns_bloodraw, // no longer used - kept for ZScript.
ns_bloodsfx, // no longer used - kept for ZScript.
ns_bloodmisc, // no longer used - kept for ZScript.
ns_strifevoices,
ns_hires,
ns_voxels,
ns_maybeflat,
// These namespaces are only used to mark lumps in special subdirectories
// so that their contents doesn't interfere with the global namespace.
// searching for data in these namespaces works differently for lumps coming
// from Zips or other files.
ns_specialzipdirectory,
ns_sounds,
ns_patches,
ns_graphics,
ns_music,
ns_firstskin,
};
// extended class that adds Doom's very special short name lookup to the file system.
class FileSystem : public FileSys::FileSystem
{
private:
struct FileEntry
{
char ShortName[9];
uint8_t Namespace;
uint8_t Flags;
uint32_t HashFirst;
uint32_t HashNext;
};
const int wadflags = FileSys::FResourceFile::NO_EXTENSIONS | FileSys::FResourceFile::NO_FOLDERS | FileSys::FResourceFile::SHORTNAMES;
const uint32_t NULL_INDEX = 0xffffffff;
TArray<FileEntry> files;
int skin_namespc = ns_firstskin;
void Start(FileSys::FileSystemMessageFunc Printf);
void SetupName(int fileindex);
bool IsMarker(int lump, const char* marker) noexcept;
void SetNamespace(int filenum, const char* startmarker, const char* endmarker, namespace_t space, FileSys::FileSystemMessageFunc Printf, bool flathack = false);
void SkinHack(int filenum, FileSys::FileSystemMessageFunc Printf);
void SetupNamespace(int filenum, FileSys::FileSystemMessageFunc Printf);
using Super = FileSys::FileSystem;
public:
enum
{
LUMPF_MAYBEFLAT = 1,
LUMPF_FULLPATH = 2,
};
bool InitFiles(std::vector<std::string>& filenames, FileSys::FileSystemFilterInfo* filter = nullptr, FileSys::FileSystemMessageFunc Printf = nullptr, bool allowduplicates = false) override;
void InitHashChains() override;
int CheckNumForAnyName(const char* cname, namespace_t namespc = ns_global) const;
int CheckNumForName(const char* name, int namespc) const;
int CheckNumForName(const char* name, int namespc, int wadfile, bool exact = true) const;
int GetNumForName(const char* name, int namespc) const;
inline int CheckNumForName(const uint8_t* name) const { return CheckNumForName((const char*)name, ns_global); }
inline int CheckNumForName(const char* name) const { return CheckNumForName(name, ns_global); }
inline int CheckNumForName(const uint8_t* name, int ns) const { return CheckNumForName((const char*)name, ns); }
inline int GetNumForName(const char* name) const { return GetNumForName(name, ns_global); }
inline int GetNumForName(const uint8_t* name) const { return GetNumForName((const char*)name); }
inline int GetNumForName(const uint8_t* name, int ns) const { return GetNumForName((const char*)name, ns); }
int FindLump(const char* name, int* lastlump, bool anyns = false); // [RH] Find lumps with duplication
int FindLumpMulti(const char** names, int* lastlump, bool anyns = false, int* nameindex = nullptr); // same with multiple possible names
bool CheckFileName(int lump, const char* name) const noexcept
{
if ((size_t)lump >= files.size())
return false;
return !strnicmp(files[lump].ShortName, name, 8);
}
const char* GetFileShortName(int lump) const noexcept
{
if ((size_t)lump >= files.size())
return nullptr;
else
return files[lump].ShortName;
}
int GetFileNamespace(int lump) const noexcept
{
if ((size_t)lump >= files.size())
return ns_global;
else
return files[lump].Namespace;
}
void SetFileNamespace(int lump, int ns) noexcept
{
if ((size_t)lump < files.size()) files[lump].Namespace = ns;
}
// This is only for code that wants to edit the names before the game starts.
char* GetShortName(int i);
};
inline FileSystem fileSystem;
inline FileSys::FileSystem fileSystem;

2
src/common/engine/sc_man.cpp
View file

@ -124,7 +124,7 @@ FScanner::FScanner(int lumpnum, TMap<FName, Symbol>* extsymbols) : symbols(extsy
void FScanner::Open (const char *name)
{
int lump = fileSystem.CheckNumForAnyName(name);
int lump = fileSystem.CheckNumForFullName(name, true);
if (lump == -1)
{
I_Error("Could not find script lump '%s'\n", name);

16
src/common/engine/serializer.cpp
View file

@ -58,6 +58,8 @@
#include "vm.h"
#include "i_interface.h"
using namespace FileSys;
extern DObject *WP_NOCHANGE;
bool save_full = false; // for testing. Should be removed afterward.
@ -153,13 +155,13 @@ bool FSerializer::OpenReader(const char *buffer, size_t length)
//
//==========================================================================
bool FSerializer::OpenReader(FileSys::FCompressedBuffer *input)
bool FSerializer::OpenReader(FCompressedBuffer *input)
{
if (input->mSize <= 0 || input->mBuffer == nullptr) return false;
if (w != nullptr || r != nullptr) return false;
mErrors = 0;
if (input->mMethod == FileSys::METHOD_STORED)
if (input->mMethod == METHOD_STORED)
{
r = new FReader((char*)input->mBuffer, input->mSize);
}
@ -783,10 +785,10 @@ const char *FSerializer::GetOutput(unsigned *len)
//
//==========================================================================
FileSys::FCompressedBuffer FSerializer::GetCompressedOutput()
FCompressedBuffer FSerializer::GetCompressedOutput()
{
if (isReading()) return{ 0,0,0,0,0,nullptr };
FileSys::FCompressedBuffer buff;
FCompressedBuffer buff;
WriteObjects();
EndObject();
buff.filename = nullptr;
@ -825,7 +827,7 @@ FileSys::FCompressedBuffer FSerializer::GetCompressedOutput()
if (err == Z_OK)
{
buff.mBuffer = new char[buff.mCompressedSize];
buff.mMethod = FileSys::METHOD_DEFLATE;
buff.mMethod = METHOD_DEFLATE;
memcpy(buff.mBuffer, compressbuf, buff.mCompressedSize);
delete[] compressbuf;
return buff;
@ -834,7 +836,7 @@ FileSys::FCompressedBuffer FSerializer::GetCompressedOutput()
error:
memcpy(compressbuf, w->mOutString.GetString(), buff.mSize + 1);
buff.mCompressedSize = buff.mSize;
buff.mMethod = FileSys::METHOD_STORED;
buff.mMethod = METHOD_STORED;
return buff;
}
@ -1179,7 +1181,7 @@ FSerializer &Serialize(FSerializer &arc, const char *key, FTextureID &value, FTe
if (TexMan.GetLinkedTexture(lump) == pic)
{
name = fileSystem.GetFileName(lump);
name = fileSystem.GetFileFullName(lump);
}
else
{

2
src/common/engine/stringtable.cpp
View file

@ -47,7 +47,7 @@
//
//==========================================================================
void FStringTable::LoadStrings (FileSystem& fileSystem, const char *language)
void FStringTable::LoadStrings (FileSys::FileSystem& fileSystem, const char *language)
{
int lastlump, lump;

2
src/common/engine/stringtable.h
View file

@ -84,7 +84,7 @@ public:
using LangMap = TMap<uint32_t, StringMap>;
using StringMacroMap = TMap<FName, StringMacro>;
void LoadStrings(FileSystem& fileSystem, const char *language);
void LoadStrings(FileSys::FileSystem& fileSystem, const char *language);
void UpdateLanguage(const char* language);
StringMap GetDefaultStrings() { return allStrings[default_table]; } // Dehacked needs these for comparison
void SetOverrideStrings(StringMap & map)

150
src/common/filesystem/include/fs_filesystem.h
View file

@ -13,6 +13,15 @@
namespace FileSys {
union LumpShortName
{
char String[9];
uint32_t dword; // These are for accessing the first 4 or 8 chars of
uint64_t qword; // Name as a unit without breaking strict aliasing rules
};
struct FolderEntry
{
const char *name;
@ -23,34 +32,46 @@ class FileSystem
{
public:
FileSystem();
virtual ~FileSystem ();
// do not copy!
FileSystem(const FileSystem& other) = delete;
FileSystem& operator =(const FileSystem& other) = delete;
~FileSystem ();
bool Initialize(std::vector<std::string>& filenames, FileSystemFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, bool allowduplicates = false);
// The wadnum for the IWAD
int GetIwadNum() { return IwadIndex; }
void SetIwadNum(int x) { IwadIndex = x; }
// The container for the IWAD
int GetBaseNum() { return BaseIndex; }
void SetBaseNum(int x) { BaseIndex = x; }
int GetMaxIwadNum() { return MaxIwadIndex; }
void SetMaxIwadNum(int x) { MaxIwadIndex = x; }
int GetMaxBaseNum() { return MaxBaseIndex; }
void SetMaxBaseNum(int x) { MaxBaseIndex = x; }
int CheckIfContainerLoaded (const char *name) noexcept;
bool InitSingleFile(const char *filename, FileSystemMessageFunc Printf = nullptr);
bool InitMultipleFiles (std::vector<std::string>& filenames, LumpFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, bool allowduplicates = false);
void AddFile (const char *filename, FileReader *wadinfo, LumpFilterInfo* filter, FileSystemMessageFunc Printf);
int CheckIfResourceFileLoaded (const char *name) noexcept;
void AddAdditionalFile(const char* filename, FileReader* wadinfo = NULL) {}
const char *GetContainerName (int container) const noexcept;
const char *GetContainerFullName (int container) const noexcept;
const char *GetResourceFileName (int filenum) const noexcept;
const char *GetResourceFileFullName (int wadnum) const noexcept;
int GetFirstEntry(int container) const noexcept;
int GetLastEntry(int container) const noexcept;
int GetEntryCount(int container) const noexcept;
int GetContainerFlags(int container) const noexcept;
int GetFirstEntry(int wadnum) const noexcept;
int GetLastEntry(int wadnum) const noexcept;
int GetEntryCount(int wadnum) const noexcept;
int FindFile (const char *cname, bool ignoreext = false) const;
int GetFileInContainer (const char *name, int wadfile) const;
int GetFile (const char *name) const;
int CheckNumForName (const char *name, int namespc) const;
int CheckNumForName (const char *name, int namespc, int wadfile, bool exact = true) const;
int GetNumForName (const char *name, int namespc) const;
inline int CheckNumForName (const uint8_t *name) const { return CheckNumForName ((const char *)name, ns_global); }
inline int CheckNumForName (const char *name) const { return CheckNumForName (name, ns_global); }
inline int CheckNumForName (const uint8_t *name, int ns) const { return CheckNumForName ((const char *)name, ns); }
inline int GetNumForName (const char *name) const { return GetNumForName (name, ns_global); }
inline int GetNumForName (const uint8_t *name) const { return GetNumForName ((const char *)name); }
inline int GetNumForName (const uint8_t *name, int ns) const { return GetNumForName ((const char *)name, ns); }
int CheckNumForFullName (const char *cname, bool trynormal = false, int namespc = ns_global, bool ignoreext = false) const;
int CheckNumForFullName (const char *name, int wadfile) const;
int GetNumForFullName (const char *name) const;
int FindFile(const char* name) const
{
return CheckNumForFullName(name);
}
bool FileExists(const char* name) const
{
@ -62,106 +83,101 @@ public:
return FindFile(name.c_str()) >= 0;
}
LumpShortName& GetShortName(int i); // may only be called before the hash chains are set up.
void RenameFile(int num, const char* fn);
bool CreatePathlessCopy(const char* name, int id, int flags);
void ReadFile (int filenum, void *dest);
void ReadFile (int lump, void *dest);
// These should only be used if the file data really needs padding.
FileData ReadFile (int filenum);
FileData ReadFileFullName(const char* name) { return ReadFile(GetFile(name)); }
FileData ReadFile (int lump);
FileData ReadFile (const char *name) { return ReadFile (GetNumForName (name)); }
FileData ReadFileFullName(const char* name) { return ReadFile(GetNumForFullName(name)); }
FileReader OpenFileReader(int filenum, int readertype, int readerflags); // opens a reader that redirects to the containing file's one.
FileReader OpenFileReader(int lump, int readertype, int readerflags); // opens a reader that redirects to the containing file's one.
FileReader OpenFileReader(const char* name);
FileReader ReopenFileReader(const char* name, bool alwayscache = false);
FileReader OpenFileReader(int filenum)
FileReader OpenFileReader(int lump)
{
return OpenFileReader(filenum, READER_SHARED, READERFLAG_SEEKABLE);
return OpenFileReader(lump, READER_SHARED, READERFLAG_SEEKABLE);
}
FileReader ReopenFileReader(int filenum, bool alwayscache = false)
FileReader ReopenFileReader(int lump, bool alwayscache = false)
{
return OpenFileReader(filenum, alwayscache ? READER_CACHED : READER_NEW, READERFLAG_SEEKABLE);
return OpenFileReader(lump, alwayscache ? READER_CACHED : READER_NEW, READERFLAG_SEEKABLE);
}
int FindLump (const char *name, int *lastlump, bool anyns=false); // [RH] Find lumps with duplication
int FindLumpMulti (const char **names, int *lastlump, bool anyns = false, int *nameindex = NULL); // same with multiple possible names
int FindLumpFullName(const char* name, int* lastlump, bool noext = false);
bool CheckFileName (int lump, const char *name); // [RH] True if lump's name == name
int FindFileWithExtensions(const char* name, const char* const* exts, int count) const;
int FindResource(int resid, const char* type, int filenum = -1) const noexcept;
int GetResource(int resid, const char* type, int filenum = -1) const;
ptrdiff_t FileLength(int filenum) const;
int GetFileFlags (int filenum); // Return the flags for this filenum
const char* GetFileName(int filenum) const; // Gets uninterpreted name from the FResourceFile
std::string GetFileFullPath (int filenum) const; // [RH] Returns wad's name + filenum's full name
int GetFileContainer (int filenum) const;
// [RH] Returns container for a specified filenum
int GetResourceId(int filenum) const; // Returns the RFF index number for this filenum
const char* GetResourceType(int filenum) const;
static uint32_t LumpNameHash (const char *name); // [RH] Create hash key from an 8-char name
ptrdiff_t FileLength (int lump) const;
int GetFileFlags (int lump); // Return the flags for this lump
const char* GetFileShortName(int lump) const;
const char *GetFileFullName (int lump, bool returnshort = true) const; // [RH] Returns the lump's full name
std::string GetFileFullPath (int lump) const; // [RH] Returns wad's name + lump's full name
int GetFileContainer (int lump) const; // [RH] Returns wadnum for a specified lump
int GetFileNamespace (int lump) const; // [RH] Returns the namespace a lump belongs to
void SetFileNamespace(int lump, int ns);
int GetResourceId(int lump) const; // Returns the RFF index number for this lump
const char* GetResourceType(int lump) const;
bool CheckFileName (int lump, const char *name) const; // [RH] Returns true if the names match
unsigned GetFilesInFolder(const char *path, std::vector<FolderEntry> &result, bool atomic) const;
int GetFileCount() const
int GetNumEntries() const
{
return NumEntries;
}
int GetContainerCount() const
int GetNumWads() const
{
return (int)Files.size();
}
int AddFromBuffer(const char* name, char* data, int size, int id, int flags);
FileReader* GetFileReader(int container); // Gets a FileReader object to the entire WAD
FileReader* GetFileReader(int wadnum); // Gets a FileReader object to the entire WAD
void InitHashChains();
protected:
struct LumpRecord;
const uint32_t NULL_INDEX = 0xffffffff;
std::vector<FResourceFile *> Files;
std::vector<LumpRecord> FileInfo;
std::vector<uint32_t> Hashes; // one allocation for all hash lists.
uint32_t *FirstLumpIndex = nullptr; // [RH] Hashing stuff moved out of lumpinfo structure
uint32_t *NextLumpIndex = nullptr;
uint32_t *FirstFileIndex_FullName = nullptr; // The same information for fully qualified paths from .zips
uint32_t *NextFileIndex_FullName = nullptr;
uint32_t *FirstLumpIndex_FullName = nullptr; // The same information for fully qualified paths from .zips
uint32_t *NextLumpIndex_FullName = nullptr;
uint32_t *FirstFileIndex_NoExt = nullptr; // The same information for fully qualified paths from .zips
uint32_t *NextFileIndex_NoExt = nullptr;
uint32_t *FirstLumpIndex_NoExt = nullptr; // The same information for fully qualified paths from .zips
uint32_t *NextLumpIndex_NoExt = nullptr;
uint32_t* FirstFileIndex_ResId = nullptr; // The same information for fully qualified paths from .zips
uint32_t* NextFileIndex_ResId = nullptr;
uint32_t* FirstLumpIndex_ResId = nullptr; // The same information for fully qualified paths from .zips
uint32_t* NextLumpIndex_ResId = nullptr;
uint32_t NumEntries = 0; // Not necessarily the same as FileInfo.Size()
uint32_t NumWads = 0;
int BaseIndex = -1;
int MaxBaseIndex = -1;
int IwadIndex = -1;
int MaxIwadIndex = -1;
StringPool* stringpool = nullptr;
private:
void DeleteAll();
void MoveFilesInFolder(const char *);
void AddFile(const char* filename, FileReader* wadinfo, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf);
protected:
// These two functions must be overridden by subclasses which want to extend the file system.
virtual bool InitFiles(std::vector<std::string>& filenames, FileSystemFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, bool allowduplicates = false);
public:
virtual void InitHashChains();
void MoveLumpsInFolder(const char *);
};
//djb2 hash algorithm with case insensitivity hack
inline static uint32_t MakeHash(const char* str, size_t length = SIZE_MAX)
{
uint32_t hash = 5381;
uint32_t c;
while (length-- > 0 && (c = *str++)) hash = hash * 33 + (c | 32);
return hash;
}
}

74
src/common/filesystem/include/resourcefile.h
View file

@ -16,7 +16,7 @@ std::string ExtractBaseName(const char* path, bool include_extension = false);
void strReplace(std::string& str, const char* from, const char* to);
// user context in which the file system gets opened. This also contains a few callbacks to avoid direct dependencies on the engine.
struct FileSystemFilterInfo
struct LumpFilterInfo
{
std::vector<std::string> gameTypeFilter; // this can contain multiple entries
@ -45,10 +45,41 @@ using FileSystemMessageFunc = int(*)(FSMessageLevel msglevel, const char* format
class FResourceFile;
// [RH] Namespaces from BOOM.
// These are needed here in the low level part so that WAD files can be properly set up.
typedef enum {
ns_hidden = -1,
ns_global = 0,
ns_sprites,
ns_flats,
ns_colormaps,
ns_acslibrary,
ns_newtextures,
ns_bloodraw, // no longer used - kept for ZScript.
ns_bloodsfx, // no longer used - kept for ZScript.
ns_bloodmisc, // no longer used - kept for ZScript.
ns_strifevoices,
ns_hires,
ns_voxels,
// These namespaces are only used to mark lumps in special subdirectories
// so that their contents doesn't interfere with the global namespace.
// searching for data in these namespaces works differently for lumps coming
// from Zips or other files.
ns_specialzipdirectory,
ns_sounds,
ns_patches,
ns_graphics,
ns_music,
ns_firstskin,
} namespace_t;
enum ELumpFlags
{
RESFF_FULLPATH = 2, // contains a full path.
RESFF_MAYBEFLAT = 1, // might be a flat inside a WAD outside F_START/END
RESFF_FULLPATH = 2, // contains a full path. This will trigger extended namespace checks when looking up short names.
RESFF_EMBEDDED = 4, // marks an embedded resource file for later processing.
RESFF_SHORTNAME = 8, // the stored name is a short extension-less name
RESFF_COMPRESSED = 16, // compressed or encrypted, i.e. cannot be read with the container file's reader.
@ -69,10 +100,11 @@ struct FResourceEntry
size_t CompressedSize;
const char* FileName;
size_t Position;
int ResourceID; // Only Blood RFF uses this natively.
int ResourceID;
uint32_t CRC32;
uint16_t Flags;
uint16_t Method;
int16_t Namespace;
};
void SetMainThread();
@ -80,25 +112,17 @@ void SetMainThread();
class FResourceFile
{
public:
enum
{
// descibes which kind of limitations this file type has.
NO_FOLDERS = 1, // no paths - only one rpot folder (e.g. Build GRP, Blood RFF, Descent HOG
NO_EXTENSIONS = 2, // no extensions for file names (e.g. Doom WADs.)
SHORTNAMES = 4, // Name is (at most) 8.3 DOS ASCII format, (8.0 in case of WAD)
};
FResourceFile(const char* filename, StringPool* sp, int flags);
FResourceFile(const char* filename, FileReader& r, StringPool* sp, int flags);
const char* NormalizeFileName(const char* fn, int fallbackcp = 0, bool allowbackslash = false);
FResourceFile(const char* filename, StringPool* sp);
FResourceFile(const char* filename, FileReader& r, StringPool* sp);
const char* NormalizeFileName(const char* fn, int fallbackcp = 0);
FResourceEntry* AllocateEntries(int count);
void GenerateHash();
void PostProcessArchive(FileSystemFilterInfo* filter);
void PostProcessArchive(LumpFilterInfo* filter);
protected:
FileReader Reader;
const char* FileName;
FResourceEntry* Entries = nullptr;
uint32_t NumLumps;
int flags = 0;
char Hash[48];
StringPool* stringpool;
@ -108,7 +132,7 @@ protected:
Entries[entry].Flags &= ~RESFF_NEEDFILESTART;
}
bool IsFileInFolder(const char* const resPath);
void CheckEmbedded(uint32_t entry, FileSystemFilterInfo* lfi);
void CheckEmbedded(uint32_t entry, LumpFilterInfo* lfi);
private:
uint32_t FirstLump;
@ -116,20 +140,19 @@ private:
int FilterLumps(const std::string& filtername, uint32_t max);
bool FindPrefixRange(const char* filter, uint32_t max, uint32_t &start, uint32_t &end);
void JunkLeftoverFilters(uint32_t max);
void FindCommonFolder(FileSystemFilterInfo* filter);
static FResourceFile *DoOpenResourceFile(const char *filename, FileReader &file, bool containeronly, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
void FindCommonFolder(LumpFilterInfo* filter);
static FResourceFile *DoOpenResourceFile(const char *filename, FileReader &file, bool containeronly, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
public:
static FResourceFile *OpenResourceFile(const char *filename, FileReader &file, bool containeronly = false, FileSystemFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, StringPool* sp = nullptr);
static FResourceFile *OpenResourceFile(const char *filename, bool containeronly = false, FileSystemFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, StringPool* sp = nullptr);
static FResourceFile *OpenDirectory(const char *filename, FileSystemFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, StringPool* sp = nullptr);
static FResourceFile *OpenResourceFile(const char *filename, FileReader &file, bool containeronly = false, LumpFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, StringPool* sp = nullptr);
static FResourceFile *OpenResourceFile(const char *filename, bool containeronly = false, LumpFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, StringPool* sp = nullptr);
static FResourceFile *OpenDirectory(const char *filename, LumpFilterInfo* filter = nullptr, FileSystemMessageFunc Printf = nullptr, StringPool* sp = nullptr);
virtual ~FResourceFile();
// If this FResourceFile represents a directory, the Reader object is not usable so don't return it.
FileReader *GetContainerReader() { return Reader.isOpen()? &Reader : nullptr; }
const char* GetFileName() const { return FileName; }
uint32_t GetFirstEntry() const { return FirstLump; }
int GetFlags() const noexcept { return flags; }
void SetFirstFile(uint32_t f) { FirstLump = f; }
void SetFirstLump(uint32_t f) { FirstLump = f; }
const char* GetHash() const { return Hash; }
int EntryCount() const { return NumLumps; }
@ -152,6 +175,11 @@ public:
return (entry < NumLumps) ? Entries[entry].Flags : 0;
}
int GetEntryNamespace(uint32_t entry)
{
return (entry < NumLumps) ? Entries[entry].Namespace : (int)ns_hidden;
}
int GetEntryResourceID(uint32_t entry)
{
return (entry < NumLumps) ? Entries[entry].ResourceID : -1;

9
src/common/filesystem/source/file_7z.cpp
View file

@ -177,7 +177,7 @@ class F7ZFile : public FResourceFile
public:
F7ZFile(const char * filename, FileReader &filer, StringPool* sp);
bool Open(FileSystemFilterInfo* filter, FileSystemMessageFunc Printf);
bool Open(LumpFilterInfo* filter, FileSystemMessageFunc Printf);
virtual ~F7ZFile();
FileData Read(uint32_t entry) override;
FileReader GetEntryReader(uint32_t entry, int, int) override;
@ -192,7 +192,7 @@ public:
//==========================================================================
F7ZFile::F7ZFile(const char * filename, FileReader &filer, StringPool* sp)
: FResourceFile(filename, filer, sp, 0)
: FResourceFile(filename, filer, sp)
{
Archive = nullptr;
}
@ -204,7 +204,7 @@ F7ZFile::F7ZFile(const char * filename, FileReader &filer, StringPool* sp)
//
//==========================================================================
bool F7ZFile::Open(FileSystemFilterInfo *filter, FileSystemMessageFunc Printf)
bool F7ZFile::Open(LumpFilterInfo *filter, FileSystemMessageFunc Printf)
{
Archive = new C7zArchive(Reader);
int skipped = 0;
@ -268,6 +268,7 @@ bool F7ZFile::Open(FileSystemFilterInfo *filter, FileSystemMessageFunc Printf)
Entries[j].Length = SzArEx_GetFileSize(archPtr, i);
Entries[j].Flags = RESFF_FULLPATH|RESFF_COMPRESSED;
Entries[j].ResourceID = -1;
Entries[j].Namespace = ns_global;
Entries[j].Method = METHOD_INVALID;
Entries[j].Position = i;
j++;
@ -350,7 +351,7 @@ FileReader F7ZFile::GetEntryReader(uint32_t entry, int, int)
//
//==========================================================================
FResourceFile *Check7Z(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *Check7Z(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[k7zSignatureSize];

13
src/common/filesystem/source/file_directory.cpp
View file

@ -57,11 +57,11 @@ class FDirectory : public FResourceFile
const char** SystemFilePath;
int AddDirectory(const char* dirpath, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf);
int AddDirectory(const char* dirpath, LumpFilterInfo* filter, FileSystemMessageFunc Printf);
public:
FDirectory(const char * dirname, StringPool* sp, bool nosubdirflag = false);
bool Open(FileSystemFilterInfo* filter, FileSystemMessageFunc Printf);
bool Open(LumpFilterInfo* filter, FileSystemMessageFunc Printf);
FileReader GetEntryReader(uint32_t entry, int, int) override;
};
@ -74,7 +74,7 @@ public:
//==========================================================================
FDirectory::FDirectory(const char * directory, StringPool* sp, bool nosubdirflag)
: FResourceFile("", sp, 0), nosubdir(nosubdirflag)
: FResourceFile("", sp), nosubdir(nosubdirflag)
{
auto fn = FS_FullPath(directory);
if (fn.back() != '/') fn += '/';
@ -87,7 +87,7 @@ FDirectory::FDirectory(const char * directory, StringPool* sp, bool nosubdirflag
//
//==========================================================================
int FDirectory::AddDirectory(const char *dirpath, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf)
int FDirectory::AddDirectory(const char *dirpath, LumpFilterInfo* filter, FileSystemMessageFunc Printf)
{
int count = 0;
@ -141,6 +141,7 @@ int FDirectory::AddDirectory(const char *dirpath, FileSystemFilterInfo* filter,
Entries[count].Flags = RESFF_FULLPATH;
Entries[count].ResourceID = -1;
Entries[count].Method = METHOD_STORED;
Entries[count].Namespace = ns_global;
Entries[count].Position = count;
count++;
}
@ -156,7 +157,7 @@ int FDirectory::AddDirectory(const char *dirpath, FileSystemFilterInfo* filter,
//
//==========================================================================
bool FDirectory::Open(FileSystemFilterInfo* filter, FileSystemMessageFunc Printf)
bool FDirectory::Open(LumpFilterInfo* filter, FileSystemMessageFunc Printf)
{
NumLumps = AddDirectory(FileName, filter, Printf);
PostProcessArchive(filter);
@ -192,7 +193,7 @@ FileReader FDirectory::GetEntryReader(uint32_t entry, int readertype, int)
//
//==========================================================================
FResourceFile *CheckDir(const char *filename, bool nosubdirflag, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *CheckDir(const char *filename, bool nosubdirflag, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
auto rf = new FDirectory(filename, sp, nosubdirflag);
if (rf->Open(filter, Printf)) return rf;

7
src/common/filesystem/source/file_grp.cpp
View file

@ -71,7 +71,7 @@ struct GrpLump
//
//==========================================================================
static bool OpenGrp(FResourceFile* file, FileSystemFilterInfo* filter)
static bool OpenGrp(FResourceFile* file, LumpFilterInfo* filter)
{
GrpHeader header;
@ -91,6 +91,7 @@ static bool OpenGrp(FResourceFile* file, FileSystemFilterInfo* filter)
Entries[i].CompressedSize = Entries[i].Length = LittleLong(fileinfo[i].Size);
Position += fileinfo[i].Size;
Entries[i].Flags = 0;
Entries[i].Namespace = ns_global;
fileinfo[i].NameWithZero[12] = '\0'; // Be sure filename is null-terminated
Entries[i].ResourceID = -1;
Entries[i].Method = METHOD_STORED;
@ -108,7 +109,7 @@ static bool OpenGrp(FResourceFile* file, FileSystemFilterInfo* filter)
//
//==========================================================================
FResourceFile *CheckGRP(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *CheckGRP(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[12];
@ -119,7 +120,7 @@ FResourceFile *CheckGRP(const char *filename, FileReader &file, FileSystemFilter
file.Seek(0, FileReader::SeekSet);
if (!memcmp(head, "KenSilverman", 12))
{
auto rf = new FResourceFile(filename, file, sp, FResourceFile::NO_FOLDERS | FResourceFile::SHORTNAMES);
auto rf = new FResourceFile(filename, file, sp);
if (OpenGrp(rf, filter)) return rf;
file = rf->Destroy();
}

7
src/common/filesystem/source/file_hog.cpp
View file

@ -44,7 +44,7 @@ namespace FileSys {
static bool OpenHog(FResourceFile* rf, FileSystemFilterInfo* filter)
static bool OpenHog(FResourceFile* rf, LumpFilterInfo* filter)
{
auto Reader = rf->GetContainerReader();
FileReader::Size length = Reader->GetLength();
@ -66,6 +66,7 @@ static bool OpenHog(FResourceFile* rf, FileSystemFilterInfo* filter)
Entry.CompressedSize = Entry.Length = elength;
Entry.Flags = 0;
Entry.CRC32 = 0;
Entry.Namespace = ns_global;
Entry.ResourceID = -1;
Entry.Method = METHOD_STORED;
Entry.FileName = rf->NormalizeFileName(name);
@ -85,7 +86,7 @@ static bool OpenHog(FResourceFile* rf, FileSystemFilterInfo* filter)
//
//==========================================================================
FResourceFile* CheckHog(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile* CheckHog(const char* filename, FileReader& file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[3];
@ -95,7 +96,7 @@ FResourceFile* CheckHog(const char* filename, FileReader& file, FileSystemFilter
file.Read(&head, 3);
if (!memcmp(head, "DHF", 3))
{
auto rf = new FResourceFile(filename, file, sp, FResourceFile::NO_FOLDERS | FResourceFile::SHORTNAMES);
auto rf = new FResourceFile(filename, file, sp);
if (OpenHog(rf, filter)) return rf;
file = rf->Destroy();
}

107
src/common/filesystem/source/file_hog2.cpp
View file

@ -1,107 +0,0 @@
/*
** file_hog.cpp
**
** reads Descent 3 .hog2 files
**
**---------------------------------------------------------------------------
** Copyright 2024 Christoph Oelckers
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
**
*/
#include "resourcefile.h"
#include "fs_swap.h"
namespace FileSys {
using namespace byteswap;
static bool OpenHog2(FResourceFile* rf, FileSystemFilterInfo* filter)
{
auto Reader = rf->GetContainerReader();
FileReader::Size length = Reader->GetLength();
uint32_t numfiles = Reader->ReadUInt32();
uint32_t offset = Reader->ReadUInt32(); // offset to first file (end of file list)
Reader->Seek(56, FileReader::SeekEnd); // filled with FF
auto Entries = rf->AllocateEntries((int)numfiles);
for(uint32_t i = 0; i < numfiles; i++)
{
char name[37];
Reader->Read(name, 36);
name[36] = 0;
Reader->ReadUInt32();
uint32_t size = Reader->ReadUInt32();;
Reader->ReadUInt32();
FResourceEntry& Entry = Entries[i];
Entry.Position = offset;
Entry.CompressedSize = Entry.Length = size;
Entry.Flags = RESFF_FULLPATH;
Entry.CRC32 = 0;
Entry.ResourceID = -1;
Entry.Method = METHOD_STORED;
Entry.FileName = rf->NormalizeFileName(name);
offset += size;
}
rf->GenerateHash();
return true;
}
//==========================================================================
//
// File open
//
//==========================================================================
FResourceFile* CheckHog2(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[4];
if (file.GetLength() >= 68)
{
file.Seek(0, FileReader::SeekSet);
file.Read(&head, 4);
if (!memcmp(head, "HOG2", 4))
{
auto rf = new FResourceFile(filename, file, sp, 0);
if (OpenHog2(rf, filter)) return rf;
file = rf->Destroy();
}
file.Seek(0, FileReader::SeekSet);
}
return nullptr;
}
}

7
src/common/filesystem/source/file_lump.cpp
View file

@ -41,10 +41,11 @@ namespace FileSys {
//
//==========================================================================
static bool OpenLump(FResourceFile* file, FileSystemFilterInfo*)
static bool OpenLump(FResourceFile* file, LumpFilterInfo*)
{
auto Entries = file->AllocateEntries(1);
Entries[0].FileName = file->NormalizeFileName(ExtractBaseName(file->GetFileName(), true).c_str());
Entries[0].Namespace = ns_global;
Entries[0].ResourceID = -1;
Entries[0].Position = 0;
Entries[0].CompressedSize = Entries[0].Length = file->GetContainerReader()->GetLength();
@ -59,10 +60,10 @@ static bool OpenLump(FResourceFile* file, FileSystemFilterInfo*)
//
//==========================================================================
FResourceFile *CheckLump(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *CheckLump(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
// always succeeds
auto rf = new FResourceFile(filename, file, sp, FResourceFile::NO_FOLDERS);
auto rf = new FResourceFile(filename, file, sp);
if (OpenLump(rf, filter)) return rf;
file = rf->Destroy();
return NULL;

6
src/common/filesystem/source/file_mvl.cpp
View file

@ -43,7 +43,7 @@ namespace FileSys {
static bool OpenMvl(FResourceFile* rf, FileSystemFilterInfo* filter)
static bool OpenMvl(FResourceFile* rf, LumpFilterInfo* filter)
{
auto Reader = rf->GetContainerReader();
auto count = Reader->ReadUInt32();
@ -75,7 +75,7 @@ static bool OpenMvl(FResourceFile* rf, FileSystemFilterInfo* filter)
//
//==========================================================================
FResourceFile* CheckMvl(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile* CheckMvl(const char* filename, FileReader& file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[4];
@ -85,7 +85,7 @@ FResourceFile* CheckMvl(const char* filename, FileReader& file, FileSystemFilter
file.Read(&head, 4);
if (!memcmp(head, "DMVL", 4))
{
auto rf = new FResourceFile(filename, file, sp, FResourceFile::NO_FOLDERS | FResourceFile::SHORTNAMES);
auto rf = new FResourceFile(filename, file, sp);
if (OpenMvl(rf, filter)) return rf;
file = rf->Destroy();
}

7
src/common/filesystem/source/file_pak.cpp
View file

@ -63,7 +63,7 @@ struct dpackheader_t
//
//==========================================================================
static bool OpenPak(FResourceFile* file, FileSystemFilterInfo* filter)
static bool OpenPak(FResourceFile* file, LumpFilterInfo* filter)
{
dpackheader_t header;
@ -82,6 +82,7 @@ static bool OpenPak(FResourceFile* file, FileSystemFilterInfo* filter)
Entries[i].Position = LittleLong(fileinfo[i].filepos);
Entries[i].CompressedSize = Entries[i].Length = LittleLong(fileinfo[i].filelen);
Entries[i].Flags = RESFF_FULLPATH;
Entries[i].Namespace = ns_global;
Entries[i].ResourceID = -1;
Entries[i].Method = METHOD_STORED;
Entries[i].FileName = file->NormalizeFileName(fileinfo[i].name);
@ -98,7 +99,7 @@ static bool OpenPak(FResourceFile* file, FileSystemFilterInfo* filter)
//
//==========================================================================
FResourceFile *CheckPak(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *CheckPak(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[4];
@ -109,7 +110,7 @@ FResourceFile *CheckPak(const char *filename, FileReader &file, FileSystemFilter
file.Seek(0, FileReader::SeekSet);
if (!memcmp(head, "PACK", 4))
{
auto rf = new FResourceFile(filename, file, sp, 0);
auto rf = new FResourceFile(filename, file, sp);
if (OpenPak(rf, filter)) return rf;
file = rf->Destroy();
}

7
src/common/filesystem/source/file_rff.cpp
View file

@ -91,7 +91,7 @@ void BloodCrypt (void *data, int key, int len)
//
//==========================================================================
static bool OpenRFF(FResourceFile* file, FileSystemFilterInfo*)
static bool OpenRFF(FResourceFile* file, LumpFilterInfo*)
{
RFFLump *lumps;
RFFInfo header;
@ -123,6 +123,7 @@ static bool OpenRFF(FResourceFile* file, FileSystemFilterInfo*)
Entries[i].Flags = 0;
Entries[i].Method = METHOD_STORED;
}
Entries[i].Namespace = ns_global;
Entries[i].ResourceID = LittleLong(lumps[i].IndexNum);
// Rearrange the name and extension to construct the fullname.
@ -149,7 +150,7 @@ static bool OpenRFF(FResourceFile* file, FileSystemFilterInfo*)
//
//==========================================================================
FResourceFile *CheckRFF(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *CheckRFF(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[4];
@ -160,7 +161,7 @@ FResourceFile *CheckRFF(const char *filename, FileReader &file, FileSystemFilter
file.Seek(0, FileReader::SeekSet);
if (!memcmp(head, "RFF\x1a", 4))
{
auto rf = new FResourceFile(filename, file, sp, FResourceFile::NO_FOLDERS | FResourceFile::SHORTNAMES);
auto rf = new FResourceFile(filename, file, sp);
if (OpenRFF(rf, filter)) return rf;
file = rf->Destroy();
}

8
src/common/filesystem/source/file_ssi.cpp
View file

@ -44,7 +44,7 @@ namespace FileSys {
//
//==========================================================================
static bool OpenSSI(FResourceFile* file, int version, int EntryCount, FileSystemFilterInfo*)
static bool OpenSSI(FResourceFile* file, int version, int EntryCount, LumpFilterInfo*)
{
uint32_t NumLumps = EntryCount * 2;
auto Entries = file->AllocateEntries(NumLumps);
@ -65,6 +65,7 @@ static bool OpenSSI(FResourceFile* file, int version, int EntryCount, FileSystem
Entries[i].Position = j;
Entries[i].CompressedSize = Entries[i].Length = flength;
Entries[i].Flags = 0;
Entries[i].Namespace = ns_global;
Entries[i].Method = METHOD_STORED;
Entries[i].ResourceID = -1;
Entries[i].FileName = file->NormalizeFileName(fn);
@ -77,6 +78,7 @@ static bool OpenSSI(FResourceFile* file, int version, int EntryCount, FileSystem
Entries[i + 1].Position = j;
Entries[i + 1].CompressedSize = Entries[i + 1].Length = flength;
Entries[i + 1].Flags = 0;
Entries[i + 1].Namespace = ns_global;
Entries[i + 1].ResourceID = -1;
Entries[i + 1].FileName = file->NormalizeFileName(fn);
Entries[i + 1].Method = METHOD_STORED;
@ -97,7 +99,7 @@ static bool OpenSSI(FResourceFile* file, int version, int EntryCount, FileSystem
//
//==========================================================================
FResourceFile* CheckSSI(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile* CheckSSI(const char* filename, FileReader& file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char zerobuf[72];
char buf[72];
@ -127,7 +129,7 @@ FResourceFile* CheckSSI(const char* filename, FileReader& file, FileSystemFilter
{
if (!skipstring(70)) return nullptr;
}
auto ssi = new FResourceFile(filename, file, sp, FResourceFile::NO_FOLDERS | FResourceFile::SHORTNAMES);
auto ssi = new FResourceFile(filename, file, sp);
if (OpenSSI(ssi, version, numfiles, filter)) return ssi;
file = ssi->Destroy();
}

293
src/common/filesystem/source/file_wad.cpp
View file

@ -58,22 +58,52 @@ struct wadlump_t
char Name[8];
};
//==========================================================================
//
// Wad file
//
//==========================================================================
class FWadFile : public FResourceFile
{
bool IsMarker(int lump, const char *marker);
void SetNamespace(const char *startmarker, const char *endmarker, namespace_t space, FileSystemMessageFunc Printf, bool flathack=false);
void SkinHack (FileSystemMessageFunc Printf);
public:
FWadFile(const char * filename, FileReader &file, StringPool* sp);
bool Open(LumpFilterInfo* filter, FileSystemMessageFunc Printf);
};
//==========================================================================
//
// FWadFile::FWadFile
//
// Initializes a WAD file
//
//==========================================================================
FWadFile::FWadFile(const char *filename, FileReader &file, StringPool* sp)
: FResourceFile(filename, file, sp)
{
}
//==========================================================================
//
// Open it
//
//==========================================================================
static bool OpenWAD(FResourceFile* file, FileSystemFilterInfo*, FileSystemMessageFunc Printf)
bool FWadFile::Open(LumpFilterInfo*, FileSystemMessageFunc Printf)
{
wadinfo_t header;
uint32_t InfoTableOfs;
bool isBigEndian = false; // Little endian is assumed until proven otherwise
auto Reader = file->GetContainerReader();
auto wadSize = Reader->GetLength();
auto wadSize = Reader.GetLength();
Reader->Read(&header, sizeof(header));
uint32_t NumLumps = LittleLong(header.NumLumps);
Reader.Read(&header, sizeof(header));
NumLumps = LittleLong(header.NumLumps);
InfoTableOfs = LittleLong(header.InfoTableOfs);
// Check to see if the little endian interpretation is valid
@ -87,16 +117,16 @@ static bool OpenWAD(FResourceFile* file, FileSystemFilterInfo*, FileSystemMessag
// Check again to detect broken wads
if (InfoTableOfs + NumLumps*sizeof(wadlump_t) > (unsigned)wadSize)
{
Printf(FSMessageLevel::Error, "%s: Bad directory offset.\n", file->GetFileName());
Printf(FSMessageLevel::Error, "%s: Bad directory offset.\n", FileName);
return false;
}
}
Reader->Seek(InfoTableOfs, FileReader::SeekSet);
auto fd = Reader->Read(NumLumps * sizeof(wadlump_t));
Reader.Seek(InfoTableOfs, FileReader::SeekSet);
auto fd = Reader.Read(NumLumps * sizeof(wadlump_t));
auto fileinfo = (const wadlump_t*)fd.data();
auto Entries = file->AllocateEntries(NumLumps);
AllocateEntries(NumLumps);
for(uint32_t i = 0; i < NumLumps; i++)
{
@ -113,17 +143,17 @@ static bool OpenWAD(FResourceFile* file, FileSystemFilterInfo*, FileSystemMessag
else if (ishigh > 1)
{
// This may not end up printing something proper because we do not know what encoding might have been used.
Printf(FSMessageLevel::Warning, "%s: Lump name %.8s contains invalid characters\n", file->GetFileName(), fileinfo[i].Name);
n[0] = 0;
Printf(FSMessageLevel::Warning, "%s: Lump name %.8s contains invalid characters\n", FileName, fileinfo[i].Name);
}
Entries[i].FileName = nullptr;
Entries[i].Position = isBigEndian ? BigLong(fileinfo[i].FilePos) : LittleLong(fileinfo[i].FilePos);
Entries[i].CompressedSize = Entries[i].Length = isBigEndian ? BigLong(fileinfo[i].Size) : LittleLong(fileinfo[i].Size);
Entries[i].Namespace = ns_global;
Entries[i].Flags = ishigh? RESFF_SHORTNAME | RESFF_COMPRESSED : RESFF_SHORTNAME;
Entries[i].Method = ishigh == 1? METHOD_LZSS : METHOD_STORED;
Entries[i].FileName = file->NormalizeFileName(n, 0, true);
Entries[i].FileName = stringpool->Strdup(n);
// This doesn't set up the namespace yet.
}
for (uint32_t i = 0; i < NumLumps; i++)
@ -131,21 +161,250 @@ static bool OpenWAD(FResourceFile* file, FileSystemFilterInfo*, FileSystemMessag
if (Entries[i].Method == METHOD_LZSS)
{
// compressed size is implicit.
Entries[i].CompressedSize = (i == NumLumps - 1 ? Reader->GetLength() : Entries[i + 1].Position) - Entries[i].Position;
Entries[i].CompressedSize = (i == NumLumps - 1 ? Reader.GetLength() : Entries[i + 1].Position) - Entries[i].Position;
}
}
file->GenerateHash(); // Do this before the lump processing below.
GenerateHash(); // Do this before the lump processing below.
SetNamespace("s_start", "s_end", ns_sprites, Printf);
SetNamespace("f_start", "f_end", ns_flats, Printf, true);
SetNamespace("c_start", "c_end", ns_colormaps, Printf);
SetNamespace("a_start", "a_end", ns_acslibrary, Printf);
SetNamespace("tx_start", "tx_end", ns_newtextures, Printf);
SetNamespace("v_start", "v_end", ns_strifevoices, Printf);
SetNamespace("hi_start", "hi_end", ns_hires, Printf);
SetNamespace("vx_start", "vx_end", ns_voxels, Printf);
SkinHack(Printf);
return true;
}
//==========================================================================
//
// IsMarker
//
// (from BOOM)
//
//==========================================================================
inline bool FWadFile::IsMarker(int lump, const char *marker)
{
if (Entries[lump].FileName[0] == marker[0])
{
return (!strcmp(Entries[lump].FileName, marker) ||
(marker[1] == '_' && !strcmp(Entries[lump].FileName +1, marker)));
}
else return false;
}
//==========================================================================
//
// SetNameSpace
//
// Sets namespace information for the lumps. It always looks for the first
// x_START and the last x_END lump, except when loading flats. In this case
// F_START may be absent and if that is the case all lumps with a size of
// 4096 will be flagged appropriately.
//
//==========================================================================
// This class was supposed to be local in the function but GCC
// does not like that.
struct Marker
{
int markertype;
unsigned int index;
};
void FWadFile::SetNamespace(const char *startmarker, const char *endmarker, namespace_t space, FileSystemMessageFunc Printf, bool flathack)
{
bool warned = false;
int numstartmarkers = 0, numendmarkers = 0;
unsigned int i;
std::vector<Marker> markers;
for(i = 0; i < NumLumps; i++)
{
if (IsMarker(i, startmarker))
{
Marker m = { 0, i };
markers.push_back(m);
numstartmarkers++;
}
else if (IsMarker(i, endmarker))
{
Marker m = { 1, i };
markers.push_back(m);
numendmarkers++;
}
}
if (numstartmarkers == 0)
{
if (numendmarkers == 0) return; // no markers found
Printf(FSMessageLevel::Warning, "%s: %s marker without corresponding %s found.\n", FileName, endmarker, startmarker);
if (flathack)
{
// We have found no F_START but one or more F_END markers.
// mark all lumps before the last F_END marker as potential flats.
unsigned int end = markers[markers.size()-1].index;
for(unsigned int ii = 0; ii < end; ii++)
{
if (Entries[ii].Length == 4096)
{
// We can't add this to the flats namespace but
// it needs to be flagged for the texture manager.
Printf(FSMessageLevel::DebugNotify, "%s: Marking %s as potential flat\n", FileName, Entries[ii].FileName);
Entries[ii].Flags |= RESFF_MAYBEFLAT;
}
}
}
return;
}
i = 0;
while (i < markers.size())
{
int start, end;
if (markers[i].markertype != 0)
{
Printf(FSMessageLevel::Warning, "%s: %s marker without corresponding %s found.\n", FileName, endmarker, startmarker);
i++;
continue;
}
start = i++;
// skip over subsequent x_START markers
while (i < markers.size() && markers[i].markertype == 0)
{
Printf(FSMessageLevel::Warning, "%s: duplicate %s marker found.\n", FileName, startmarker);
i++;
continue;
}
// same for x_END markers
while (i < markers.size()-1 && (markers[i].markertype == 1 && markers[i+1].markertype == 1))
{
Printf(FSMessageLevel::Warning, "%s: duplicate %s marker found.\n", FileName, endmarker);
i++;
continue;
}
// We found a starting marker but no end marker. Ignore this block.
if (i >= markers.size())
{
Printf(FSMessageLevel::Warning, "%s: %s marker without corresponding %s found.\n", FileName, startmarker, endmarker);
end = NumLumps;
}
else
{
end = markers[i++].index;
}
// we found a marked block
Printf(FSMessageLevel::DebugNotify, "%s: Found %s block at (%d-%d)\n", FileName, startmarker, markers[start].index, end);
for(int j = markers[start].index + 1; j < end; j++)
{
if (Entries[j].Namespace != ns_global)
{
if (!warned)
{
Printf(FSMessageLevel::Warning, "%s: Overlapping namespaces found (lump %d)\n", FileName, j);
}
warned = true;
}
else if (space == ns_sprites && Entries[j].Length < 8)
{
// sf 26/10/99:
// ignore sprite lumps smaller than 8 bytes (the smallest possible)
// in size -- this was used by some dmadds wads
// as an 'empty' graphics resource
Printf(FSMessageLevel::DebugWarn, "%s: Skipped empty sprite %s (lump %d)\n", FileName, Entries[j].FileName, j);
}
else
{
Entries[j].Namespace = space;
}
}
}
}
//==========================================================================
//
// W_SkinHack
//
// Tests a wad file to see if it contains an S_SKIN marker. If it does,
// every lump in the wad is moved into a new namespace. Because skins are
// only supposed to replace player sprites, sounds, or faces, this should
// not be a problem. Yes, there are skins that replace more than that, but
// they are such a pain, and breaking them like this was done on purpose.
// This also renames any S_SKINxx lumps to just S_SKIN.
//
//==========================================================================
void FWadFile::SkinHack (FileSystemMessageFunc Printf)
{
// this being static is not a problem. The only relevant thing is that each skin gets a different number.
static int namespc = ns_firstskin;
bool skinned = false;
bool hasmap = false;
uint32_t i;
for (i = 0; i < NumLumps; i++)
{
auto lump = &Entries[i];
if (!strnicmp(lump->FileName, "S_SKIN", 6))
{ // Wad has at least one skin.
lump->FileName = "S_SKIN";
if (!skinned)
{
skinned = true;
uint32_t j;
for (j = 0; j < NumLumps; j++)
{
Entries[j].Namespace = namespc;
}
namespc++;
}
}
// needless to say, this check is entirely useless these days as map names can be more diverse..
if ((lump->FileName[0] == 'M' &&
lump->FileName[1] == 'A' &&
lump->FileName[2] == 'P' &&
lump->FileName[3] >= '0' && lump->FileName[3] <= '9' &&
lump->FileName[4] >= '0' && lump->FileName[4] <= '9' &&
lump->FileName[5] == '\0')
||
(lump->FileName[0] == 'E' &&
lump->FileName[1] >= '0' && lump->FileName[1] <= '9' &&
lump->FileName[2] == 'M' &&
lump->FileName[3] >= '0' && lump->FileName[3] <= '9' &&
lump->FileName[4] == '\0'))
{
hasmap = true;
}
}
if (skinned && hasmap)
{
Printf(FSMessageLevel::Attention, "%s: The maps will not be loaded because it has a skin.\n", FileName);
Printf(FSMessageLevel::Attention, "You should remove the skin from the wad to play these maps.\n");
}
}
//==========================================================================
//
// File open
//
//==========================================================================
FResourceFile *CheckWad(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *CheckWad(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[4];
@ -156,8 +415,8 @@ FResourceFile *CheckWad(const char *filename, FileReader &file, FileSystemFilter
file.Seek(0, FileReader::SeekSet);
if (!memcmp(head, "IWAD", 4) || !memcmp(head, "PWAD", 4))
{
auto rf = new FResourceFile(filename, file, sp, FResourceFile::NO_FOLDERS | FResourceFile::NO_EXTENSIONS | FResourceFile::SHORTNAMES);
if (OpenWAD(rf, filter, Printf)) return rf;
auto rf = new FWadFile(filename, file, sp);
if (rf->Open(filter, Printf)) return rf;
file = rf->Destroy();
}

7
src/common/filesystem/source/file_whres.cpp
View file

@ -47,7 +47,7 @@ namespace FileSys {
//
//==========================================================================
bool OpenWHRes(FResourceFile* file, FileSystemFilterInfo*)
bool OpenWHRes(FResourceFile* file, LumpFilterInfo*)
{
uint32_t directory[1024];
@ -83,6 +83,7 @@ bool OpenWHRes(FResourceFile* file, FileSystemFilterInfo*)
Entries[i].Position = offset;
Entries[i].CompressedSize = Entries[i].Length = length;
Entries[i].Flags = RESFF_FULLPATH;
Entries[i].Namespace = ns_global;
Entries[i].ResourceID = -1;
Entries[i].Method = METHOD_STORED;
Entries[i].FileName = file->NormalizeFileName(synthname.c_str());
@ -98,7 +99,7 @@ bool OpenWHRes(FResourceFile* file, FileSystemFilterInfo*)
//
//==========================================================================
FResourceFile *CheckWHRes(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *CheckWHRes(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
if (file.GetLength() >= 8192) // needs to be at least 8192 to contain one file and the directory.
{
@ -118,7 +119,7 @@ FResourceFile *CheckWHRes(const char *filename, FileReader &file, FileSystemFilt
if (offset != checkpos || length == 0 || offset + length >= (size_t)size - 4096 ) return nullptr;
checkpos += (length+4095) / 4096;
}
auto rf = new FResourceFile(filename, file, sp, FResourceFile::NO_EXTENSIONS);
auto rf = new FResourceFile(filename, file, sp);
if (OpenWHRes(rf, filter)) return rf;
file = rf->Destroy();
}

8
src/common/filesystem/source/file_zip.cpp
View file

@ -113,7 +113,7 @@ class FZipFile : public FResourceFile
public:
FZipFile(const char* filename, FileReader& file, StringPool* sp);
bool Open(FileSystemFilterInfo* filter, FileSystemMessageFunc Printf);
bool Open(LumpFilterInfo* filter, FileSystemMessageFunc Printf);
FCompressedBuffer GetRawData(uint32_t entry) override;
};
@ -124,11 +124,11 @@ public:
//==========================================================================
FZipFile::FZipFile(const char * filename, FileReader &file, StringPool* sp)
: FResourceFile(filename, file, sp, 0)
: FResourceFile(filename, file, sp)
{
}
bool FZipFile::Open(FileSystemFilterInfo* filter, FileSystemMessageFunc Printf)
bool FZipFile::Open(LumpFilterInfo* filter, FileSystemMessageFunc Printf)
{
bool zip64 = false;
uint32_t centraldir = Zip_FindCentralDir(Reader, &zip64);
@ -376,7 +376,7 @@ void FZipFile::SetEntryAddress(uint32_t entry)
//
//==========================================================================
FResourceFile *CheckZip(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *CheckZip(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
char head[4];

669
src/common/filesystem/source/filesystem.cpp
View file

File diff suppressed because it is too large Load diff

55
src/common/filesystem/source/resourcefile.cpp
View file

@ -113,7 +113,7 @@ bool FResourceFile::IsFileInFolder(const char* const resPath)
return 0 == stricmp(filePath.c_str(), resPath);
}
void FResourceFile::CheckEmbedded(uint32_t entry, FileSystemFilterInfo* lfi)
void FResourceFile::CheckEmbedded(uint32_t entry, LumpFilterInfo* lfi)
{
// Checks for embedded archives
auto FullName = Entries[entry].FileName;
@ -138,30 +138,29 @@ void FResourceFile::CheckEmbedded(uint32_t entry, FileSystemFilterInfo* lfi)
//
//==========================================================================
typedef FResourceFile * (*CheckFunc)(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
typedef FResourceFile * (*CheckFunc)(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckWad(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckGRP(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckRFF(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckPak(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckZip(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *Check7Z(const char *filename, FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckSSI(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckHog(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckHog2(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckMvl(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckWHRes(const char* filename, FileReader& file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckLump(const char *filename,FileReader &file, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckDir(const char *filename, bool nosub, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckWad(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckGRP(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckRFF(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckPak(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckZip(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *Check7Z(const char *filename, FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckSSI(const char* filename, FileReader& file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckHog(const char* filename, FileReader& file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckMvl(const char* filename, FileReader& file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile* CheckWHRes(const char* filename, FileReader& file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckLump(const char *filename,FileReader &file, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
FResourceFile *CheckDir(const char *filename, bool nosub, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp);
static CheckFunc funcs[] = { CheckWad, CheckZip, Check7Z, CheckPak, CheckGRP, CheckRFF, CheckHog, CheckMvl, CheckHog2, CheckSSI, CheckWHRes, CheckLump };
static CheckFunc funcs[] = { CheckWad, CheckZip, Check7Z, CheckPak, CheckGRP, CheckRFF, CheckSSI, CheckHog, CheckMvl, CheckWHRes, CheckLump };
static int nulPrintf(FSMessageLevel msg, const char* fmt, ...)
{
return 0;
}
FResourceFile *FResourceFile::DoOpenResourceFile(const char *filename, FileReader &file, bool containeronly, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *FResourceFile::DoOpenResourceFile(const char *filename, FileReader &file, bool containeronly, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
if (!file.isOpen()) return nullptr;
if (Printf == nullptr) Printf = nulPrintf;
@ -174,20 +173,20 @@ FResourceFile *FResourceFile::DoOpenResourceFile(const char *filename, FileReade
return NULL;
}
FResourceFile *FResourceFile::OpenResourceFile(const char *filename, FileReader &file, bool containeronly, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *FResourceFile::OpenResourceFile(const char *filename, FileReader &file, bool containeronly, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
return DoOpenResourceFile(filename, file, containeronly, filter, Printf, sp);
}
FResourceFile *FResourceFile::OpenResourceFile(const char *filename, bool containeronly, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *FResourceFile::OpenResourceFile(const char *filename, bool containeronly, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
FileReader file;
if (!file.OpenFile(filename)) return nullptr;
return DoOpenResourceFile(filename, file, containeronly, filter, Printf, sp);
}
FResourceFile *FResourceFile::OpenDirectory(const char *filename, FileSystemFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
FResourceFile *FResourceFile::OpenDirectory(const char *filename, LumpFilterInfo* filter, FileSystemMessageFunc Printf, StringPool* sp)
{
if (Printf == nullptr) Printf = nulPrintf;
return CheckDir(filename, false, filter, Printf, sp);
@ -199,15 +198,14 @@ FResourceFile *FResourceFile::OpenDirectory(const char *filename, FileSystemFilt
//
//==========================================================================
FResourceFile::FResourceFile(const char *filename, StringPool* sp, int flags_)
:flags(flags_)
FResourceFile::FResourceFile(const char *filename, StringPool* sp)
{
stringpool = sp ? sp : new StringPool(false);
FileName = stringpool->Strdup(filename);
}
FResourceFile::FResourceFile(const char *filename, FileReader &r, StringPool* sp, int flags)
: FResourceFile(filename,sp, flags)
FResourceFile::FResourceFile(const char *filename, FileReader &r, StringPool* sp)
: FResourceFile(filename,sp)
{
Reader = std::move(r);
}
@ -252,7 +250,7 @@ FCompressedBuffer FResourceFile::GetRawData(uint32_t entry)
//
//==========================================================================
const char* FResourceFile::NormalizeFileName(const char* fn, int fallbackcp, bool allowbackslash)
const char* FResourceFile::NormalizeFileName(const char* fn, int fallbackcp)
{
if (!fn || !*fn) return "";
auto norm = tolower_normalize(fn);
@ -276,8 +274,7 @@ const char* FResourceFile::NormalizeFileName(const char* fn, int fallbackcp, boo
norm = tolower_normalize(&ffn.front());
}
}
// The WAD format can have legal backslashes in its names so this must be optional.
if (!allowbackslash) FixPathSeparator(norm);
FixPathSeparator(norm);
auto pooled = stringpool->Strdup(norm);
free(norm);
return pooled;
@ -357,7 +354,7 @@ void FResourceFile::GenerateHash()
//
//==========================================================================
void FResourceFile::PostProcessArchive(FileSystemFilterInfo *filter)
void FResourceFile::PostProcessArchive(LumpFilterInfo *filter)
{
// only do this for archive types which contain full file names. All others are assumed to be pre-sorted.
if (NumLumps == 0 || !(Entries[0].Flags & RESFF_FULLPATH)) return;
@ -419,7 +416,7 @@ void FResourceFile::PostProcessArchive(FileSystemFilterInfo *filter)
//
//==========================================================================
void FResourceFile::FindCommonFolder(FileSystemFilterInfo* filter)
void FResourceFile::FindCommonFolder(LumpFilterInfo* filter)
{
std::string name0, name1;
bool foundspeciallump = false;

6
src/common/fonts/v_font.cpp
View file

@ -120,7 +120,7 @@ FFont *V_GetFont(const char *name, const char *fontlumpname)
}
lump = fileSystem.CheckNumForAnyName(fontlumpname? fontlumpname : name);
lump = fileSystem.CheckNumForFullName(fontlumpname? fontlumpname : name, true);
if (lump != -1 && fileSystem.GetFileContainer(lump) >= folderfile)
{
@ -290,7 +290,7 @@ void V_InitCustomFonts()
{
*p = TexMan.GetGameTexture(texid);
}
else if (fileSystem.GetFileContainer(sc.LumpNum) >= fileSystem.GetBaseNum())
else if (fileSystem.GetFileContainer(sc.LumpNum) >= fileSystem.GetIwadNum())
{
// Print a message only if this isn't in zdoom.pk3
sc.ScriptMessage("%s: Unable to find texture in font definition for %s", sc.String, namebuffer.GetChars());
@ -871,7 +871,7 @@ void V_InitFonts()
FFont *CreateHexLumpFont(const char *fontname, int lump);
FFont *CreateHexLumpFont2(const char *fontname, int lump);
auto lump = fileSystem.GetFileInContainer("newconsolefont.hex", 0); // This is always loaded from gzdoom.pk3 to prevent overriding it with incomplete replacements.
auto lump = fileSystem.CheckNumForFullName("newconsolefont.hex", 0); // This is always loaded from gzdoom.pk3 to prevent overriding it with incomplete replacements.
if (lump == -1) I_FatalError("newconsolefont.hex not found"); // This font is needed - do not start up without it.
NewConsoleFont = CreateHexLumpFont("NewConsoleFont", lump);
NewSmallFont = CreateHexLumpFont2("NewSmallFont", lump);

2
src/common/menu/menudef.cpp
View file

@ -1524,7 +1524,7 @@ void M_ParseMenuDefs()
DefaultOptionMenuSettings->Reset();
OptionSettings.mLinespacing = 17;
int IWADMenu = fileSystem.CheckNumForName("MENUDEF", ns_global, fileSystem.GetBaseNum());
int IWADMenu = fileSystem.CheckNumForName("MENUDEF", FileSys::ns_global, fileSystem.GetIwadNum());
while ((lump = fileSystem.FindLump ("MENUDEF", &lastlump)) != -1)
{

12
src/common/models/model.cpp
View file

@ -88,7 +88,7 @@ void FModel::DestroyVertexBuffer()
static int FindGFXFile(FString & fn)
{
int lump = fileSystem.FindFile(fn.GetChars()); // if we find something that matches the name plus the extension, return it and do not enter the substitution logic below.
int lump = fileSystem.CheckNumForFullName(fn.GetChars()); // if we find something that matches the name plus the extension, return it and do not enter the substitution logic below.
if (lump != -1) return lump;
int best = -1;
@ -100,7 +100,7 @@ static int FindGFXFile(FString & fn)
for (const char ** extp=extensions; *extp; extp++)
{
lump = fileSystem.FindFile((fn + *extp).GetChars());
lump = fileSystem.CheckNumForFullName((fn + *extp).GetChars());
if (lump >= best) best = lump;
}
return best;
@ -120,7 +120,7 @@ FTextureID LoadSkin(const char * path, const char * fn)
buffer.Format("%s%s", path, fn);
int texlump = FindGFXFile(buffer);
const char * const texname = texlump < 0 ? fn : fileSystem.GetFileName(texlump);
const char * const texname = texlump < 0 ? fn : fileSystem.GetFileFullName(texlump);
return TexMan.CheckForTexture(texname, ETextureType::Any, FTextureManager::TEXMAN_TryAny | FTextureManager::TEXMAN_ForceLookup);
}
@ -148,7 +148,7 @@ unsigned FindModel(const char * path, const char * modelfile, bool silent)
if (path) fullname.Format("%s%s", path, modelfile);
else fullname = modelfile;
int lump = fileSystem.FindFile(fullname.GetChars());
int lump = fileSystem.CheckNumForFullName(fullname.GetChars());
if (lump<0)
{
@ -175,7 +175,7 @@ unsigned FindModel(const char * path, const char * modelfile, bool silent)
{
FString anivfile = fullname.GetChars();
anivfile.Substitute("_d.3d","_a.3d");
if ( fileSystem.FindFile(anivfile.GetChars()) > 0 )
if ( fileSystem.CheckNumForFullName(anivfile.GetChars()) > 0 )
{
model = new FUE1Model;
}
@ -184,7 +184,7 @@ unsigned FindModel(const char * path, const char * modelfile, bool silent)
{
FString datafile = fullname.GetChars();
datafile.Substitute("_a.3d","_d.3d");
if ( fileSystem.FindFile(datafile.GetChars()) > 0 )
if ( fileSystem.CheckNumForFullName(datafile.GetChars()) > 0 )
{
model = new FUE1Model;
}

6
src/common/models/models_ue1.cpp
View file

@ -49,18 +49,18 @@ bool FUE1Model::Load( const char *filename, int lumpnum, const char *buffer, int
{
int lumpnum2;
hasSurfaces = true;
FString realfilename = fileSystem.GetFileName(lumpnum);
FString realfilename = fileSystem.GetFileFullName(lumpnum);
if ( (size_t)realfilename.IndexOf("_d.3d") == realfilename.Len()-5 )
{
realfilename.Substitute("_d.3d","_a.3d");
lumpnum2 = fileSystem.FindFile(realfilename.GetChars());
lumpnum2 = fileSystem.CheckNumForFullName(realfilename.GetChars());
mDataLump = lumpnum;
mAnivLump = lumpnum2;
}
else
{
realfilename.Substitute("_a.3d","_d.3d");
lumpnum2 = fileSystem.FindFile(realfilename.GetChars());
lumpnum2 = fileSystem.CheckNumForFullName(realfilename.GetChars());
mAnivLump = lumpnum;
mDataLump = lumpnum2;
}

2
src/common/models/voxels.cpp
View file

@ -309,7 +309,7 @@ FVoxelDef *R_LoadVoxelDef(int lumpnum, int spin)
FVoxel *vox = R_LoadKVX(lumpnum);
if (vox == NULL)
{
Printf("%s is not a valid voxel file\n", fileSystem.GetFileName(lumpnum));
Printf("%s is not a valid voxel file\n", fileSystem.GetFileFullName(lumpnum));
return NULL;
}
else

16
src/common/rendering/gl/gl_shader.cpp
View file

@ -373,10 +373,10 @@ bool FShader::Load(const char * name, const char * vert_prog_lump, const char *
i_data += "#define NPOT_EMULATION\nuniform vec2 uNpotEmulation;\n";
#endif
int vp_lump = fileSystem.GetFileInContainer(vert_prog_lump, 0);
int vp_lump = fileSystem.CheckNumForFullName(vert_prog_lump, 0);
if (vp_lump == -1) I_Error("Unable to load '%s'", vert_prog_lump);
int fp_lump = fileSystem.GetFileInContainer(frag_prog_lump, 0);
int fp_lump = fileSystem.CheckNumForFullName(frag_prog_lump, 0);
if (fp_lump == -1) I_Error("Unable to load '%s'", frag_prog_lump);
@ -418,8 +418,8 @@ bool FShader::Load(const char * name, const char * vert_prog_lump, const char *
if (*proc_prog_lump != '#')
{
int pp_lump = fileSystem.GetFileInContainer(proc_prog_lump, 0); // if it's a core shader, ignore overrides by user mods.
if (pp_lump == -1) pp_lump = fileSystem.FindFile(proc_prog_lump);
int pp_lump = fileSystem.CheckNumForFullName(proc_prog_lump, 0); // if it's a core shader, ignore overrides by user mods.
if (pp_lump == -1) pp_lump = fileSystem.CheckNumForFullName(proc_prog_lump);
if (pp_lump == -1) I_Error("Unable to load '%s'", proc_prog_lump);
FString pp_data = GetStringFromLump(pp_lump);
@ -429,13 +429,13 @@ bool FShader::Load(const char * name, const char * vert_prog_lump, const char *
if (pp_data.IndexOf("GetTexCoord") >= 0)
{
int pl_lump = fileSystem.GetFileInContainer("shaders/glsl/func_defaultmat2.fp", 0);
int pl_lump = fileSystem.CheckNumForFullName("shaders/glsl/func_defaultmat2.fp", 0);
if (pl_lump == -1) I_Error("Unable to load '%s'", "shaders/glsl/func_defaultmat2.fp");
fp_comb << "\n" << GetStringFromLump(pl_lump);
}
else
{
int pl_lump = fileSystem.GetFileInContainer("shaders/glsl/func_defaultmat.fp", 0);
int pl_lump = fileSystem.CheckNumForFullName("shaders/glsl/func_defaultmat.fp", 0);
if (pl_lump == -1) I_Error("Unable to load '%s'", "shaders/glsl/func_defaultmat.fp");
fp_comb << "\n" << GetStringFromLump(pl_lump);
@ -461,7 +461,7 @@ bool FShader::Load(const char * name, const char * vert_prog_lump, const char *
if (pp_data.IndexOf("ProcessLight") < 0)
{
int pl_lump = fileSystem.GetFileInContainer("shaders/glsl/func_defaultlight.fp", 0);
int pl_lump = fileSystem.CheckNumForFullName("shaders/glsl/func_defaultlight.fp", 0);
if (pl_lump == -1) I_Error("Unable to load '%s'", "shaders/glsl/func_defaultlight.fp");
fp_comb << "\n" << GetStringFromLump(pl_lump);
}
@ -483,7 +483,7 @@ bool FShader::Load(const char * name, const char * vert_prog_lump, const char *
if (light_fragprog)
{
int pp_lump = fileSystem.GetFileInContainer(light_fragprog, 0);
int pp_lump = fileSystem.CheckNumForFullName(light_fragprog, 0);
if (pp_lump == -1) I_Error("Unable to load '%s'", light_fragprog);
fp_comb << GetStringFromLump(pp_lump) << "\n";
}

2
src/common/rendering/gl/gl_shaderprogram.cpp
View file

@ -87,7 +87,7 @@ void FShaderProgram::CreateShader(ShaderType type)
void FShaderProgram::Compile(ShaderType type, const char *lumpName, const char *defines, int maxGlslVersion)
{
int lump = fileSystem.FindFile(lumpName);
int lump = fileSystem.CheckNumForFullName(lumpName);
if (lump == -1) I_FatalError("Unable to load '%s'", lumpName);
FString code = GetStringFromLump(lump);

14
src/common/rendering/gles/gles_shader.cpp
View file

@ -381,10 +381,10 @@ bool FShader::Load(const char * name, const char * vert_prog_lump_, const char *
i_data += "#define NPOT_EMULATION\nuniform vec2 uNpotEmulation;\n";
#endif
int vp_lump = fileSystem.GetFileInContainer(vert_prog_lump.GetChars(), 0);
int vp_lump = fileSystem.CheckNumForFullName(vert_prog_lump.GetChars(), 0);
if (vp_lump == -1) I_Error("Unable to load '%s'", vert_prog_lump.GetChars());
int fp_lump = fileSystem.GetFileInContainer(frag_prog_lump.GetChars(), 0);
int fp_lump = fileSystem.CheckNumForFullName(frag_prog_lump.GetChars(), 0);
if (fp_lump == -1) I_Error("Unable to load '%s'", frag_prog_lump.GetChars());
@ -418,7 +418,7 @@ bool FShader::Load(const char * name, const char * vert_prog_lump_, const char *
if (proc_prog_lump[0] != '#')
{
int pp_lump = fileSystem.FindFile(proc_prog_lump.GetChars());
int pp_lump = fileSystem.CheckNumForFullName(proc_prog_lump.GetChars());
if (pp_lump == -1) I_Error("Unable to load '%s'", proc_prog_lump.GetChars());
FString pp_data = GetStringFromLump(pp_lump);
@ -428,13 +428,13 @@ bool FShader::Load(const char * name, const char * vert_prog_lump_, const char *
if (pp_data.IndexOf("GetTexCoord") >= 0)
{
int pl_lump = fileSystem.GetFileInContainer("shaders_gles/glsl/func_defaultmat2.fp", 0);
int pl_lump = fileSystem.CheckNumForFullName("shaders_gles/glsl/func_defaultmat2.fp", 0);
if (pl_lump == -1) I_Error("Unable to load '%s'", "shaders_gles/glsl/func_defaultmat2.fp");
fp_comb << "\n" << GetStringFromLump(pl_lump);
}
else
{
int pl_lump = fileSystem.GetFileInContainer("shaders_gles/glsl/func_defaultmat.fp", 0);
int pl_lump = fileSystem.CheckNumForFullName("shaders_gles/glsl/func_defaultmat.fp", 0);
if (pl_lump == -1) I_Error("Unable to load '%s'", "shaders_gles/glsl/func_defaultmat.fp");
fp_comb << "\n" << GetStringFromLump(pl_lump);
@ -460,7 +460,7 @@ bool FShader::Load(const char * name, const char * vert_prog_lump_, const char *
if (pp_data.IndexOf("ProcessLight") < 0)
{
int pl_lump = fileSystem.GetFileInContainer("shaders_gles/glsl/func_defaultlight.fp", 0);
int pl_lump = fileSystem.CheckNumForFullName("shaders_gles/glsl/func_defaultlight.fp", 0);
if (pl_lump == -1) I_Error("Unable to load '%s'", "shaders_gles/glsl/func_defaultlight.fp");
fp_comb << "\n" << GetStringFromLump(pl_lump);
}
@ -482,7 +482,7 @@ bool FShader::Load(const char * name, const char * vert_prog_lump_, const char *
if (light_fragprog.Len())
{
int pp_lump = fileSystem.GetFileInContainer(light_fragprog.GetChars(), 0);
int pp_lump = fileSystem.CheckNumForFullName(light_fragprog.GetChars(), 0);
if (pp_lump == -1) I_Error("Unable to load '%s'", light_fragprog.GetChars());
fp_comb << GetStringFromLump(pp_lump) << "\n";
}

2
src/common/rendering/gles/gles_shaderprogram.cpp
View file

@ -87,7 +87,7 @@ void FShaderProgram::CreateShader(ShaderType type)
void FShaderProgram::Compile(ShaderType type, const char *lumpName, const char *defines, int maxGlslVersion)
{
int lump = fileSystem.FindFile(lumpName);
int lump = fileSystem.CheckNumForFullName(lumpName);
if (lump == -1) I_FatalError("Unable to load '%s'", lumpName);
FString code = GetStringFromLump(lump);
Compile(type, lumpName, code, defines, maxGlslVersion);

2
src/common/rendering/vulkan/shaders/vk_ppshader.cpp
View file

@ -67,7 +67,7 @@ void VkPPShader::Reset()
FString VkPPShader::LoadShaderCode(const FString &lumpName, const FString &defines, int version)
{
int lump = fileSystem.FindFile(lumpName.GetChars());
int lump = fileSystem.CheckNumForFullName(lumpName.GetChars());
if (lump == -1) I_FatalError("Unable to load '%s'", lumpName.GetChars());
FString code = GetStringFromLump(lump);

6
src/common/rendering/vulkan/shaders/vk_shader.cpp
View file

@ -465,15 +465,15 @@ FString VkShaderManager::GetTargetGlslVersion()
FString VkShaderManager::LoadPublicShaderLump(const char *lumpname)
{
int lump = fileSystem.GetFileInContainer(lumpname, 0);
if (lump == -1) lump = fileSystem.FindFile(lumpname);
int lump = fileSystem.CheckNumForFullName(lumpname, 0);
if (lump == -1) lump = fileSystem.CheckNumForFullName(lumpname);
if (lump == -1) I_Error("Unable to load '%s'", lumpname);
return GetStringFromLump(lump);
}
FString VkShaderManager::LoadPrivateShaderLump(const char *lumpname)
{
int lump = fileSystem.GetFileInContainer(lumpname, 0);
int lump = fileSystem.CheckNumForFullName(lumpname, 0);
if (lump == -1) I_Error("Unable to load '%s'", lumpname);
return GetStringFromLump(lump);
}

2
src/common/scripting/core/types.cpp
View file

@ -2585,7 +2585,7 @@ static void PMapValueWriter(FSerializer &ar, const M *map, const PMap *m)
if (TexMan.GetLinkedTexture(lump) == tex)
{
name = fileSystem.GetFileName(lump);
name = fileSystem.GetFileFullName(lump);
}
else
{

6
src/common/scripting/frontend/zcc_parser.cpp
View file

@ -304,7 +304,7 @@ static void ParseSingleFile(FScanner *pSC, const char *filename, int lump, void
{
if (filename != nullptr)
{
lump = fileSystem.CheckNumForAnyName(filename);
lump = fileSystem.CheckNumForFullName(filename, true);
if (lump >= 0)
{
lsc.OpenLumpNum(lump);
@ -480,7 +480,7 @@ PNamespace *ParseOneScript(const int baselump, ZCCParseState &state)
ParseSingleFile(&sc, nullptr, lumpnum, parser, state);
for (unsigned i = 0; i < Includes.Size(); i++)
{
lumpnum = fileSystem.CheckNumForAnyName(Includes[i].GetChars());
lumpnum = fileSystem.CheckNumForFullName(Includes[i].GetChars(), true);
if (lumpnum == -1)
{
IncludeLocs[i].Message(MSG_ERROR, "Include script lump %s not found", Includes[i].GetChars());
@ -491,7 +491,7 @@ PNamespace *ParseOneScript(const int baselump, ZCCParseState &state)
if (fileno == 0 && fileno2 != 0)
{
I_FatalError("File %s is overriding core lump %s.",
fileSystem.GetContainerFullName(fileSystem.GetFileContainer(lumpnum)), Includes[i].GetChars());
fileSystem.GetResourceFileFullName(fileSystem.GetFileContainer(lumpnum)), Includes[i].GetChars());
}
ParseSingleFile(nullptr, nullptr, lumpnum, parser, state);

14
src/common/scripting/interface/vmnatives.cpp
View file

@ -426,7 +426,7 @@ DEFINE_ACTION_FUNCTION(_TexMan, GetName)
// Textures for full path names do not have their own name, they merely link to the source lump.
auto lump = tex->GetSourceLump();
if (TexMan.GetLinkedTexture(lump) == tex)
retval = fileSystem.GetFileName(lump);
retval = fileSystem.GetFileFullName(lump);
}
}
ACTION_RETURN_STRING(retval);
@ -799,7 +799,7 @@ DEFINE_ACTION_FUNCTION_NATIVE(FFont, GetChar, ::GetChar)
DEFINE_ACTION_FUNCTION(_Wads, GetNumLumps)
{
PARAM_PROLOGUE;
ACTION_RETURN_INT(fileSystem.GetFileCount());
ACTION_RETURN_INT(fileSystem.GetNumEntries());
}
DEFINE_ACTION_FUNCTION(_Wads, CheckNumForName)
@ -816,7 +816,7 @@ DEFINE_ACTION_FUNCTION(_Wads, CheckNumForFullName)
{
PARAM_PROLOGUE;
PARAM_STRING(name);
ACTION_RETURN_INT(fileSystem.FindFile(name.GetChars()));
ACTION_RETURN_INT(fileSystem.CheckNumForFullName(name.GetChars()));
}
DEFINE_ACTION_FUNCTION(_Wads, FindLump)
@ -825,7 +825,7 @@ DEFINE_ACTION_FUNCTION(_Wads, FindLump)
PARAM_STRING(name);
PARAM_INT(startlump);
PARAM_INT(ns);
const bool isLumpValid = startlump >= 0 && startlump < fileSystem.GetFileCount();
const bool isLumpValid = startlump >= 0 && startlump < fileSystem.GetNumEntries();
ACTION_RETURN_INT(isLumpValid ? fileSystem.FindLump(name.GetChars(), &startlump, 0 != ns) : -1);
}
@ -835,7 +835,7 @@ DEFINE_ACTION_FUNCTION(_Wads, FindLumpFullName)
PARAM_STRING(name);
PARAM_INT(startlump);
PARAM_BOOL(noext);
const bool isLumpValid = startlump >= 0 && startlump < fileSystem.GetFileCount();
const bool isLumpValid = startlump >= 0 && startlump < fileSystem.GetNumEntries();
ACTION_RETURN_INT(isLumpValid ? fileSystem.FindLumpFullName(name.GetChars(), &startlump, noext) : -1);
}
@ -850,7 +850,7 @@ DEFINE_ACTION_FUNCTION(_Wads, GetLumpFullName)
{
PARAM_PROLOGUE;
PARAM_INT(lump);
ACTION_RETURN_STRING(fileSystem.GetFileName(lump));
ACTION_RETURN_STRING(fileSystem.GetFileFullName(lump));
}
DEFINE_ACTION_FUNCTION(_Wads, GetLumpNamespace)
@ -864,7 +864,7 @@ DEFINE_ACTION_FUNCTION(_Wads, ReadLump)
{
PARAM_PROLOGUE;
PARAM_INT(lump);
const bool isLumpValid = lump >= 0 && lump < fileSystem.GetFileCount();
const bool isLumpValid = lump >= 0 && lump < fileSystem.GetNumEntries();
ACTION_RETURN_STRING(isLumpValid ? GetStringFromLump(lump, false) : FString());
}

4
src/common/startscreen/endoom.cpp
View file

@ -153,14 +153,14 @@ int RunEndoom()
return 0;
}
int endoom_lump = fileSystem.CheckNumForAnyName (endoomName.GetChars());
int endoom_lump = fileSystem.CheckNumForFullName (endoomName.GetChars(), true);
if (endoom_lump < 0 || fileSystem.FileLength (endoom_lump) != 4000)
{
return 0;
}
if (fileSystem.GetFileContainer(endoom_lump) == fileSystem.GetMaxBaseNum() && showendoom == 2)
if (fileSystem.GetFileContainer(endoom_lump) == fileSystem.GetMaxIwadNum() && showendoom == 2)
{
// showendoom==2 means to show only lumps from PWADs.
return 0;

2
src/common/startscreen/startscreen_generic.cpp
View file

@ -72,7 +72,7 @@ FGenericStartScreen::FGenericStartScreen(int max_progress)
: FStartScreen(max_progress)
{
// at this point we do not have a working texture manager yet, so we have to do the lookup via the file system
int startup_lump = fileSystem.CheckNumForName("BOOTLOGO", ns_graphics);
int startup_lump = fileSystem.CheckNumForName("BOOTLOGO", FileSys::ns_graphics);
StartupBitmap.Create(640 * 2, 480 * 2);
ClearBlock(StartupBitmap, { 0, 0, 0, 255 }, 0, 0, 640 * 2, 480 * 2);

6
src/common/startscreen/startscreen_hexen.cpp
View file

@ -81,9 +81,9 @@ FHexenStartScreen::FHexenStartScreen(int max_progress)
: FStartScreen(max_progress)
{
// at this point we do not have a working texture manager yet, so we have to do the lookup via the file system
int startup_lump = fileSystem.CheckNumForName("STARTUP", ns_graphics);
int netnotch_lump = fileSystem.CheckNumForName("NETNOTCH", ns_graphics);
int notch_lump = fileSystem.CheckNumForName("NOTCH", ns_graphics);
int startup_lump = fileSystem.CheckNumForName("STARTUP", FileSys::ns_graphics);
int netnotch_lump = fileSystem.CheckNumForName("NETNOTCH", FileSys::ns_graphics);
int notch_lump = fileSystem.CheckNumForName("NOTCH", FileSys::ns_graphics);
// For backwards compatibility we also need to look in the default namespace, because these were previously not handled as graphics.
if (startup_lump == -1) startup_lump = fileSystem.CheckNumForName("STARTUP");

2
src/common/startscreen/startscreen_strife.cpp
View file

@ -111,7 +111,7 @@ FStrifeStartScreen::FStrifeStartScreen(int max_progress)
// Load the background and animated overlays.
for (size_t i = 0; i < countof(StrifeStartupPicNames); ++i)
{
int lumpnum = fileSystem.CheckNumForName(StrifeStartupPicNames[i], ns_graphics);
int lumpnum = fileSystem.CheckNumForName(StrifeStartupPicNames[i], FileSys::ns_graphics);
if (lumpnum < 0) lumpnum = fileSystem.CheckNumForName(StrifeStartupPicNames[i]);
if (lumpnum >= 0)

16
src/common/textures/formats/pngtexture.cpp
View file

@ -119,12 +119,12 @@ FImageSource *PNGImage_TryCreate(FileReader & data, int lumpnum)
if (compression != 0 || filter != 0 || interlace > 1)
{
Printf(TEXTCOLOR_YELLOW"WARNING: failed to load PNG %s: the compression, filter, or interlace is not supported!\n", fileSystem.GetFileName(lumpnum));
Printf(TEXTCOLOR_YELLOW"WARNING: failed to load PNG %s: the compression, filter, or interlace is not supported!\n", fileSystem.GetFileFullName(lumpnum));
return NULL;
}
if (!((1 << colortype) & 0x5D))
{
Printf(TEXTCOLOR_YELLOW"WARNING: failed to load PNG %s: the colortype (%u) is not supported!\n", fileSystem.GetFileName(lumpnum), colortype);
Printf(TEXTCOLOR_YELLOW"WARNING: failed to load PNG %s: the colortype (%u) is not supported!\n", fileSystem.GetFileFullName(lumpnum), colortype);
return NULL;
}
if (!((1 << bitdepth) & 0x116))
@ -150,12 +150,12 @@ FImageSource *PNGImage_TryCreate(FileReader & data, int lumpnum)
int ihoty = data.ReadInt32BE();
if (ihotx < -32768 || ihotx > 32767)
{
Printf("X-Offset for PNG texture %s is bad: %d (0x%08x)\n", fileSystem.GetFileName(lumpnum), ihotx, ihotx);
Printf("X-Offset for PNG texture %s is bad: %d (0x%08x)\n", fileSystem.GetFileFullName(lumpnum), ihotx, ihotx);
ihotx = 0;
}
if (ihoty < -32768 || ihoty > 32767)
{
Printf("Y-Offset for PNG texture %s is bad: %d (0x%08x)\n", fileSystem.GetFileName(lumpnum), ihoty, ihoty);
Printf("Y-Offset for PNG texture %s is bad: %d (0x%08x)\n", fileSystem.GetFileFullName(lumpnum), ihoty, ihoty);
ihoty = 0;
}
tex->SetOffsets(ihotx, ihoty);
@ -169,7 +169,7 @@ FImageSource *PNGImage_TryCreate(FileReader & data, int lumpnum)
return tex;
}
Printf(TEXTCOLOR_YELLOW"WARNING: failed to load PNG %s: the bit-depth (%u) is not supported!\n", fileSystem.GetFileName(lumpnum), bitdepth);
Printf(TEXTCOLOR_YELLOW"WARNING: failed to load PNG %s: the bit-depth (%u) is not supported!\n", fileSystem.GetFileFullName(lumpnum), bitdepth);
return NULL;
}
@ -180,7 +180,7 @@ FImageSource *PNGImage_TryCreate(FileReader & data, int lumpnum)
{
if (data.Read(first4bytes.b, 4) != 4 || first4bytes.dw == MAKE_ID('I','E','N','D'))
{
Printf(TEXTCOLOR_YELLOW"WARNING: failed to load PNG %s: the file ends immediately after the IHDR.\n", fileSystem.GetFileName(lumpnum));
Printf(TEXTCOLOR_YELLOW"WARNING: failed to load PNG %s: the file ends immediately after the IHDR.\n", fileSystem.GetFileFullName(lumpnum));
return NULL;
}
}
@ -231,12 +231,12 @@ FPNGTexture::FPNGTexture (FileReader &lump, int lumpnum, int width, int height,
int ihoty = lump.ReadInt32BE();
if (ihotx < -32768 || ihotx > 32767)
{
Printf ("X-Offset for PNG texture %s is bad: %d (0x%08x)\n", fileSystem.GetFileName (lumpnum), ihotx, ihotx);
Printf ("X-Offset for PNG texture %s is bad: %d (0x%08x)\n", fileSystem.GetFileFullName (lumpnum), ihotx, ihotx);
ihotx = 0;
}
if (ihoty < -32768 || ihoty > 32767)
{
Printf ("Y-Offset for PNG texture %s is bad: %d (0x%08x)\n", fileSystem.GetFileName (lumpnum), ihoty, ihoty);
Printf ("Y-Offset for PNG texture %s is bad: %d (0x%08x)\n", fileSystem.GetFileFullName (lumpnum), ihoty, ihoty);
ihoty = 0;
}
LeftOffset = ihotx;

10
src/common/textures/gametexture.cpp
View file

@ -124,7 +124,7 @@ FGameTexture::~FGameTexture()
bool FGameTexture::isUserContent() const
{
int filenum = fileSystem.GetFileContainer(Base->GetSourceLump());
return (filenum > fileSystem.GetMaxBaseNum());
return (filenum > fileSystem.GetMaxIwadNum());
}
@ -182,10 +182,10 @@ void FGameTexture::AddAutoMaterials()
if (this->*(layer.pointer) == nullptr) // only if no explicit assignment had been done.
{
FStringf lookup("%s%s%s", layer.path, fullname ? "" : "auto/", searchname.GetChars());
auto lump = fileSystem.FindFile(lookup.GetChars(), true);
auto lump = fileSystem.CheckNumForFullName(lookup.GetChars(), false, FileSys::ns_global, true);
if (lump != -1)
{
auto bmtex = TexMan.FindGameTexture(fileSystem.GetFileName(lump), ETextureType::Any, FTextureManager::TEXMAN_TryAny);
auto bmtex = TexMan.FindGameTexture(fileSystem.GetFileFullName(lump), ETextureType::Any, FTextureManager::TEXMAN_TryAny);
if (bmtex != nullptr)
{
this->*(layer.pointer) = bmtex->GetTexture();
@ -199,10 +199,10 @@ void FGameTexture::AddAutoMaterials()
if (!this->Layers || this->Layers.get()->*(layer.pointer) == nullptr) // only if no explicit assignment had been done.
{
FStringf lookup("%s%s%s", layer.path, fullname ? "" : "auto/", searchname.GetChars());
auto lump = fileSystem.FindFile(lookup.GetChars(), true);
auto lump = fileSystem.CheckNumForFullName(lookup.GetChars(), false, FileSys::ns_global, true);
if (lump != -1)
{
auto bmtex = TexMan.FindGameTexture(fileSystem.GetFileName(lump), ETextureType::Any, FTextureManager::TEXMAN_TryAny);
auto bmtex = TexMan.FindGameTexture(fileSystem.GetFileFullName(lump), ETextureType::Any, FTextureManager::TEXMAN_TryAny);
if (bmtex != nullptr)
{
if (this->Layers == nullptr) this->Layers = std::make_unique<FMaterialLayers>();

52
src/common/textures/texturemanager.cpp
View file

@ -50,6 +50,7 @@
#include "basics.h"
#include "cmdlib.h"
using namespace FileSys;
FTextureManager TexMan;
@ -247,7 +248,7 @@ FTextureID FTextureManager::CheckForTexture (const char *name, ETextureType uset
if (strchr(name, '/') || (flags & TEXMAN_ForceLookup))
{
FGameTexture *const NO_TEXTURE = (FGameTexture*)-1; // marker for lumps we already checked that do not map to a texture.
int lump = fileSystem.FindFile(name);
int lump = fileSystem.CheckNumForFullName(name);
if (lump >= 0)
{
FGameTexture *tex = GetLinkedTexture(lump);
@ -394,7 +395,7 @@ bool FTextureManager::OkForLocalization(FTextureID texnum, const char *substitut
// Mode 3 must also reject substitutions for non-IWAD content.
int file = fileSystem.GetFileContainer(Textures[texnum.GetIndex()].Texture->GetSourceLump());
if (file > fileSystem.GetMaxBaseNum()) return true;
if (file > fileSystem.GetMaxIwadNum()) return true;
return false;
}
@ -456,7 +457,7 @@ FTextureID FTextureManager::CreateTexture (int lumpnum, ETextureType usetype)
str = fileSystem.GetFileShortName(lumpnum);
else
{
auto fn = fileSystem.GetFileName(lumpnum);
auto fn = fileSystem.GetFileFullName(lumpnum);
str = ExtractFileBase(fn);
}
auto out = MakeGameTexture(CreateTextureFromLump(lumpnum, usetype == ETextureType::Flat), str.GetChars(), usetype);
@ -584,7 +585,7 @@ void FTextureManager::AddGroup(int wadnum, int ns, ETextureType usetype)
}
progressFunc();
}
else if (ns == ns_flats && fileSystem.GetFileNamespace(firsttx) == ns_maybeflat)
else if (ns == ns_flats && fileSystem.GetFileFlags(firsttx) & RESFF_MAYBEFLAT)
{
if (fileSystem.CheckNumForName(Name, ns) < firsttx)
{
@ -722,8 +723,8 @@ void FTextureManager::ParseTextureDef(int lump, FMultipatchTextureBuilder &build
FName texname = sc.String;
sc.MustGetString();
int lumpnum = fileSystem.CheckNumForAnyName(sc.String, ns_patches);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForAnyName(sc.String, ns_graphics);
int lumpnum = fileSystem.CheckNumForFullName(sc.String, true, ns_patches);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForFullName(sc.String, true, ns_graphics);
if (tlist.Size() == 0)
{
@ -778,8 +779,8 @@ void FTextureManager::ParseTextureDef(int lump, FMultipatchTextureBuilder &build
{
FString src = base.Left(8);
int lumpnum = fileSystem.CheckNumForAnyName(sc.String, ns_patches);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForAnyName(sc.String, ns_graphics);
int lumpnum = fileSystem.CheckNumForFullName(sc.String, true, ns_patches);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForFullName(sc.String, true, ns_graphics);
sc.GetString();
bool is32bit = !!sc.Compare("force32bit");
@ -853,7 +854,7 @@ void FTextureManager::ParseTextureDef(int lump, FMultipatchTextureBuilder &build
sc.MustGetString();
// This is not using sc.Open because it can print a more useful error message when done here
int includelump = fileSystem.CheckNumForAnyName(sc.String);
int includelump = fileSystem.CheckNumForFullName(sc.String, true);
if (includelump == -1)
{
sc.ScriptError("Lump '%s' not found", sc.String);
@ -936,7 +937,7 @@ void FTextureManager::LoadTextureX(int wadnum, FMultipatchTextureBuilder &build)
void FTextureManager::AddTexturesForWad(int wadnum, FMultipatchTextureBuilder &build)
{
int firsttexture = Textures.Size();
bool iwad = wadnum >= fileSystem.GetBaseNum() && wadnum <= fileSystem.GetMaxBaseNum();
bool iwad = wadnum >= fileSystem.GetIwadNum() && wadnum <= fileSystem.GetMaxIwadNum();
FirstTextureForFile.Push(firsttexture);
@ -970,7 +971,7 @@ void FTextureManager::AddTexturesForWad(int wadnum, FMultipatchTextureBuilder &b
if (ns == ns_global)
{
// In Zips all graphics must be in a separate namespace.
if (fileSystem.GetFileFlags(i) & FileSys::RESFF_FULLPATH) continue;
if (fileSystem.GetFileFlags(i) & RESFF_FULLPATH) continue;
// Ignore lumps with empty names.
if (fileSystem.CheckFileName(i, "")) continue;
@ -1108,7 +1109,7 @@ void FTextureManager::SortTexturesByType(int start, int end)
void FTextureManager::AddLocalizedVariants()
{
std::vector<FileSys::FolderEntry> content;
std::vector<FolderEntry> content;
fileSystem.GetFilesInFolder("localized/textures/", content, false);
for (auto &entry : content)
{
@ -1217,7 +1218,7 @@ void FTextureManager::AddTextures(void (*progressFunc_)(), void (*checkForHacks)
progressFunc = progressFunc_;
//if (BuildTileFiles.Size() == 0) CountBuildTiles ();
int wadcnt = fileSystem.GetContainerCount();
int wadcnt = fileSystem.GetNumWads();
FMultipatchTextureBuilder build(*this, progressFunc_, checkForHacks);
@ -1409,7 +1410,7 @@ int FTextureManager::GuesstimateNumTextures ()
{
int numtex = 0;
for(int i = fileSystem.GetFileCount()-1; i>=0; i--)
for(int i = fileSystem.GetNumEntries()-1; i>=0; i--)
{
int space = fileSystem.GetFileNamespace(i);
switch(space)
@ -1420,11 +1421,12 @@ int FTextureManager::GuesstimateNumTextures ()
case ns_hires:
case ns_patches:
case ns_graphics:
case ns_maybeflat:
numtex++;
break;
default:
if (fileSystem.GetFileFlags(i) & RESFF_MAYBEFLAT) numtex++;
break;
}
}
@ -1445,7 +1447,7 @@ int FTextureManager::GuesstimateNumTextures ()
int FTextureManager::CountTexturesX ()
{
int count = 0;
int wadcount = fileSystem.GetContainerCount();
int wadcount = fileSystem.GetNumWads();
for (int wadnum = 0; wadnum < wadcount; wadnum++)
{
// Use the most recent PNAMES for this WAD.
@ -1503,16 +1505,16 @@ void FTextureManager::AdjustSpriteOffsets()
int sprid;
TMap<int, bool> donotprocess;
int numtex = fileSystem.GetFileCount();
int numtex = fileSystem.GetNumEntries();
for (int i = 0; i < numtex; i++)
{
if (fileSystem.GetFileContainer(i) > fileSystem.GetMaxBaseNum()) break; // we are past the IWAD
if (fileSystem.GetFileNamespace(i) == ns_sprites && fileSystem.GetFileContainer(i) >= fileSystem.GetBaseNum() && fileSystem.GetFileContainer(i) <= fileSystem.GetMaxBaseNum())
if (fileSystem.GetFileContainer(i) > fileSystem.GetMaxIwadNum()) break; // we are past the IWAD
if (fileSystem.GetFileNamespace(i) == ns_sprites && fileSystem.GetFileContainer(i) >= fileSystem.GetIwadNum() && fileSystem.GetFileContainer(i) <= fileSystem.GetMaxIwadNum())
{
const char *str = fileSystem.GetFileShortName(i);
FTextureID texid = TexMan.CheckForTexture(str, ETextureType::Sprite, 0);
if (texid.isValid() && fileSystem.GetFileContainer(GetGameTexture(texid)->GetSourceLump()) > fileSystem.GetMaxBaseNum())
if (texid.isValid() && fileSystem.GetFileContainer(GetGameTexture(texid)->GetSourceLump()) > fileSystem.GetMaxIwadNum())
{
// This texture has been replaced by some PWAD.
memcpy(&sprid, str, 4);
@ -1551,12 +1553,12 @@ void FTextureManager::AdjustSpriteOffsets()
int lumpnum = tex->GetSourceLump();
// We only want to change texture offsets for sprites in the IWAD or the file this lump originated from.
if (lumpnum >= 0 && lumpnum < fileSystem.GetFileCount())
if (lumpnum >= 0 && lumpnum < fileSystem.GetNumEntries())
{
int wadno = fileSystem.GetFileContainer(lumpnum);
if ((iwadonly && wadno >= fileSystem.GetBaseNum() && wadno <= fileSystem.GetMaxBaseNum()) || (!iwadonly && wadno == ofslumpno))
if ((iwadonly && wadno >= fileSystem.GetIwadNum() && wadno <= fileSystem.GetMaxIwadNum()) || (!iwadonly && wadno == ofslumpno))
{
if (wadno >= fileSystem.GetBaseNum() && wadno <= fileSystem.GetMaxBaseNum() && !forced && iwadonly)
if (wadno >= fileSystem.GetIwadNum() && wadno <= fileSystem.GetMaxIwadNum() && !forced && iwadonly)
{
memcpy(&sprid, tex->GetName().GetChars(), 4);
if (donotprocess.CheckKey(sprid)) continue; // do not alter sprites that only get partially replaced.
@ -1630,7 +1632,7 @@ void FTextureManager::Listaliases()
void FTextureManager::SetLinkedTexture(int lump, FGameTexture* tex)
{
if (lump < fileSystem.GetFileCount())
if (lump < fileSystem.GetNumEntries())
{
linkedMap.Insert(lump, tex);
}
@ -1644,7 +1646,7 @@ void FTextureManager::SetLinkedTexture(int lump, FGameTexture* tex)
FGameTexture* FTextureManager::GetLinkedTexture(int lump)
{
if (lump < fileSystem.GetFileCount())
if (lump < fileSystem.GetNumEntries())
{
auto check = linkedMap.CheckKey(lump);
if (check) return *check;

6
src/common/utility/palette.cpp
View file

@ -672,7 +672,7 @@ FString V_GetColorStringByName(const char* name, FScriptPosition* sc)
int c[3], step;
size_t namelen;
if (fileSystem.GetFileCount() == 0) return FString();
if (fileSystem.GetNumEntries() == 0) return FString();
rgblump = fileSystem.CheckNumForName("X11R6RGB");
if (rgblump == -1)
@ -960,13 +960,13 @@ int ReadPalette(int lumpnum, uint8_t* buffer)
id = MAKE_ID('I', 'E', 'N', 'D');
fr.Read(&id, 4);
}
I_Error("%s contains no palette", fileSystem.GetFileName(lumpnum));
I_Error("%s contains no palette", fileSystem.GetFileFullName(lumpnum));
}
if (memcmp(lumpmem, "JASC-PAL", 8) == 0)
{
FScanner sc;
sc.OpenMem(fileSystem.GetFileName(lumpnum), (char*)lumpmem, int(lump.size()));
sc.OpenMem(fileSystem.GetFileFullName(lumpnum), (char*)lumpmem, int(lump.size()));
sc.MustGetString();
sc.MustGetNumber(); // version - ignore
sc.MustGetNumber();

2
src/d_defcvars.cpp
View file

@ -46,7 +46,7 @@ void D_GrabCVarDefaults()
while ((lump = fileSystem.FindLump("DEFCVARS", &lastlump)) != -1)
{
// don't parse from wads
if (lastlump > fileSystem.GetLastEntry(fileSystem.GetMaxBaseNum()))
if (lastlump > fileSystem.GetLastEntry(fileSystem.GetMaxIwadNum()))
{
// would rather put this in a modal of some sort, but this will have to do.
Printf(TEXTCOLOR_RED "Cannot load DEFCVARS from a wadfile!\n");

26
src/d_iwad.cpp
View file

@ -314,7 +314,7 @@ void FIWadManager::ParseIWadInfo(const char *fn, const char *data, int datasize,
// Look for IWAD definition lump
//
//==========================================================================
void GetReserved(FileSys::FileSystemFilterInfo& lfi);
void GetReserved(FileSys::LumpFilterInfo& lfi);
FIWadManager::FIWadManager(const char *firstfn, const char *optfn)
{
@ -322,10 +322,10 @@ FIWadManager::FIWadManager(const char *firstfn, const char *optfn)
std::vector<std::string> fns;
fns.push_back(firstfn);
if (optfn) fns.push_back(optfn);
FileSys::FileSystemFilterInfo lfi;
FileSys::LumpFilterInfo lfi;
GetReserved(lfi);
if (check.Initialize(fns, &lfi, nullptr))
if (check.InitMultipleFiles(fns, &lfi, nullptr))
{
// this is for the IWAD picker. As we have a filesystem open here that contains the base files, it is the easiest place to load the strings early.
GStrings.LoadStrings(check, language);
@ -350,8 +350,7 @@ FIWadManager::FIWadManager(const char *firstfn, const char *optfn)
int FIWadManager::ScanIWAD (const char *iwad)
{
FileSystem check;
std::vector<std::string> list({ iwad });
check.Initialize(list, nullptr);
check.InitSingleFile(iwad, nullptr);
mLumpsFound.Resize(mIWadInfos.Size());
@ -369,18 +368,19 @@ int FIWadManager::ScanIWAD (const char *iwad)
}
};
if (check.GetFileCount() > 0)
if (check.GetNumEntries() > 0)
{
memset(&mLumpsFound[0], 0, mLumpsFound.Size() * sizeof(mLumpsFound[0]));
for(int ii = 0; ii < check.GetFileCount(); ii++)
for(int ii = 0; ii < check.GetNumEntries(); ii++)
{
auto full = check.GetFileName(ii);
CheckFileName(check.GetFileShortName(ii));
auto full = check.GetFileFullName(ii, false);
if (full && strnicmp(full, "maps/", 5) == 0)
{
FString mapname(&full[5], strcspn(&full[5], "."));
CheckFileName(mapname.GetChars());
}
else CheckFileName(full);
}
}
for (unsigned i = 0; i< mIWadInfos.Size(); i++)
@ -404,11 +404,11 @@ int FIWadManager::CheckIWADInfo(const char* fn)
{
FileSystem check;
FileSys::FileSystemFilterInfo lfi;
FileSys::LumpFilterInfo lfi;
GetReserved(lfi);
std::vector<std::string> filenames = { fn };
if (check.Initialize(filenames, &lfi, nullptr))
if (check.InitMultipleFiles(filenames, &lfi, nullptr))
{
int num = check.CheckNumForName("IWADINFO");
if (num >= 0)
@ -829,14 +829,14 @@ int FIWadManager::IdentifyVersion (std::vector<std::string>&wadfiles, const char
iwadnum++;
}
fileSystem.SetBaseNum(iwadnum);
fileSystem.SetIwadNum(iwadnum);
if (picks[pick].mRequiredPath.IsNotEmpty())
{
D_AddFile (wadfiles, picks[pick].mRequiredPath.GetChars(), true, -1, GameConfig);
iwadnum++;
}
D_AddFile (wadfiles, picks[pick].mFullPath.GetChars(), true, -1, GameConfig);
fileSystem.SetMaxBaseNum(iwadnum);
fileSystem.SetMaxIwadNum(iwadnum);
auto info = mIWadInfos[picks[pick].mInfoIndex];

198
src/d_main.cpp
View file

@ -123,6 +123,8 @@
#include "i_system.h" // for SHARE_DIR
#endif // __unix__
using namespace FileSys;
EXTERN_CVAR(Bool, hud_althud)
EXTERN_CVAR(Int, vr_mode)
EXTERN_CVAR(Bool, cl_customizeinvulmap)
@ -1263,7 +1265,7 @@ void D_DoomLoop ()
}
D_ErrorCleanup ();
}
catch (const FileSys::FileSystemException& error) // in case this propagates up to here it should be treated as a recoverable error.
catch (const FileSystemException& error) // in case this propagates up to here it should be treated as a recoverable error.
{
if (error.what())
{
@ -1943,7 +1945,7 @@ static FString ParseGameInfo(std::vector<std::string> &pwads, const char *fn, co
return iwad;
}
void GetReserved(FileSys::FileSystemFilterInfo& lfi)
void GetReserved(LumpFilterInfo& lfi)
{
lfi.reservedFolders = { "flats/", "textures/", "hires/", "sprites/", "voxels/", "colormaps/", "acs/", "maps/", "voices/", "patches/", "graphics/", "sounds/", "music/",
"materials/", "models/", "fonts/", "brightmaps/" };
@ -1955,18 +1957,18 @@ static FString CheckGameInfo(std::vector<std::string> & pwads)
{
FileSystem check;
FileSys::FileSystemFilterInfo lfi;
LumpFilterInfo lfi;
GetReserved(lfi);
// Open the entire list as a temporary file system and look for a GAMEINFO lump. The last one will automatically win.
if (check.Initialize(pwads, &lfi, nullptr))
if (check.InitMultipleFiles(pwads, &lfi, nullptr))
{
int num = check.CheckNumForName("GAMEINFO");
if (num >= 0)
{
// Found one!
auto data = check.ReadFile(num);
auto wadname = check.GetContainerName(check.GetFileContainer(num));
auto wadname = check.GetResourceFileName(check.GetFileContainer(num));
return ParseGameInfo(pwads, wadname, data.string(), (int)data.size());
}
}
@ -1981,9 +1983,9 @@ static FString CheckGameInfo(std::vector<std::string> & pwads)
static void SetMapxxFlag()
{
int lump_name = fileSystem.CheckNumForName("MAP01", ns_global, fileSystem.GetBaseNum());
int lump_wad = fileSystem.GetFileInContainer("maps/map01.wad", fileSystem.GetBaseNum());
int lump_map = fileSystem.GetFileInContainer("maps/map01.map", fileSystem.GetBaseNum());
int lump_name = fileSystem.CheckNumForName("MAP01", ns_global, fileSystem.GetIwadNum());
int lump_wad = fileSystem.CheckNumForFullName("maps/map01.wad", fileSystem.GetIwadNum());
int lump_map = fileSystem.CheckNumForFullName("maps/map01.map", fileSystem.GetIwadNum());
if (lump_name >= 0 || lump_wad >= 0 || lump_map >= 0) gameinfo.flags |= GI_MAPxx;
}
@ -2248,48 +2250,48 @@ static void RenameSprites(FileSystem &fileSystem, const TArray<FString>& deletel
bool MNTRZfound = false;
const char* altbigfont = gameinfo.gametype == GAME_Strife ? "SBIGFONT" : (gameinfo.gametype & GAME_Raven) ? "HBIGFONT" : "DBIGFONT";
static const char HereticRenames[][4] =
{ {'H','E','A','D'}, {'L','I','C','H'}, // Ironlich
static const uint32_t HereticRenames[] =
{ MAKE_ID('H','E','A','D'), MAKE_ID('L','I','C','H'), // Ironlich
};
static const char HexenRenames[][4] =
{ {'B','A','R','L'}, {'Z','B','A','R'}, // ZBarrel
{'A','R','M','1'}, {'A','R','_','1'}, // MeshArmor
{'A','R','M','2'}, {'A','R','_','2'}, // FalconShield
{'A','R','M','3'}, {'A','R','_','3'}, // PlatinumHelm
{'A','R','M','4'}, {'A','R','_','4'}, // AmuletOfWarding
{'S','U','I','T'}, {'Z','S','U','I'}, // ZSuitOfArmor and ZArmorChunk
{'T','R','E','1'}, {'Z','T','R','E'}, // ZTree and ZTreeDead
{'T','R','E','2'}, {'T','R','E','S'}, // ZTreeSwamp150
{'C','A','N','D'}, {'B','C','A','N'}, // ZBlueCandle
{'R','O','C','K'}, {'R','O','K','K'}, // rocks and dirt in a_debris.cpp
{'W','A','T','R'}, {'H','W','A','T'}, // Strife also has WATR
{'G','I','B','S'}, {'P','O','L','5'}, // RealGibs
{'E','G','G','M'}, {'P','R','K','M'}, // PorkFX
{'I','N','V','U'}, {'D','E','F','N'}, // Icon of the Defender
static const uint32_t HexenRenames[] =
{ MAKE_ID('B','A','R','L'), MAKE_ID('Z','B','A','R'), // ZBarrel
MAKE_ID('A','R','M','1'), MAKE_ID('A','R','_','1'), // MeshArmor
MAKE_ID('A','R','M','2'), MAKE_ID('A','R','_','2'), // FalconShield
MAKE_ID('A','R','M','3'), MAKE_ID('A','R','_','3'), // PlatinumHelm
MAKE_ID('A','R','M','4'), MAKE_ID('A','R','_','4'), // AmuletOfWarding
MAKE_ID('S','U','I','T'), MAKE_ID('Z','S','U','I'), // ZSuitOfArmor and ZArmorChunk
MAKE_ID('T','R','E','1'), MAKE_ID('Z','T','R','E'), // ZTree and ZTreeDead
MAKE_ID('T','R','E','2'), MAKE_ID('T','R','E','S'), // ZTreeSwamp150
MAKE_ID('C','A','N','D'), MAKE_ID('B','C','A','N'), // ZBlueCandle
MAKE_ID('R','O','C','K'), MAKE_ID('R','O','K','K'), // rocks and dirt in a_debris.cpp
MAKE_ID('W','A','T','R'), MAKE_ID('H','W','A','T'), // Strife also has WATR
MAKE_ID('G','I','B','S'), MAKE_ID('P','O','L','5'), // RealGibs
MAKE_ID('E','G','G','M'), MAKE_ID('P','R','K','M'), // PorkFX
MAKE_ID('I','N','V','U'), MAKE_ID('D','E','F','N'), // Icon of the Defender
};
static const char StrifeRenames[][4] =
{ {'M','I','S','L'}, {'S','M','I','S'}, // lots of places
{'A','R','M','1'}, {'A','R','M','3'}, // MetalArmor
{'A','R','M','2'}, {'A','R','M','4'}, // LeatherArmor
{'P','M','A','P'}, {'S','M','A','P'}, // StrifeMap
{'T','L','M','P'}, {'T','E','C','H'}, // TechLampSilver and TechLampBrass
{'T','R','E','1'}, {'T','R','E','T'}, // TreeStub
{'B','A','R','1'}, {'B','A','R','C'}, // BarricadeColumn
{'S','H','T','2'}, {'M','P','U','F'}, // MaulerPuff
{'B','A','R','L'}, {'B','B','A','R'}, // StrifeBurningBarrel
{'T','R','C','H'}, {'T','R','H','L'}, // SmallTorchLit
{'S','H','R','D'}, {'S','H','A','R'}, // glass shards
{'B','L','S','T'}, {'M','A','U','L'}, // Mauler
{'L','O','G','G'}, {'L','O','G','W'}, // StickInWater
{'V','A','S','E'}, {'V','A','Z','E'}, // Pot and Pitcher
{'C','N','D','L'}, {'K','N','D','L'}, // Candle
{'P','O','T','1'}, {'M','P','O','T'}, // MetalPot
{'S','P','I','D'}, {'S','T','L','K'}, // Stalker
static const uint32_t StrifeRenames[] =
{ MAKE_ID('M','I','S','L'), MAKE_ID('S','M','I','S'), // lots of places
MAKE_ID('A','R','M','1'), MAKE_ID('A','R','M','3'), // MetalArmor
MAKE_ID('A','R','M','2'), MAKE_ID('A','R','M','4'), // LeatherArmor
MAKE_ID('P','M','A','P'), MAKE_ID('S','M','A','P'), // StrifeMap
MAKE_ID('T','L','M','P'), MAKE_ID('T','E','C','H'), // TechLampSilver and TechLampBrass
MAKE_ID('T','R','E','1'), MAKE_ID('T','R','E','T'), // TreeStub
MAKE_ID('B','A','R','1'), MAKE_ID('B','A','R','C'), // BarricadeColumn
MAKE_ID('S','H','T','2'), MAKE_ID('M','P','U','F'), // MaulerPuff
MAKE_ID('B','A','R','L'), MAKE_ID('B','B','A','R'), // StrifeBurningBarrel
MAKE_ID('T','R','C','H'), MAKE_ID('T','R','H','L'), // SmallTorchLit
MAKE_ID('S','H','R','D'), MAKE_ID('S','H','A','R'), // glass shards
MAKE_ID('B','L','S','T'), MAKE_ID('M','A','U','L'), // Mauler
MAKE_ID('L','O','G','G'), MAKE_ID('L','O','G','W'), // StickInWater
MAKE_ID('V','A','S','E'), MAKE_ID('V','A','Z','E'), // Pot and Pitcher
MAKE_ID('C','N','D','L'), MAKE_ID('K','N','D','L'), // Candle
MAKE_ID('P','O','T','1'), MAKE_ID('M','P','O','T'), // MetalPot
MAKE_ID('S','P','I','D'), MAKE_ID('S','T','L','K'), // Stalker
};
const char (*renames)[4];
const uint32_t* renames;
int numrenames;
switch (gameinfo.gametype)
@ -2317,7 +2319,7 @@ static void RenameSprites(FileSystem &fileSystem, const TArray<FString>& deletel
break;
}
unsigned NumFiles = fileSystem.GetFileCount();
unsigned NumFiles = fileSystem.GetNumEntries();
for (uint32_t i = 0; i < NumFiles; i++)
{
@ -2325,8 +2327,8 @@ static void RenameSprites(FileSystem &fileSystem, const TArray<FString>& deletel
// some frames need to be renamed.
if (fileSystem.GetFileNamespace(i) == ns_sprites)
{
auto shortName = fileSystem.GetShortName(i);
if (!memcmp(shortName, "MNTRZ", 5))
auto& shortName = fileSystem.GetShortName(i);
if (shortName.dword == MAKE_ID('M', 'N', 'T', 'R') && shortName.String[4] == 'Z')
{
MNTRZfound = true;
break;
@ -2338,38 +2340,38 @@ static void RenameSprites(FileSystem &fileSystem, const TArray<FString>& deletel
for (uint32_t i = 0; i < NumFiles; i++)
{
auto shortName = fileSystem.GetShortName(i);
auto& shortName = fileSystem.GetShortName(i);
if (fileSystem.GetFileNamespace(i) == ns_sprites)
{
// Only sprites in the IWAD normally get renamed
if (renameAll || fileSystem.GetFileContainer(i) == fileSystem.GetBaseNum())
if (renameAll || fileSystem.GetFileContainer(i) == fileSystem.GetIwadNum())
{
for (int j = 0; j < numrenames; ++j)
{
if (!memcmp(shortName, &renames[j * 8], 4))
if (shortName.dword == renames[j * 2])
{
memcpy(shortName, renames[j * 8 + 4], 4);
shortName.dword = renames[j * 2 + 1];
}
}
if (gameinfo.gametype == GAME_Hexen)
{
if (fileSystem.CheckFileName(i, "ARTIINVU"))
{
shortName[4] = 'D'; shortName[5] = 'E';
shortName[6] = 'F'; shortName[7] = 'N';
shortName.String[4] = 'D'; shortName.String[5] = 'E';
shortName.String[6] = 'F'; shortName.String[7] = 'N';
}
}
}
if (!MNTRZfound)
{
if (!memcmp(shortName, "MNTR", 4))
if (shortName.dword == MAKE_ID('M', 'N', 'T', 'R'))
{
for (size_t fi : {4, 6})
{
if (shortName[fi] >= 'F' && shortName[fi] <= 'K')
if (shortName.String[fi] >= 'F' && shortName.String[fi] <= 'K')
{
shortName[fi] += 'U' - 'F';
shortName.String[fi] += 'U' - 'F';
}
}
}
@ -2379,23 +2381,23 @@ static void RenameSprites(FileSystem &fileSystem, const TArray<FString>& deletel
// the same blood states can be used everywhere
if (!(gameinfo.gametype & GAME_DoomChex))
{
if (!memcmp(shortName, "BLOD", 4))
if (shortName.dword == MAKE_ID('B', 'L', 'O', 'D'))
{
memcpy(shortName, "BLUD", 4);
shortName.dword = MAKE_ID('B', 'L', 'U', 'D');
}
}
}
else if (fileSystem.GetFileNamespace(i) == ns_global)
{
int fn = fileSystem.GetFileContainer(i);
if (fn >= fileSystem.GetBaseNum() && fn <= fileSystem.GetMaxBaseNum() && deletelumps.Find(shortName) < deletelumps.Size())
if (fn >= fileSystem.GetIwadNum() && fn <= fileSystem.GetMaxIwadNum() && deletelumps.Find(shortName.String) < deletelumps.Size())
{
shortName[0] = 0; // Lump must be deleted from directory.
shortName.String[0] = 0; // Lump must be deleted from directory.
}
// Rename the game specific big font lumps so that the font manager does not have to do problematic special checks for them.
else if (!strcmp(shortName, altbigfont))
else if (!strcmp(shortName.String, altbigfont))
{
strcpy(shortName, "BIGFONT");
strcpy(shortName.String, "BIGFONT");
}
}
}
@ -2431,8 +2433,8 @@ void RenameNerve(FileSystem& fileSystem)
0x70, 0xc2, 0xca, 0x36, 0xac, 0x65, 0xaf, 0x45 }
};
size_t nervesize[numnerveversions] = { 3819855, 3821966, 3821885, 4003409 }; // NERVE.WAD's file size
int w = fileSystem.GetBaseNum();
while (++w < fileSystem.GetContainerCount())
int w = fileSystem.GetIwadNum();
while (++w < fileSystem.GetNumWads())
{
auto fr = fileSystem.GetFileReader(w);
int isizecheck = -1;
@ -2465,16 +2467,18 @@ void RenameNerve(FileSystem& fileSystem)
for (int i = fileSystem.GetFirstEntry(w); i <= fileSystem.GetLastEntry(w); i++)
{
auto shortName = fileSystem.GetShortName(i);
auto& shortName = fileSystem.GetShortName(i);
// Only rename the maps from NERVE.WAD
if (!memcmp(shortName, "CWILV", 5))
if (shortName.dword == MAKE_ID('C', 'W', 'I', 'L'))
{
shortName[0] = 'N';
shortName.String[0] = 'N';
}
else if (!memcmp(shortName, "MAP0", 4))
else if (shortName.dword == MAKE_ID('M', 'A', 'P', '0'))
{
shortName[6] = shortName[4];
memcpy(shortName, "LEVEL0", 6);
shortName.String[6] = shortName.String[4];
shortName.String[5] = '0';
shortName.String[4] = 'L';
shortName.dword = MAKE_ID('L', 'E', 'V', 'E');
}
}
}
@ -2497,7 +2501,7 @@ void FixMacHexen(FileSystem& fileSystem)
return;
}
FileReader* reader = fileSystem.GetFileReader(fileSystem.GetBaseNum());
FileReader* reader = fileSystem.GetFileReader(fileSystem.GetIwadNum());
auto iwadSize = reader->GetLength();
static const ptrdiff_t DEMO_SIZE = 13596228;
@ -2551,13 +2555,13 @@ void FixMacHexen(FileSystem& fileSystem)
// Hexen Beta is very similar to Demo but it has MAP41: Maze at the end of the WAD
// So keep this map if it's present but discard all extra lumps
const int lastLump = fileSystem.GetLastEntry(fileSystem.GetBaseNum()) - (isBeta ? 12 : 0);
assert(fileSystem.GetFirstEntry(fileSystem.GetBaseNum()) + 299 < lastLump);
const int lastLump = fileSystem.GetLastEntry(fileSystem.GetIwadNum()) - (isBeta ? 12 : 0);
assert(fileSystem.GetFirstEntry(fileSystem.GetIwadNum()) + 299 < lastLump);
for (int i = lastLump - EXTRA_LUMPS + 1; i <= lastLump; ++i)
{
auto shortName = fileSystem.GetShortName(i);
memcpy(shortName, "\0\0\0\0\0\0\0", 8); // these get compared with memcmp so all 8 bytes need to get cleared.
auto& shortName = fileSystem.GetShortName(i);
shortName.String[0] = '\0';
}
}
@ -2565,24 +2569,24 @@ static void FindStrifeTeaserVoices(FileSystem& fileSystem)
{
if (gameinfo.gametype == GAME_Strife && gameinfo.flags & GI_SHAREWARE)
{
unsigned NumFiles = fileSystem.GetFileCount();
unsigned NumFiles = fileSystem.GetNumEntries();
for (uint32_t i = 0; i < NumFiles; i++)
{
auto shortName = fileSystem.GetShortName(i);
auto& shortName = fileSystem.GetShortName(i);
if (fileSystem.GetFileNamespace(i) == ns_global)
{
// Strife teaser voices are not in the expected namespace.
if (fileSystem.GetFileContainer(i) == fileSystem.GetBaseNum())
// Only sprites in the IWAD normally get renamed
if (fileSystem.GetFileContainer(i) == fileSystem.GetIwadNum())
{
if (shortName[0] == 'V' &&
shortName[1] == 'O' &&
shortName[2] == 'C')
if (shortName.String[0] == 'V' &&
shortName.String[1] == 'O' &&
shortName.String[2] == 'C')
{
int j;
for (j = 3; j < 8; ++j)
{
if (shortName[j] != 0 && !isdigit(shortName[j]))
if (shortName.String[j] != 0 && !isdigit(shortName.String[j]))
break;
}
if (j == 8)
@ -2842,7 +2846,7 @@ void System_CrashInfo(char* buffer, size_t bufflen, const char *lfstr)
buffer += snprintf(buffer, buffend - buffer, " %s", Args->GetArg(i));
}
for (i = 0; (arg = fileSystem.GetContainerName(i)) != NULL; ++i)
for (i = 0; (arg = fileSystem.GetResourceFileName(i)) != NULL; ++i)
{
buffer += mysnprintf(buffer, buffend - buffer, "%sWad %d: %s", lfstr, i, arg);
}
@ -3044,7 +3048,7 @@ static bool FileNameCheck(const char* base, const char* path)
return true;
}
static int FileSystemPrintf(FileSys::FSMessageLevel level, const char* fmt, ...)
static int FileSystemPrintf(FSMessageLevel level, const char* fmt, ...)
{
va_list arg;
va_start(arg, fmt);
@ -3052,22 +3056,22 @@ static int FileSystemPrintf(FileSys::FSMessageLevel level, const char* fmt, ...)
text.VFormat(fmt, arg);
switch (level)
{
case FileSys::FSMessageLevel::Error:
case FSMessageLevel::Error:
return Printf(TEXTCOLOR_RED "%s", text.GetChars());
break;
case FileSys::FSMessageLevel::Warning:
case FSMessageLevel::Warning:
Printf(TEXTCOLOR_YELLOW "%s", text.GetChars());
break;
case FileSys::FSMessageLevel::Attention:
case FSMessageLevel::Attention:
Printf(TEXTCOLOR_BLUE "%s", text.GetChars());
break;
case FileSys::FSMessageLevel::Message:
case FSMessageLevel::Message:
Printf("%s", text.GetChars());
break;
case FileSys::FSMessageLevel::DebugWarn:
case FSMessageLevel::DebugWarn:
DPrintf(DMSG_WARNING, "%s", text.GetChars());
break;
case FileSys::FSMessageLevel::DebugNotify:
case FSMessageLevel::DebugNotify:
DPrintf(DMSG_NOTIFY, "%s", text.GetChars());
break;
}
@ -3139,7 +3143,7 @@ static int D_InitGame(const FIWADInfo* iwad_info, std::vector<std::string>& allw
if (!batchrun) Printf ("W_Init: Init WADfiles.\n");
FileSys::FileSystemFilterInfo lfi;
LumpFilterInfo lfi;
static const struct { int match; const char* name; } blanket[] =
{
@ -3180,7 +3184,7 @@ static int D_InitGame(const FIWADInfo* iwad_info, std::vector<std::string>& allw
);
bool allowduplicates = Args->CheckParm("-allowduplicates");
if (!fileSystem.Initialize(allwads, &lfi, FileSystemPrintf, allowduplicates))
if (!fileSystem.InitMultipleFiles(allwads, &lfi, FileSystemPrintf, allowduplicates))
{
I_FatalError("FileSystem: no files found");
}
@ -3989,12 +3993,12 @@ void I_UpdateWindowTitle()
CCMD(fs_dir)
{
int numfiles = fileSystem.GetFileCount();
int numfiles = fileSystem.GetNumEntries();
for (int i = 0; i < numfiles; i++)
{
auto container = fileSystem.GetContainerFullName(fileSystem.GetFileContainer(i));
auto fn1 = fileSystem.GetFileName(i);
auto container = fileSystem.GetResourceFileFullName(fileSystem.GetFileContainer(i));
auto fn1 = fileSystem.GetFileFullName(i);
auto fns = fileSystem.GetFileShortName(i);
auto fnid = fileSystem.GetResourceId(i);
auto length = fileSystem.FileLength(i);
@ -4006,7 +4010,7 @@ CCMD(fs_dir)
CCMD(type)
{
if (argv.argc() < 2) return;
int lump = fileSystem.FindFile(argv[1]);
int lump = fileSystem.CheckNumForFullName(argv[1]);
if (lump >= 0)
{
auto data = fileSystem.ReadFile(lump);

12
src/g_dumpinfo.cpp
View file

@ -143,7 +143,7 @@ CCMD (mapchecksum)
{
if (argv.argc() == 1)
{ //current map
const char *wadname = fileSystem.GetContainerName(fileSystem.GetFileContainer(level.lumpnum));
const char *wadname = fileSystem.GetResourceFileName(fileSystem.GetFileContainer(level.lumpnum));
for (size_t i = 0; i < 16; ++i)
{
@ -165,7 +165,7 @@ CCMD (mapchecksum)
{
if(!strcmp(argv[i], "*"))
{
const char *wadname = fileSystem.GetContainerName(fileSystem.GetFileContainer(level.lumpnum));
const char *wadname = fileSystem.GetResourceFileName(fileSystem.GetFileContainer(level.lumpnum));
for (size_t i = 0; i < 16; ++i)
{
@ -184,7 +184,7 @@ CCMD (mapchecksum)
else
{
map->GetChecksum(cksum);
const char *wadname = fileSystem.GetContainerName(fileSystem.GetFileContainer(map->lumpnum));
const char *wadname = fileSystem.GetResourceFileName(fileSystem.GetFileContainer(map->lumpnum));
delete map;
for (size_t j = 0; j < sizeof(cksum); ++j)
{
@ -389,7 +389,7 @@ CCMD(targetinv)
CCMD(listmaps)
{
int iwadNum = fileSystem.GetBaseNum();
int iwadNum = fileSystem.GetIwadNum();
for (unsigned i = 0; i < wadlevelinfos.Size(); i++)
{
@ -403,7 +403,7 @@ CCMD(listmaps)
if (argv.argc() == 1
|| CheckWildcards(argv[1], info->MapName.GetChars())
|| CheckWildcards(argv[1], info->LookupLevelName().GetChars())
|| CheckWildcards(argv[1], fileSystem.GetContainerName(mapWadNum)))
|| CheckWildcards(argv[1], fileSystem.GetResourceFileName(mapWadNum)))
{
bool isFromPwad = mapWadNum != iwadNum;
@ -411,7 +411,7 @@ CCMD(listmaps)
Printf("%s%s: '%s' (%s)\n", lineColor, info->MapName.GetChars(),
info->LookupLevelName().GetChars(),
fileSystem.GetContainerName(mapWadNum));
fileSystem.GetResourceFileName(mapWadNum));
}
delete map;
}

8
src/g_game.cpp
View file

@ -1915,7 +1915,7 @@ static bool CheckSingleWad (const char *name, bool &printRequires, bool printwar
{
return true;
}
if (fileSystem.CheckIfContainerLoaded (name) < 0)
if (fileSystem.CheckIfResourceFileLoaded (name) < 0)
{
if (printwarn)
{
@ -2311,11 +2311,11 @@ static void PutSaveWads (FSerializer &arc)
const char *name;
// Name of IWAD
name = fileSystem.GetContainerName (fileSystem.GetBaseNum());
name = fileSystem.GetResourceFileName (fileSystem.GetIwadNum());
arc.AddString("Game WAD", name);
// Name of wad the map resides in
name = fileSystem.GetContainerName (fileSystem.GetFileContainer (primaryLevel->lumpnum));
name = fileSystem.GetResourceFileName (fileSystem.GetFileContainer (primaryLevel->lumpnum));
arc.AddString("Map WAD", name);
}
@ -2909,7 +2909,7 @@ void G_DoPlayDemo (void)
gameaction = ga_nothing;
// [RH] Allow for demos not loaded as lumps
demolump = fileSystem.CheckNumForAnyName (defdemoname.GetChars());
demolump = fileSystem.CheckNumForFullName (defdemoname.GetChars(), true);
if (demolump >= 0)
{
int demolen = fileSystem.FileLength (demolump);

12
src/g_statusbar/sbarinfo.cpp
View file

@ -445,7 +445,7 @@ void SBarInfo::Load()
{
if(gameinfo.statusbar.IsNotEmpty())
{
int lump = fileSystem.CheckNumForAnyName(gameinfo.statusbar.GetChars());
int lump = fileSystem.CheckNumForFullName(gameinfo.statusbar.GetChars(), true);
if(lump != -1)
{
if (!batchrun) Printf ("ParseSBarInfo: Loading default status bar definition.\n");
@ -483,7 +483,7 @@ void SBarInfo::ParseSBarInfo(int lump)
if(sc.TokenType == TK_Include)
{
sc.MustGetToken(TK_StringConst);
int lump = fileSystem.CheckNumForAnyName(sc.String);
int lump = fileSystem.CheckNumForFullName(sc.String, true);
if (lump == -1)
sc.ScriptError("Lump '%s' not found", sc.String);
ParseSBarInfo(lump);
@ -500,15 +500,15 @@ void SBarInfo::ParseSBarInfo(int lump)
sc.MustGetToken(TK_Identifier);
if(sc.Compare("Doom"))
{
baselump = fileSystem.FindFile("sbarinfo/doom.txt");
baselump = fileSystem.CheckNumForFullName("sbarinfo/doom.txt", true);
}
else if(sc.Compare("Heretic"))
{
baselump = fileSystem.FindFile("sbarinfo/heretic.txt");
baselump = fileSystem.CheckNumForFullName("sbarinfo/heretic.txt", true);
}
else if(sc.Compare("Hexen"))
{
baselump = fileSystem.FindFile("sbarinfo/hexen.txt");
baselump = fileSystem.CheckNumForFullName("sbarinfo/hexen.txt", true);
}
else if(sc.Compare("Strife"))
gameType = GAME_Strife;
@ -526,7 +526,7 @@ void SBarInfo::ParseSBarInfo(int lump)
else if (fileSystem.GetFileContainer(baselump) > 0)
{
I_FatalError("File %s is overriding core lump sbarinfo/%s.txt.",
fileSystem.GetContainerFullName(fileSystem.GetFileContainer(baselump)), sc.String);
fileSystem.GetResourceFileFullName(fileSystem.GetFileContainer(baselump)), sc.String);
}
ParseSBarInfo(baselump);
}

16
src/gamedata/d_dehacked.cpp
View file

@ -168,7 +168,7 @@ static void ReplaceSoundName(int index, const char* newname)
if (snd == NO_SOUND) return;
auto sfx = soundEngine->GetWritableSfx(snd);
FStringf dsname("ds%s", newname);
sfx->lumpnum = fileSystem.CheckNumForName(dsname.GetChars(), ns_sounds);
sfx->lumpnum = fileSystem.CheckNumForName(dsname.GetChars(), FileSys::ns_sounds);
sfx->bTentative = false;
sfx->bRandomHeader = false;
sfx->bLoadRAW = false;
@ -3098,7 +3098,7 @@ CVAR(Int, dehload, 0, CVAR_ARCHIVE) // Autoloading of .DEH lumps is disabled by
// checks if lump is a .deh or .bex file. Only lumps in the root directory are considered valid.
static bool isDehFile(int lumpnum)
{
const char* const fullName = fileSystem.GetFileName(lumpnum);
const char* const fullName = fileSystem.GetFileFullName(lumpnum);
const char* const extension = strrchr(fullName, '.');
return NULL != extension && strchr(fullName, '/') == NULL
@ -3113,12 +3113,12 @@ int D_LoadDehLumps(DehLumpSource source, int flags)
{
const int filenum = fileSystem.GetFileContainer(lumpnum);
if (FromIWAD == source && filenum > fileSystem.GetMaxBaseNum())
if (FromIWAD == source && filenum > fileSystem.GetMaxIwadNum())
{
// No more DEHACKED lumps in IWAD
break;
}
else if (FromPWADs == source && filenum <= fileSystem.GetMaxBaseNum())
else if (FromPWADs == source && filenum <= fileSystem.GetMaxIwadNum())
{
// Skip DEHACKED lumps from IWAD
continue;
@ -3128,7 +3128,7 @@ int D_LoadDehLumps(DehLumpSource source, int flags)
if((flags & DEH_SKIP_BEX_STRINGS_IF_LANGUAGE) && FromIWAD == source)
{
int iwadnum = fileSystem.GetBaseNum();
int iwadnum = fileSystem.GetIwadNum();
int lastlump2 = fileSystem.GetFirstEntry(iwadnum);
int lumpnum2 = fileSystem.FindLump("LANGUAGE", &lastlump2);
@ -3146,7 +3146,7 @@ int D_LoadDehLumps(DehLumpSource source, int flags)
if (dehload == 1) // load all .DEH lumps that are found.
{
for (lumpnum = 0, lastlump = fileSystem.GetFileCount(); lumpnum < lastlump; ++lumpnum)
for (lumpnum = 0, lastlump = fileSystem.GetNumEntries(); lumpnum < lastlump; ++lumpnum)
{
if (isDehFile(lumpnum))
{
@ -3156,7 +3156,7 @@ int D_LoadDehLumps(DehLumpSource source, int flags)
}
else // only load the last .DEH lump that is found.
{
for (lumpnum = fileSystem.GetFileCount()-1; lumpnum >=0; --lumpnum)
for (lumpnum = fileSystem.GetNumEntries()-1; lumpnum >=0; --lumpnum)
{
if (isDehFile(lumpnum))
{
@ -3205,7 +3205,7 @@ bool D_LoadDehFile(const char *patchfile, int flags)
else
{
// Couldn't find it in the filesystem; try from a lump instead.
int lumpnum = fileSystem.FindFile(patchfile);
int lumpnum = fileSystem.CheckNumForFullName(patchfile, true);
if (lumpnum < 0)
{
// Compatibility fallback. It's just here because

2
src/gamedata/decallib.cpp
View file

@ -397,7 +397,7 @@ void FDecalLib::ParseDecal (FScanner &sc)
case DECAL_PIC:
sc.MustGetString ();
picnum = TexMan.CheckForTexture (sc.String, ETextureType::Any);
if (!picnum.Exists() && (lumpnum = fileSystem.CheckNumForName (sc.String, ns_graphics)) >= 0)
if (!picnum.Exists() && (lumpnum = fileSystem.CheckNumForName (sc.String, FileSys::ns_graphics)) >= 0)
{
picnum = TexMan.CreateTexture (lumpnum, ETextureType::Decal);
}

14
src/gamedata/doomfont.h
View file

@ -18,9 +18,9 @@ void InitDoomFonts()
if (fileSystem.CheckNumForName("FONTA_S") >= 0)
{
int wadfile = -1;
auto a = fileSystem.CheckNumForName("FONTA33", ns_graphics);
auto a = fileSystem.CheckNumForName("FONTA33", FileSys::ns_graphics);
if (a != -1) wadfile = fileSystem.GetFileContainer(a);
if (wadfile > fileSystem.GetBaseNum())
if (wadfile > fileSystem.GetIwadNum())
{
// The font has been replaced, so we need to create a copy of the original as well.
SmallFont = new FFont("SmallFont", "FONTA%02u", nullptr, HU_FONTSTART, HU_FONTSIZE, 1, -1);
@ -32,12 +32,12 @@ void InitDoomFonts()
SmallFont->SetCursor('[');
}
}
else if (fileSystem.CheckNumForName("STCFN033", ns_graphics) >= 0)
else if (fileSystem.CheckNumForName("STCFN033", FileSys::ns_graphics) >= 0)
{
int wadfile = -1;
auto a = fileSystem.CheckNumForName("STCFN065", ns_graphics);
auto a = fileSystem.CheckNumForName("STCFN065", FileSys::ns_graphics);
if (a != -1) wadfile = fileSystem.GetFileContainer(a);
if (wadfile > fileSystem.GetBaseNum())
if (wadfile > fileSystem.GetIwadNum())
{
// The font has been replaced, so we need to create a copy of the original as well.
SmallFont = new FFont("SmallFont", "STCFN%.3d", nullptr, HU_FONTSTART, HU_FONTSIZE, HU_FONTSTART, -1, -1, false, false, true);
@ -55,7 +55,7 @@ void InitDoomFonts()
OriginalSmallFont = new FFont("OriginalSmallFont", "FONTA%02u", "defsmallfont", HU_FONTSTART, HU_FONTSIZE, 1, -1, -1, false, true);
OriginalSmallFont->SetCursor('[');
}
else if (fileSystem.CheckNumForName("STCFN033", ns_graphics) >= 0)
else if (fileSystem.CheckNumForName("STCFN033", FileSys::ns_graphics) >= 0)
{
OriginalSmallFont = new FFont("OriginalSmallFont", "STCFN%.3d", "defsmallfont", HU_FONTSTART, HU_FONTSIZE, HU_FONTSTART, -1, -1, false, true, true);
}
@ -63,7 +63,7 @@ void InitDoomFonts()
if (!(SmallFont2 = V_GetFont("SmallFont2"))) // Only used by Strife
{
if (fileSystem.CheckNumForName("STBFN033", ns_graphics) >= 0)
if (fileSystem.CheckNumForName("STBFN033", FileSys::ns_graphics) >= 0)
{
SmallFont2 = new FFont("SmallFont2", "STBFN%.3d", "defsmallfont2", HU_FONTSTART, HU_FONTSIZE, HU_FONTSTART, -1);
}

20
src/gamedata/g_mapinfo.cpp
View file

@ -941,12 +941,12 @@ void FMapInfoParser::ParseCluster()
// Remap Hexen's CLUS?MSG lumps to the string table, if applicable. The code here only checks what can actually be in an IWAD.
if (clusterinfo->flags & CLUSTER_EXITTEXTINLUMP)
{
int lump = fileSystem.CheckNumForAnyName(clusterinfo->ExitText.GetChars());
int lump = fileSystem.CheckNumForFullName(clusterinfo->ExitText.GetChars(), true);
if (lump > 0)
{
// Check if this comes from either Hexen.wad or Hexdd.wad and if so, map to the string table.
int fileno = fileSystem.GetFileContainer(lump);
auto fn = fileSystem.GetContainerName(fileno);
auto fn = fileSystem.GetResourceFileName(fileno);
if (fn && (!stricmp(fn, "HEXEN.WAD") || !stricmp(fn, "HEXDD.WAD")))
{
FStringf key("TXT_%.5s_%s", fn, clusterinfo->ExitText.GetChars());
@ -2217,7 +2217,7 @@ level_info_t *FMapInfoParser::ParseMapHeader(level_info_t &defaultinfo)
{
// Try to localize Hexen's map names. This does not use the above feature to allow these names to be unique.
int fileno = fileSystem.GetFileContainer(sc.LumpNum);
auto fn = fileSystem.GetContainerName(fileno);
auto fn = fileSystem.GetResourceFileName(fileno);
if (fn && (!stricmp(fn, "HEXEN.WAD") || !stricmp(fn, "HEXDD.WAD")))
{
FStringf key("TXT_%.5s_%s", fn, levelinfo->MapName.GetChars());
@ -2447,7 +2447,7 @@ void FMapInfoParser::ParseMapInfo (int lump, level_info_t &gamedefaults, level_i
if (sc.Compare("include"))
{
sc.MustGetString();
int inclump = fileSystem.CheckNumForAnyName(sc.String);
int inclump = fileSystem.CheckNumForFullName(sc.String, true);
if (inclump < 0)
{
sc.ScriptError("include file '%s' not found", sc.String);
@ -2458,7 +2458,7 @@ void FMapInfoParser::ParseMapInfo (int lump, level_info_t &gamedefaults, level_i
if (fileSystem.GetFileContainer(sc.LumpNum) == 0)
{
I_FatalError("File %s is overriding core lump %s.",
fileSystem.GetContainerFullName(fileSystem.GetFileContainer(inclump)), sc.String);
fileSystem.GetResourceFileFullName(fileSystem.GetFileContainer(inclump)), sc.String);
}
}
// use a new parser object to parse the include. Otherwise we'd have to save the entire FScanner in a local variable which is a lot more messy.
@ -2700,11 +2700,11 @@ void G_ParseMapInfo (FString basemapinfo)
{
FMapInfoParser parse;
level_info_t defaultinfo;
int baselump = fileSystem.GetFile(basemapinfo.GetChars());
int baselump = fileSystem.GetNumForFullName(basemapinfo.GetChars());
if (fileSystem.GetFileContainer(baselump) > 0)
{
I_FatalError("File %s is overriding core lump %s.",
fileSystem.GetContainerName(fileSystem.GetFileContainer(baselump)), basemapinfo.GetChars());
fileSystem.GetResourceFileName(fileSystem.GetFileContainer(baselump)), basemapinfo.GetChars());
}
parse.ParseMapInfo(baselump, gamedefaults, defaultinfo);
}
@ -2725,7 +2725,7 @@ void G_ParseMapInfo (FString basemapinfo)
// If that exists we need to skip this one.
int wad = fileSystem.GetFileContainer(lump);
int altlump = fileSystem.CheckNumForName("ZMAPINFO", ns_global, wad, true);
int altlump = fileSystem.CheckNumForName("ZMAPINFO", FileSys::ns_global, wad, true);
if (altlump >= 0) continue;
}
@ -2733,9 +2733,9 @@ void G_ParseMapInfo (FString basemapinfo)
{
// MAPINFO and ZMAPINFO will override UMAPINFO if in the same WAD.
int wad = fileSystem.GetFileContainer(lump);
int altlump = fileSystem.CheckNumForName("ZMAPINFO", ns_global, wad, true);
int altlump = fileSystem.CheckNumForName("ZMAPINFO", FileSys::ns_global, wad, true);
if (altlump >= 0) continue;
altlump = fileSystem.CheckNumForName("MAPINFO", ns_global, wad, true);
altlump = fileSystem.CheckNumForName("MAPINFO", FileSys::ns_global, wad, true);
if (altlump >= 0) continue;
}
if (nindex != 2)

2
src/gamedata/statistics.cpp
View file

@ -468,7 +468,7 @@ void STAT_ChangeLevel(const char *newl, FLevelLocals *Level)
wad = fileSystem.GetFileContainer(map->lumpnum);
delete map;
}
const char * name = fileSystem.GetContainerName(wad);
const char * name = fileSystem.GetResourceFileName(wad);
FString section = ExtractFileBase(name) + "." + StartEpisode->mEpisodeMap;
section.ToUpper();

8
src/gamedata/textures/buildloader.cpp
View file

@ -255,11 +255,11 @@ void InitBuildTiles()
// Unfortunately neither the palettes nor the .ART files contain any usable identifying marker
// so this can only go by the file names.
int numlumps = fileSystem.GetFileCount();
int numlumps = fileSystem.GetNumEntries();
for (int i = 0; i < numlumps; i++)
{
const char* name = fileSystem.GetFileName(i);
if (fileSystem.FindFile(name) != i) continue; // This palette is hidden by a later one. Do not process
const char* name = fileSystem.GetFileFullName(i);
if (fileSystem.CheckNumForFullName(name) != i) continue; // This palette is hidden by a later one. Do not process
FString base = ExtractFileBase(name, true);
base.ToLower();
if (base.Compare("palette.dat") == 0 && fileSystem.FileLength(i) >= 768) // must be a valid palette, i.e. at least 256 colors.
@ -276,7 +276,7 @@ void InitBuildTiles()
// only read from the same source as the palette.
// The entire format here is just too volatile to allow liberal mixing.
// An .ART set must be treated as one unit.
lumpnum = fileSystem.GetFileInContainer(artpath.GetChars(), fileSystem.GetFileContainer(i));
lumpnum = fileSystem.CheckNumForFullName(artpath.GetChars(), fileSystem.GetFileContainer(i));
if (lumpnum < 0)
{
break;

2
src/gamedata/xlat/parsecontext.cpp
View file

@ -314,7 +314,7 @@ void FParseContext::ParseLump(const char *lumpname)
const char *SavedSourceFile = SourceFile;
FParseToken token;
int lumpno = fileSystem.CheckNumForAnyName(lumpname);
int lumpno = fileSystem.CheckNumForFullName(lumpname, true);
if (lumpno == -1)
{

8
src/intermission/intermission_parse.cpp
View file

@ -303,13 +303,13 @@ bool FIntermissionActionTextscreen::ParseKey(FScanner &sc)
{
sc.MustGetToken('=');
sc.MustGetToken(TK_StringConst);
int lump = fileSystem.CheckNumForAnyName(sc.String);
int lump = fileSystem.CheckNumForFullName(sc.String, true);
bool done = false;
if (lump > 0)
{
// Check if this comes from either Hexen.wad or Hexdd.wad and if so, map to the string table.
int fileno = fileSystem.GetFileContainer(lump);
auto fn = fileSystem.GetContainerName(fileno);
auto fn = fileSystem.GetResourceFileName(fileno);
if (fn && (!stricmp(fn, "HEXEN.WAD") || !stricmp(fn, "HEXDD.WAD")))
{
FStringf key("TXT_%.5s_%s", fn, sc.String);
@ -325,7 +325,7 @@ bool FIntermissionActionTextscreen::ParseKey(FScanner &sc)
else
{
// only print an error if coming from a PWAD
if (fileSystem.GetFileContainer(sc.LumpNum) > fileSystem.GetMaxBaseNum())
if (fileSystem.GetFileContainer(sc.LumpNum) > fileSystem.GetMaxIwadNum())
sc.ScriptMessage("Unknown text lump '%s'", sc.String);
mText.Format("Unknown text lump '%s'", sc.String);
}
@ -861,7 +861,7 @@ DIntermissionController* F_StartFinale (const char *music, int musicorder, int c
FIntermissionActionTextscreen *textscreen = new FIntermissionActionTextscreen;
if (textInLump)
{
int lump = fileSystem.CheckNumForAnyName(text);
int lump = fileSystem.CheckNumForFullName(text, true);
if (lump > 0)
{
textscreen->mText = GetStringFromLump(lump);

4
src/maploader/compatibility.cpp
View file

@ -213,7 +213,7 @@ void ParseCompatibility()
// The contents of this file are not cumulative, as it should not
// be present in user-distributed maps.
FScanner sc(fileSystem.GetFile("compatibility.txt"));
FScanner sc(fileSystem.GetNumForFullName("compatibility.txt"));
while (sc.GetString()) // Get MD5 signature
{
@ -297,7 +297,7 @@ FName MapLoader::CheckCompatibility(MapData *map)
// When playing Doom IWAD levels force BCOMPATF_NOSECTIONMERGE, COMPAT_SHORTTEX and COMPATF_LIGHT.
// I'm not sure if the IWAD maps actually need COMPATF_LIGHT but it certainly does not hurt.
// TNT's MAP31 also needs COMPATF_STAIRINDEX but that only gets activated for TNT.WAD.
if (fileSystem.GetFileContainer(map->lumpnum) == fileSystem.GetBaseNum())
if (fileSystem.GetFileContainer(map->lumpnum) == fileSystem.GetIwadNum())
{
if ((gameinfo.flags & GI_COMPATSHORTTEX) && Level->maptype == MAPTYPE_DOOM)
{

2
src/maploader/edata.cpp
View file

@ -520,7 +520,7 @@ void MapLoader::InitED()
FScanner sc;
if (filename.IsEmpty()) return;
int lump = fileSystem.CheckNumForAnyName(filename.GetChars(), ns_global);
int lump = fileSystem.CheckNumForFullName(filename.GetChars(), true, FileSys::ns_global);
if (lump == -1) return;
sc.OpenLumpNum(lump);

12
src/maploader/glnodes.cpp
View file

@ -727,17 +727,17 @@ static int FindGLNodesInWAD(int labellump)
int wadfile = fileSystem.GetFileContainer(labellump);
FString glheader;
glheader.Format("GL_%s", fileSystem.GetFileName(labellump));
glheader.Format("GL_%s", fileSystem.GetFileFullName(labellump));
if (glheader.Len()<=8)
{
int gllabel = fileSystem.CheckNumForName(glheader.GetChars(), ns_global, wadfile);
int gllabel = fileSystem.CheckNumForName(glheader.GetChars(), FileSys::ns_global, wadfile);
if (gllabel >= 0) return gllabel;
}
else
{
// Before scanning the entire WAD directory let's check first whether
// it is necessary.
int gllabel = fileSystem.CheckNumForName("GL_LEVEL", ns_global, wadfile);
int gllabel = fileSystem.CheckNumForName("GL_LEVEL", FileSys::ns_global, wadfile);
if (gllabel >= 0)
{
@ -748,7 +748,7 @@ static int FindGLNodesInWAD(int labellump)
if (fileSystem.GetFileContainer(lump)==wadfile)
{
auto mem = fileSystem.ReadFile(lump);
if (MatchHeader(fileSystem.GetFileName(labellump), GetStringFromLump(lump).GetChars())) return lump;
if (MatchHeader(fileSystem.GetFileFullName(labellump), GetStringFromLump(lump).GetChars())) return lump;
}
}
}
@ -853,7 +853,7 @@ bool MapLoader::LoadGLNodes(MapData * map)
bool mapinwad = map->InWad;
FResourceFile * f_gwa = map->resource;
const char * name = fileSystem.GetContainerFullName(lumpfile);
const char * name = fileSystem.GetResourceFileFullName(lumpfile);
if (mapinwad)
{
@ -881,7 +881,7 @@ bool MapLoader::LoadGLNodes(MapData * map)
f_gwa = FResourceFile::OpenResourceFile(path);
if (f_gwa==nullptr) return false;
strncpy(map->MapLumps[0].Name, fileSystem.GetFileName(map->lumpnum), 8);
strncpy(map->MapLumps[0].Name, fileSystem.GetFileFullName(map->lumpnum), 8);
}
}
}

10
src/maploader/strifedialogue.cpp
View file

@ -159,7 +159,7 @@ bool MapLoader::LoadScriptFile (const char *name, bool include, int type)
{
int lumpnum = fileSystem.CheckNumForName (name);
const bool found = lumpnum >= 0
|| (lumpnum = fileSystem.FindFile (name)) >= 0;
|| (lumpnum = fileSystem.CheckNumForFullName (name)) >= 0;
if (!found)
{
@ -173,7 +173,7 @@ bool MapLoader::LoadScriptFile (const char *name, bool include, int type)
FileReader lump = fileSystem.ReopenFileReader (lumpnum);
auto fn = fileSystem.GetFileContainer(lumpnum);
auto wadname = fileSystem.GetContainerName(fn);
auto wadname = fileSystem.GetResourceFileName(fn);
if (stricmp(wadname, "STRIFE0.WAD") && stricmp(wadname, "STRIFE1.WAD") && stricmp(wadname, "SVE.WAD")) name = nullptr; // Only localize IWAD content.
bool res = LoadScriptFile(name, lumpnum, lump, fileSystem.FileLength(lumpnum), include, type);
@ -195,7 +195,7 @@ bool MapLoader::LoadScriptFile(const char *name, int lumpnum, FileReader &lump,
if ((type == 1 && !isbinary) || (type == 2 && isbinary))
{
DPrintf(DMSG_ERROR, "Incorrect data format for conversation script in %s.\n", fileSystem.GetFileName(lumpnum));
DPrintf(DMSG_ERROR, "Incorrect data format for conversation script in %s.\n", fileSystem.GetFileFullName(lumpnum));
return false;
}
@ -215,7 +215,7 @@ bool MapLoader::LoadScriptFile(const char *name, int lumpnum, FileReader &lump,
// is exactly 1516 bytes long.
if (numnodes % 1516 != 0)
{
DPrintf(DMSG_ERROR, "Incorrect data format for conversation script in %s.\n", fileSystem.GetFileName(lumpnum));
DPrintf(DMSG_ERROR, "Incorrect data format for conversation script in %s.\n", fileSystem.GetFileFullName(lumpnum));
return false;
}
numnodes /= 1516;
@ -225,7 +225,7 @@ bool MapLoader::LoadScriptFile(const char *name, int lumpnum, FileReader &lump,
// And the teaser version has 1488-byte entries.
if (numnodes % 1488 != 0)
{
DPrintf(DMSG_ERROR, "Incorrect data format for conversation script in %s.\n", fileSystem.GetFileName(lumpnum));
DPrintf(DMSG_ERROR, "Incorrect data format for conversation script in %s.\n", fileSystem.GetFileFullName(lumpnum));
return false;
}
numnodes /= 1488;

2
src/maploader/udmf.cpp
View file

@ -2481,7 +2481,7 @@ public:
isExtended = false;
floordrop = false;
sc.OpenMem(fileSystem.GetFileName(map->lumpnum), map->Read(ML_TEXTMAP));
sc.OpenMem(fileSystem.GetFileFullName(map->lumpnum), map->Read(ML_TEXTMAP));
sc.SetCMode(true);
if (sc.CheckString("namespace"))
{

2
src/maploader/usdf.cpp
View file

@ -562,7 +562,7 @@ public:
bool Parse(MapLoader *loader,int lumpnum, FileReader &lump, int lumplen)
{
Level = loader->Level;
sc.OpenMem(fileSystem.GetFileName(lumpnum), lump.Read(lumplen));
sc.OpenMem(fileSystem.GetFileFullName(lumpnum), lump.Read(lumplen));
sc.SetCMode(true);
// Namespace must be the first field because everything else depends on it.
if (sc.CheckString("namespace"))

2
src/menu/loadsavemenu.cpp
View file

@ -116,7 +116,7 @@ void FSavegameManager::ReadSaveStrings()
// old, incompatible savegame. List as not usable.
oldVer = true;
}
else if (iwad.CompareNoCase(fileSystem.GetContainerName(fileSystem.GetBaseNum())) == 0)
else if (iwad.CompareNoCase(fileSystem.GetResourceFileName(fileSystem.GetIwadNum())) == 0)
{
missing = !G_CheckSaveGameWads(arc, false);
}

14
src/p_openmap.cpp
View file

@ -140,9 +140,9 @@ MapData *P_OpenMapData(const char * mapname, bool justcheck)
// Names with more than 8 characters will only be checked as .wad and .map.
if (strlen(mapname) <= 8) lump_name = fileSystem.CheckNumForName(mapname);
fmt.Format("maps/%s.wad", mapname);
lump_wad = fileSystem.FindFile(fmt.GetChars());
lump_wad = fileSystem.CheckNumForFullName(fmt.GetChars());
fmt.Format("maps/%s.map", mapname);
lump_map = fileSystem.FindFile(fmt.GetChars());
lump_map = fileSystem.CheckNumForFullName(fmt.GetChars());
if (lump_name > lump_wad && lump_name > lump_map && lump_name != -1)
{
@ -167,18 +167,18 @@ MapData *P_OpenMapData(const char * mapname, bool justcheck)
// This case can only happen if the lump is inside a real WAD file.
// As such any special handling for other types of lumps is skipped.
map->MapLumps[0].Reader = fileSystem.ReopenFileReader(lump_name);
strncpy(map->MapLumps[0].Name, fileSystem.GetFileName(lump_name), 8);
strncpy(map->MapLumps[0].Name, fileSystem.GetFileFullName(lump_name), 8);
map->InWad = true;
int index = 0;
if (stricmp(fileSystem.GetFileName(lump_name + 1), "TEXTMAP") != 0)
if (stricmp(fileSystem.GetFileFullName(lump_name + 1), "TEXTMAP") != 0)
{
for(int i = 1;; i++)
{
// Since levels must be stored in WADs they can't really have full
// names and for any valid level lump this always returns the short name.
const char * lumpname = fileSystem.GetFileName(lump_name + i);
const char * lumpname = fileSystem.GetFileFullName(lump_name + i);
try
{
index = GetMapIndex(mapname, index, lumpname, !justcheck);
@ -208,7 +208,7 @@ MapData *P_OpenMapData(const char * mapname, bool justcheck)
map->MapLumps[1].Reader = fileSystem.ReopenFileReader(lump_name + 1);
for(int i = 2;; i++)
{
const char * lumpname = fileSystem.GetFileName(lump_name + i);
const char * lumpname = fileSystem.GetFileFullName(lump_name + i);
if (lumpname == NULL)
{
@ -264,7 +264,7 @@ MapData *P_OpenMapData(const char * mapname, bool justcheck)
}
map->lumpnum = lump_wad;
auto reader = fileSystem.ReopenFileReader(lump_wad);
map->resource = FResourceFile::OpenResourceFile(fileSystem.GetFileName(lump_wad), reader, true);
map->resource = FResourceFile::OpenResourceFile(fileSystem.GetFileFullName(lump_wad), reader, true);
wadReader = map->resource->GetContainerReader();
}
}

2
src/playsim/fragglescript/t_func.cpp
View file

@ -54,6 +54,8 @@
#include "s_music.h"
#include "texturemanager.h"
using namespace FileSys;
static FRandom pr_script("FScript");
// functions. FParser::SF_ means Script Function not, well.. heh, me

8
src/playsim/p_acs.cpp
View file

@ -1930,7 +1930,7 @@ void FBehaviorContainer::LoadDefaultModules ()
FScanner sc(lump);
while (sc.GetString())
{
int acslump = fileSystem.CheckNumForName (sc.String, ns_acslibrary);
int acslump = fileSystem.CheckNumForName (sc.String, FileSys::ns_acslibrary);
if (acslump >= 0)
{
LoadModule (acslump);
@ -1963,7 +1963,7 @@ FBehavior *FBehaviorContainer::LoadModule (int lumpnum, FileReader *fr, int len,
else
{
delete behavior;
Printf(TEXTCOLOR_RED "%s: invalid ACS module\n", fileSystem.GetFileName(lumpnum));
Printf(TEXTCOLOR_RED "%s: invalid ACS module\n", fileSystem.GetFileFullName(lumpnum));
return NULL;
}
}
@ -2322,7 +2322,7 @@ bool FBehavior::Init(FLevelLocals *Level, int lumpnum, FileReader * fr, int len,
if ((Level->flags2 & LEVEL2_HEXENHACK) && gameinfo.gametype == GAME_Hexen && lumpnum == -1 && reallumpnum > 0)
{
int fileno = fileSystem.GetFileContainer(reallumpnum);
const char * filename = fileSystem.GetContainerName(fileno);
const char * filename = fileSystem.GetResourceFileName(fileno);
if (!stricmp(filename, "HEXEN.WAD") || !stricmp(filename, "HEXDD.WAD"))
{
ShouldLocalize = true;
@ -2567,7 +2567,7 @@ bool FBehavior::Init(FLevelLocals *Level, int lumpnum, FileReader * fr, int len,
if (parse[i])
{
FBehavior *module = NULL;
int lump = fileSystem.CheckNumForName (&parse[i], ns_acslibrary);
int lump = fileSystem.CheckNumForName (&parse[i], FileSys::ns_acslibrary);
if (lump < 0)
{
Printf (TEXTCOLOR_RED "Could not find ACS library %s.\n", &parse[i]);

12
src/playsim/p_user.cpp
View file

@ -410,7 +410,7 @@ void player_t::SetLogNumber (int num)
if (lumpnum != -1)
{
auto fn = fileSystem.GetFileContainer(lumpnum);
auto wadname = fileSystem.GetContainerName(fn);
auto wadname = fileSystem.GetResourceFileName(fn);
if (!stricmp(wadname, "STRIFE0.WAD") || !stricmp(wadname, "STRIFE1.WAD") || !stricmp(wadname, "SVE.WAD"))
{
// If this is an original IWAD text, try looking up its lower priority string version first.
@ -874,16 +874,16 @@ static int SetupCrouchSprite(AActor *self, int crouchsprite)
FString normspritename = sprites[self->SpawnState->sprite].name;
FString crouchspritename = sprites[crouchsprite].name;
int spritenorm = fileSystem.CheckNumForName((normspritename + "A1").GetChars(), ns_sprites);
int spritenorm = fileSystem.CheckNumForName((normspritename + "A1").GetChars(), FileSys::ns_sprites);
if (spritenorm == -1)
{
spritenorm = fileSystem.CheckNumForName((normspritename + "A0").GetChars(), ns_sprites);
spritenorm = fileSystem.CheckNumForName((normspritename + "A0").GetChars(), FileSys::ns_sprites);
}
int spritecrouch = fileSystem.CheckNumForName((crouchspritename + "A1").GetChars(), ns_sprites);
int spritecrouch = fileSystem.CheckNumForName((crouchspritename + "A1").GetChars(), FileSys::ns_sprites);
if (spritecrouch == -1)
{
spritecrouch = fileSystem.CheckNumForName((crouchspritename + "A0").GetChars(), ns_sprites);
spritecrouch = fileSystem.CheckNumForName((crouchspritename + "A0").GetChars(), FileSys::ns_sprites);
}
if (spritenorm == -1 || spritecrouch == -1)
@ -895,7 +895,7 @@ static int SetupCrouchSprite(AActor *self, int crouchsprite)
int wadnorm = fileSystem.GetFileContainer(spritenorm);
int wadcrouch = fileSystem.GetFileContainer(spritenorm);
if (wadnorm > fileSystem.GetMaxBaseNum() && wadcrouch <= fileSystem.GetMaxBaseNum())
if (wadnorm > fileSystem.GetMaxIwadNum() && wadcrouch <= fileSystem.GetMaxIwadNum())
{
// Question: Add an option / disable crouching or do what?
return false;

6
src/r_data/colormaps.cpp
View file

@ -100,15 +100,15 @@ void R_InitColormaps (bool allowCustomColormap)
cm.blend = 0;
fakecmaps.Push(cm);
uint32_t NumLumps = fileSystem.GetFileCount();
uint32_t NumLumps = fileSystem.GetNumEntries();
for (uint32_t i = 0; i < NumLumps; i++)
{
if (fileSystem.GetFileNamespace(i) == ns_colormaps)
if (fileSystem.GetFileNamespace(i) == FileSys::ns_colormaps)
{
auto name = fileSystem.GetFileShortName(i);
if (fileSystem.CheckNumForName (name, ns_colormaps) == (int)i)
if (fileSystem.CheckNumForName (name, FileSys::ns_colormaps) == (int)i)
{
strncpy(cm.name, name, 8);
cm.blend = 0;

8
src/r_data/gldefs.cpp
View file

@ -134,7 +134,7 @@ static void ParseVavoomSkybox()
sc.MustGetStringName("map");
sc.MustGetString();
maplump = fileSystem.CheckNumForAnyName(sc.String);
maplump = fileSystem.CheckNumForFullName(sc.String, true);
auto tex = TexMan.FindGameTexture(sc.String, ETextureType::Wall, FTextureManager::TEXMAN_TryAny);
if (tex == NULL)
@ -1234,7 +1234,7 @@ class GLDefsParser
if (lumpnum != -1)
{
if (iwad && fileSystem.GetFileContainer(lumpnum) <= fileSystem.GetMaxBaseNum()) useme = true;
if (iwad && fileSystem.GetFileContainer(lumpnum) <= fileSystem.GetMaxIwadNum()) useme = true;
if (thiswad && fileSystem.GetFileContainer(lumpnum) == fileSystem.GetFileContainer(workingLump)) useme = true;
}
if (!useme) return;
@ -1421,7 +1421,7 @@ class GLDefsParser
if (lumpnum != -1)
{
if (iwad && fileSystem.GetFileContainer(lumpnum) <= fileSystem.GetMaxBaseNum()) useme = true;
if (iwad && fileSystem.GetFileContainer(lumpnum) <= fileSystem.GetMaxIwadNum()) useme = true;
if (thiswad && fileSystem.GetFileContainer(lumpnum) == fileSystem.GetFileContainer(workingLump)) useme = true;
}
if (!useme) return;
@ -1928,7 +1928,7 @@ public:
{
sc.MustGetString();
// This is not using sc.Open because it can print a more useful error message when done here
lump = fileSystem.CheckNumForAnyName(sc.String);
lump = fileSystem.CheckNumForFullName(sc.String, true);
if (lump==-1)
sc.ScriptError("Lump '%s' not found", sc.String);

2
src/r_data/models.cpp
View file

@ -1050,7 +1050,7 @@ void ParseModelDefLump(int Lump)
{
sc.MustGetString();
// This is not using sc.Open because it can print a more useful error message when done here
int includelump = fileSystem.CheckNumForAnyName(sc.String);
int includelump = fileSystem.CheckNumForFullName(sc.String, true);
if (includelump == -1)
{
if (strcmp(sc.String, "sentinel.modl") != 0) // Gene Tech mod has a broken #include statement

2
src/r_data/r_translate.cpp
View file

@ -783,7 +783,7 @@ void R_ParseTrnslate()
do
{
sc.MustGetToken(TK_StringConst);
int pallump = fileSystem.CheckNumForAnyName(sc.String, ns_global);
int pallump = fileSystem.CheckNumForFullName(sc.String, true, FileSys::ns_global);
if (pallump >= 0) //
{
int start = 0;

14
src/r_data/sprites.cpp
View file

@ -344,12 +344,12 @@ void R_InitSpriteDefs ()
}
// Repeat, for voxels
vmax = fileSystem.GetFileCount();
vmax = fileSystem.GetNumEntries();
TArray<VHasher> vhashes(vmax, true);
memset(vhashes.Data(), -1, sizeof(VHasher)*vmax);
for (i = 0; i < vmax; ++i)
{
if (fileSystem.GetFileNamespace(i) == ns_voxels)
if (fileSystem.GetFileNamespace(i) == FileSys::ns_voxels)
{
size_t namelen;
int spin;
@ -588,7 +588,7 @@ void R_InitSkins (void)
{
// The player sprite has 23 frames. This means that the S_SKIN
// marker needs a minimum of 23 lumps after it.
if (base >= fileSystem.GetFileCount() - 23 || base == -1)
if (base >= fileSystem.GetNumEntries() - 23 || base == -1)
continue;
i++;
@ -715,7 +715,7 @@ void R_InitSkins (void)
int lump = fileSystem.CheckNumForName (sc.String, Skins[i].namespc);
if (lump == -1)
{
lump = fileSystem.CheckNumForAnyName (sc.String, ns_sounds);
lump = fileSystem.CheckNumForFullName (sc.String, true, FileSys::ns_sounds);
}
if (lump != -1)
{
@ -748,7 +748,7 @@ void R_InitSkins (void)
sndlumps[j] = fileSystem.CheckNumForName (sc.String, Skins[i].namespc);
if (sndlumps[j] == -1)
{ // Replacement not found, try finding it in the global namespace
sndlumps[j] = fileSystem.CheckNumForAnyName (sc.String, ns_sounds);
sndlumps[j] = fileSystem.CheckNumForFullName (sc.String, true, FileSys::ns_sounds);
}
}
}
@ -946,7 +946,7 @@ CCMD (skins)
static void R_CreateSkinTranslation (const char *palname)
{
auto lump = fileSystem.ReadFile (fileSystem.GetNumForName(palname));
auto lump = fileSystem.ReadFile (palname);
auto otherPal = lump.bytes();
for (int i = 0; i < 256; ++i)
@ -1016,7 +1016,7 @@ void R_InitSprites ()
Skins[i].range0end = basetype->IntVar(NAME_ColorRangeEnd);
Skins[i].Scale = basetype->Scale;
Skins[i].sprite = basetype->SpawnState->sprite;
Skins[i].namespc = ns_global;
Skins[i].namespc = FileSys::ns_global;
PlayerClasses[i].Skins.Push (i);

4
src/r_data/v_palette.cpp
View file

@ -44,6 +44,8 @@
#include "m_png.h"
#include "v_colortables.h"
using namespace FileSys;
/* Current color blending values */
int BlendR, BlendG, BlendB, BlendA;
@ -62,7 +64,7 @@ void InitPalette ()
if (lump == -1) lump = fileSystem.CheckNumForName("COLORMAP", ns_colormaps);
if (lump != -1)
{
auto cmap = fileSystem.ReadFile(lump);
FileData cmap = fileSystem.ReadFile(lump);
auto cmapdata = cmap.bytes();
GPalette.GenerateGlobalBrightmapFromColormap(cmapdata, 32);
MakeGoodRemap((uint32_t*)GPalette.BaseColors, GPalette.Remap, cmapdata + 7936); // last entry in colormap

4
src/r_data/voxeldef.cpp
View file

@ -50,6 +50,8 @@
#include "g_level.h"
#include "r_data/sprites.h"
using namespace FileSys;
struct VoxelOptions
{
int DroppedSpin = 0;
@ -280,7 +282,7 @@ void R_InitVoxels()
sc.SetCMode(true);
sc.MustGetToken(TK_StringConst);
voxelfile = fileSystem.CheckNumForAnyName(sc.String, ns_voxels);
voxelfile = fileSystem.CheckNumForFullName(sc.String, true, ns_voxels);
if (voxelfile < 0)
{
sc.ScriptMessage("Voxel \"%s\" not found.\n", sc.String);

8
src/rendering/swrenderer/r_swcolormaps.cpp
View file

@ -346,12 +346,12 @@ void SetDefaultColormap (const char *name)
uint8_t unremap[256];
uint8_t remap[256];
lump = fileSystem.CheckNumForAnyName (name, ns_colormaps);
lump = fileSystem.CheckNumForFullName (name, true, FileSys::ns_colormaps);
if (lump == -1)
lump = fileSystem.CheckNumForName (name, ns_global);
lump = fileSystem.CheckNumForName (name, FileSys::ns_global);
// [RH] If using BUILD's palette, generate the colormap
if (lump == -1 || fileSystem.FindFile("palette.dat") >= 0 || fileSystem.FindFile("blood.pal") >= 0)
if (lump == -1 || fileSystem.CheckNumForFullName("palette.dat") >= 0 || fileSystem.CheckNumForFullName("blood.pal") >= 0)
{
DPrintf (DMSG_NOTIFY, "Make colormap\n");
FDynamicColormap foo;
@ -403,7 +403,7 @@ static void InitBoomColormaps ()
// This is a really rough hack, but it's better than
// not doing anything with them at all (right?)
uint32_t NumLumps = fileSystem.GetFileCount();
uint32_t NumLumps = fileSystem.GetNumEntries();
realcolormaps.Maps = new uint8_t[256*NUMCOLORMAPS*fakecmaps.Size()];
SetDefaultColormap ("COLORMAP");

4
src/scripting/decorate/thingdef_parse.cpp
View file

@ -1282,11 +1282,11 @@ void ParseDecorate (FScanner &sc, PNamespace *ns)
// This check needs to remain overridable for testing purposes.
if (fileSystem.GetFileContainer(sc.LumpNum) == 0 && !Args->CheckParm("-allowdecoratecrossincludes"))
{
int includefile = fileSystem.GetFileContainer(fileSystem.CheckNumForAnyName(sc.String));
int includefile = fileSystem.GetFileContainer(fileSystem.CheckNumForFullName(sc.String, true));
if (includefile != 0)
{
I_FatalError("File %s is overriding core lump %s.",
fileSystem.GetContainerFullName(includefile), sc.String);
fileSystem.GetResourceFileFullName(includefile), sc.String);
}
}
FScanner newscanner;

12
src/sound/s_advsound.cpp
View file

@ -51,6 +51,8 @@
#include "s_music.h"
#include "i_music.h"
using namespace FileSys;
// MACROS ------------------------------------------------------------------
#define RANDOM 1
@ -414,7 +416,7 @@ DEFINE_ACTION_FUNCTION(DObject,S_GetLength)
FSoundID S_AddSound (const char *logicalname, const char *lumpname, FScanner *sc)
{
int lump = fileSystem.CheckNumForAnyName (lumpname, ns_sounds);
int lump = fileSystem.CheckNumForFullName (lumpname, true, ns_sounds);
return S_AddSound (logicalname, lump);
}
@ -480,7 +482,7 @@ FSoundID S_AddPlayerSound (const char *pclass, int gender, FSoundID refid, const
if (lumpname)
{
lump = fileSystem.CheckNumForAnyName (lumpname, ns_sounds);
lump = fileSystem.CheckNumForFullName (lumpname, true, ns_sounds);
}
return S_AddPlayerSound (pclass, gender, refid, lump);
@ -594,7 +596,7 @@ void S_ParseSndInfo (bool redefine)
CurrentPitchMask = 0;
S_AddSound ("{ no sound }", "DSEMPTY"); // Sound 0 is no sound at all
for (lump = 0; lump < fileSystem.GetFileCount(); ++lump)
for (lump = 0; lump < fileSystem.GetNumEntries(); ++lump)
{
switch (fileSystem.GetFileNamespace (lump))
{
@ -1058,7 +1060,7 @@ static void S_AddSNDINFO (int lump)
int file = fileSystem.GetFileContainer(lump);
int sndifile = fileSystem.GetFileContainer(sc.LumpNum);
if ( (file > sndifile) &&
!(sndifile <= fileSystem.GetBaseNum() && file <= fileSystem.GetBaseNum()) )
!(sndifile <= fileSystem.GetIwadNum() && file <= fileSystem.GetIwadNum()) )
{
sc.MustGetString();
continue;
@ -1069,7 +1071,7 @@ static void S_AddSNDINFO (int lump)
FName mapped = sc.String;
// only set the alias if the lump it maps to exists.
if (mapped == NAME_None || fileSystem.CheckNumForAnyName(sc.String, ns_music) >= 0)
if (mapped == NAME_None || fileSystem.CheckNumForFullName(sc.String, true, ns_music) >= 0)
{
MusicAliases[alias] = mapped;
}

8
src/sound/s_doomsound.cpp
View file

@ -185,8 +185,8 @@ static FString LookupMusic(const char* musicname, int& order)
static int FindMusic(const char* musicname)
{
int lumpnum = fileSystem.FindFile(musicname);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForName(musicname, ns_music);
int lumpnum = fileSystem.CheckNumForFullName(musicname);
if (lumpnum == -1) lumpnum = fileSystem.CheckNumForName(musicname, FileSys::ns_music);
return lumpnum;
}
@ -295,7 +295,7 @@ void S_Start()
if (LocalSndInfo.IsNotEmpty())
{
// Now parse the local SNDINFO
int j = fileSystem.CheckNumForAnyName(LocalSndInfo.GetChars());
int j = fileSystem.CheckNumForFullName(LocalSndInfo.GetChars(), true);
if (j >= 0) S_AddLocalSndInfo(j);
}
@ -309,7 +309,7 @@ void S_Start()
if (parse_ss)
{
S_ParseSndSeq(LocalSndSeq.IsNotEmpty() ? fileSystem.CheckNumForAnyName(LocalSndSeq.GetChars()) : -1);
S_ParseSndSeq(LocalSndSeq.IsNotEmpty() ? fileSystem.CheckNumForFullName(LocalSndSeq.GetChars(), true) : -1);
}
LastLocalSndInfo = LocalSndInfo;

4
src/wi_stuff.cpp
View file

@ -517,7 +517,7 @@ bool DInterBackground::LoadBackground(bool isenterpic)
{
try
{
int lumpnum = fileSystem.CheckNumForAnyName(lumpname);
int lumpnum = fileSystem.CheckNumForFullName(lumpname, true);
if (lumpnum == -1)
{
I_Error("Intermission animation lump %s not found!", lumpname);
@ -757,7 +757,7 @@ bool DInterBackground::LoadBackground(bool isenterpic)
}
else
{
int lumpnum = fileSystem.CheckNumForAnyName(lumpname + 1);
int lumpnum = fileSystem.CheckNumForFullName(lumpname + 1, true);
if (lumpnum >= 0)
{
FScanner sc(lumpnum);