From a9cbaae799835b4f1f7f9744c048f7ef22ed7b7b Mon Sep 17 00:00:00 2001 From: NepDisk Date: Thu, 4 Dec 2025 15:08:20 -0500 Subject: [PATCH] w_wad: replace lumpnumcache with unordered_map hash lookup Holy shit, thanks Alug!!!! This is a major performance boost with a large amount of lumps loaded compared to the barely functional lumpnumcache that was there before. --- src/CMakeLists.txt | 2 +- src/{w_wad.c => w_wad.cpp} | 189 +++++++++++++++++-------------------- 2 files changed, 90 insertions(+), 101 deletions(-) rename src/{w_wad.c => w_wad.cpp} (93%) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index d865141e3..b74d30edf 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -94,7 +94,7 @@ add_executable(SRB2SDL2 MACOSX_BUNDLE WIN32 v_video.c s_sound.c sounds.c - w_wad.c + w_wad.cpp filesrch.c mserv.c http-mserv.c diff --git a/src/w_wad.c b/src/w_wad.cpp similarity index 93% rename from src/w_wad.c rename to src/w_wad.cpp index f46581f9e..2bd582ffa 100644 --- a/src/w_wad.c +++ b/src/w_wad.cpp @@ -87,18 +87,33 @@ typedef struct } lumpchecklist_t; // Must be a power of two -#define LUMPNUMCACHESIZE 64 +#define LUMPNUMCACHESIZE 2048 // should be reasonable ig #define LUMPNUMCACHENAME 32 -typedef struct lumpnum_cache_s -{ - char lumpname[32]; - UINT32 lumphash; - lumpnum_t lumpnum; -} lumpnum_cache_t; +#include +#include +#include + +struct LumpnumNameHash +{ + std::size_t operator()(const std::string& str) const + { + // hopefully this is fast enough but should be + return static_cast(HASH32(str.c_str(), str.length())); + } +}; + +struct LumpnumStringEquals +{ + bool operator()(const std::string& str1, const std::string& str2) const + { + // fasticmp should be plenty fast and ignores case + return fasticmp(str1.c_str(), str2.c_str()); + } +}; + +static std::unordered_map lumpnumcache(LUMPNUMCACHESIZE); -static lumpnum_cache_t lumpnumcache[LUMPNUMCACHESIZE]; -static UINT16 lumpnumcacheindex = 0; //=========================================================================== // GLOBALS @@ -258,7 +273,7 @@ static inline void W_LoadDehackedLumpsPK3(UINT16 wadnum, boolean mainfile) { lumpinfo_t *lump_p = &wadfiles[wadnum]->lumpinfo[posStart]; size_t length = strlen(wadfiles[wadnum]->filename) + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name - char *name = malloc(length + 1); + char *name = (char *)malloc(length + 1); if (!name) I_Error("W_LoadDehackedLumpsPK3: Out of memory!\n"); @@ -291,7 +306,7 @@ static inline void W_LoadDehackedLumps(UINT16 wadnum, boolean mainfile) if (memcmp(lump_p->name,"SOC_",4)==0) // Check for generic SOC lump { // shameless copy+paste of code from LUA_LoadLump size_t length = strlen(wadfiles[wadnum]->filename) + 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name - char *name = malloc(length + 1); + char *name = (char *)malloc(length + 1); if (!name) I_Error("W_LoadDehackedLumps: Out of memory!\n"); @@ -319,13 +334,13 @@ static inline void W_LoadDehackedLumps(UINT16 wadnum, boolean mainfile) static inline boolean CheckCompatFilename(const char *filename) { // check for a K prefix - char *basename = strrchr(filename, *PATHSEP); + char *basename = (char *)strrchr(filename, *PATHSEP); return (toupper(basename ? basename[1] : filename[0]) == 'K'); } static inline boolean CheckCompatExtension(const char *filename) { - char *basename = strrchr(filename, '.'); + char *basename = (char *)strrchr(filename, '.'); if (!stricmp(basename+1, "KART")) return true; @@ -435,7 +450,7 @@ boolean W_MakeFileHash(const char *filename, boolean openwad, UINT64 *ret) // Invalidates the cache of lump numbers. Call this whenever a wad is added. static void W_InvalidateLumpnumCache(void) { - memset(lumpnumcache, 0, sizeof (lumpnumcache)); + lumpnumcache.clear(); } UINT32 W_HashLumpName(const char *name, size_t len) @@ -465,7 +480,7 @@ static restype_t ResourceFileDetect (const char* filename) */ static lumpinfo_t* ResGetLumpsStandalone (FILE* handle, UINT16* numlumps, const char* lumpname) { - lumpinfo_t* lumpinfo = Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL); + lumpinfo_t* lumpinfo = (lumpinfo_t *)Z_Calloc(sizeof (*lumpinfo), PU_STATIC, NULL); lumpinfo->position = 0; fseek(handle, 0, SEEK_END); lumpinfo->size = ftell(handle); @@ -475,14 +490,14 @@ static lumpinfo_t* ResGetLumpsStandalone (FILE* handle, UINT16* numlumps, const lumpinfo->hash.name = W_HashLumpName(lumpname, lumpinfo->namelength); // Allocate the lump's long name. - lumpinfo->longname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL); + lumpinfo->longname = (char *)Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL); strcpy(lumpinfo->longname, lumpname); lumpinfo->longname[lumpinfo->namelength] = '\0'; lumpinfo->longnamelength = lumpinfo->namelength; lumpinfo->hash.longname = lumpinfo->hash.name; // Allocate the lump's full name. - lumpinfo->fullname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL); + lumpinfo->fullname = (char *)Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL); strcpy(lumpinfo->fullname, lumpname); lumpinfo->fullname[lumpinfo->namelength] = '\0'; lumpinfo->fullnamelength = lumpinfo->namelength; @@ -528,7 +543,7 @@ static lumpinfo_t* ResGetLumpsWad (FILE* handle, UINT16* nlmp, const char* filen // read wad file directory i = header.numlumps * sizeof (*fileinfo); - fileinfov = fileinfo = malloc(i); + fileinfov = fileinfo = (filelump_t *)malloc(i); if (fseek(handle, header.infotableofs, SEEK_SET) == -1 || fread(fileinfo, 1, i, handle) < i) { @@ -540,7 +555,7 @@ static lumpinfo_t* ResGetLumpsWad (FILE* handle, UINT16* nlmp, const char* filen numlumps = header.numlumps; // fill in lumpinfo for this wad - lump_p = lumpinfo = Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL); + lump_p = lumpinfo = (lumpinfo_t *)Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL); for (i = 0; i < numlumps; i++, lump_p++, fileinfo++) { lump_p->position = LONG(fileinfo->filepos); @@ -621,7 +636,7 @@ static lumpinfo_t* ResGetLumpsWad (FILE* handle, UINT16* nlmp, const char* filen namelen = strlen(trimname); // Allocate the lump's long and full name (save on memory). - lump_p->longname = lump_p->fullname = Z_Calloc(namelen * sizeof(char), PU_STATIC, NULL); + lump_p->longname = lump_p->fullname = (char *)Z_Calloc(namelen * sizeof(char), PU_STATIC, NULL); strncpy(lump_p->longname, trimname, namelen); lump_p->longname[namelen-1] = '\0'; @@ -629,14 +644,14 @@ static lumpinfo_t* ResGetLumpsWad (FILE* handle, UINT16* nlmp, const char* filen lump_p->hash.name = W_HashLumpName(lump_p->longname, lump_p->namelength); // Allocate the lump's long name. - lump_p->longname = Z_Malloc(namelen * sizeof(char), PU_STATIC, NULL); + lump_p->longname = (char *)Z_Malloc(namelen * sizeof(char), PU_STATIC, NULL); strncpy(lump_p->longname, fileinfo->name, 8); lump_p->longname[namelen-1] = '\0'; lump_p->longnamelength = lump_p->namelength; lump_p->hash.longname = lump_p->hash.name; // Allocate the lump's full name. - lump_p->fullname = Z_Malloc(namelen * sizeof(char), PU_STATIC, NULL); + lump_p->fullname =(char *) Z_Malloc(namelen * sizeof(char), PU_STATIC, NULL); strncpy(lump_p->fullname, fileinfo->name, 8); lump_p->fullname[namelen-1] = '\0'; lump_p->fullnamelength = lump_p->namelength; @@ -652,14 +667,14 @@ static lumpinfo_t* ResGetLumpsWad (FILE* handle, UINT16* nlmp, const char* filen lump_p->hash.name = W_HashLumpName(lump_p->name, lump_p->namelength); // Allocate the lump's long name. - lump_p->longname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL); + lump_p->longname = (char *)Z_Malloc(9 * sizeof(char), PU_STATIC, NULL); strncpy(lump_p->longname, fileinfo->name, 8); lump_p->longname[8] = '\0'; lump_p->longnamelength = lump_p->namelength; lump_p->hash.longname = lump_p->hash.name; // Allocate the lump's full name. - lump_p->fullname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL); + lump_p->fullname = (char *)Z_Malloc(9 * sizeof(char), PU_STATIC, NULL); strncpy(lump_p->fullname, fileinfo->name, 8); lump_p->fullname[8] = '\0'; lump_p->fullnamelength = lump_p->namelength; @@ -763,7 +778,7 @@ static lumpinfo_t* ResGetLumpsZip (FILE* handle, UINT16* nlmp) // Look for central directory end signature near end of file. // Contains entry number (number of lumps), and central directory start offset. fseek(handle, 0, SEEK_END); - if (!ResFindSignature(handle, pat_end, max(0, ftell(handle) - (22 + 65536)))) + if (!ResFindSignature(handle, pat_end, std::max(0, ftell(handle) - (22 + 65536)))) { CONS_Alert(CONS_ERROR, "Missing central directory\n"); return NULL; @@ -777,7 +792,7 @@ static lumpinfo_t* ResGetLumpsZip (FILE* handle, UINT16* nlmp) } numlumps = zend.entries; - lump_p = lumpinfo = Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL); + lump_p = lumpinfo = (lumpinfo_t *)Z_Malloc(numlumps * sizeof (*lumpinfo), PU_STATIC, NULL); fseek(handle, zend.cdiroffset, SEEK_SET); for (i = 0; i < numlumps; i++, lump_p++) @@ -803,7 +818,7 @@ static lumpinfo_t* ResGetLumpsZip (FILE* handle, UINT16* nlmp) lump_p->disksize = zentry.compsize; lump_p->size = zentry.size; - fullname = malloc(zentry.namelen + 1); + fullname = (char *)malloc(zentry.namelen + 1); if (fgets(fullname, zentry.namelen + 1, handle) != fullname) { CONS_Alert(CONS_ERROR, "Unable to read lumpname (%s)\n", M_FileError(handle)); @@ -822,16 +837,16 @@ static lumpinfo_t* ResGetLumpsZip (FILE* handle, UINT16* nlmp) dotpos = fullname + strlen(fullname); // Watch for files without extension. memset(lump_p->name, '\0', 9); // Making sure they're initialized to 0. Is it necessary? - strncpy(lump_p->name, trimname, min(8, dotpos - trimname)); + strncpy(lump_p->name, trimname, std::min(8, dotpos - trimname)); lump_p->namelength = strlen(lump_p->name); lump_p->hash.name = W_HashLumpName(lump_p->name, lump_p->namelength); - lump_p->longname = Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL); + lump_p->longname = (char *)Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL); strlcpy(lump_p->longname, trimname, dotpos - trimname + 1); lump_p->longnamelength = strlen(lump_p->longname); lump_p->hash.longname = W_HashLumpName(lump_p->longname, lump_p->longnamelength); - lump_p->fullname = Z_Calloc(zentry.namelen + 1, PU_STATIC, NULL); + lump_p->fullname = (char *)Z_Calloc(zentry.namelen + 1, PU_STATIC, NULL); strncpy(lump_p->fullname, fullname, zentry.namelen); lump_p->fullnamelength = zentry.namelen; lump_p->hash.fullname = W_HashLumpName(lump_p->fullname, lump_p->fullnamelength); @@ -1017,7 +1032,7 @@ UINT16 W_InitFile(const char *filename, boolean mainfile, boolean startup, boole // // link wad file to search files // - wadfile = Z_Malloc(sizeof (*wadfile), PU_STATIC, NULL); + wadfile = (wadfile_t *)Z_Malloc(sizeof (*wadfile), PU_STATIC, NULL); wadfile->filename = Z_StrDup(filename); wadfile->type = type; wadfile->handle = handle; @@ -1297,7 +1312,7 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump) continue; if (lump_p->hash.name != hash) continue; - if (strncasecmp(lump_p->name, name, strlen(name))) + if (strncasecmp(lump_p->name, name, sizeof(name) - 1)) continue; return i; } @@ -1418,7 +1433,6 @@ UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump) lumpnum_t W_CheckNumForName(const char *name) { INT32 i; - UINT32 hash = name ? quickncasehash(name, 8) : 0; lumpnum_t check = INT16_MAX; if (name == NULL) @@ -1429,16 +1443,9 @@ lumpnum_t W_CheckNumForName(const char *name) // Check the lumpnumcache first. Loop backwards so that we check // most recent entries first - for (i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--) - { - if (!lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname[8] - && lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumphash == hash - && strncasecmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name, 8) == 0) - { - lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1); - return lumpnumcache[lumpnumcacheindex].lumpnum; - } - } + auto it = lumpnumcache.find(name); + if (it != lumpnumcache.end()) + return it->second; // scan wad files backwards so patch lump files take precedence for (i = numwadfiles - 1; i >= 0; i--) @@ -1452,12 +1459,9 @@ lumpnum_t W_CheckNumForName(const char *name) else { // Update the cache. - lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1); - memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', 32); - strncpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 8); - lumpnumcache[lumpnumcacheindex].lumpnum = (i << 16) | check; - - return lumpnumcache[lumpnumcacheindex].lumpnum; + lumpnum_t lumpnum = (i << 16) | check; + lumpnumcache.insert({name, lumpnum}); + return lumpnum; } } @@ -1470,7 +1474,6 @@ lumpnum_t W_CheckNumForName(const char *name) lumpnum_t W_CheckNumForLongName(const char *name) { INT32 i; - UINT32 hash = name ? quickncasehash(name, 8) : 0; lumpnum_t check = INT16_MAX; if (name == NULL) @@ -1481,14 +1484,10 @@ lumpnum_t W_CheckNumForLongName(const char *name) // Check the lumpnumcache first. Loop backwards so that we check // most recent entries first - for (i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--) - { - if (strcasecmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name) == 0) - { - lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1); - return lumpnumcache[lumpnumcacheindex].lumpnum; - } - } + auto it = lumpnumcache.find(name); + if (it != lumpnumcache.end()) + return it->second; + // scan wad files backwards so patch lump files take precedence for (i = numwadfiles - 1; i >= 0; i--) @@ -1504,11 +1503,9 @@ lumpnum_t W_CheckNumForLongName(const char *name) if (strlen(name) < 32) { // Update the cache. - lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1); - memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', 32); - strlcpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 32); - lumpnumcache[lumpnumcacheindex].lumpnum = (i << 16) | check; - lumpnumcache[lumpnumcacheindex].lumphash = hash; + lumpnum_t lumpnum = (i << 16) | check; + lumpnumcache.insert({name, lumpnum}); + return lumpnum; } return (i << 16) | check; @@ -1520,21 +1517,15 @@ lumpnum_t W_CheckNumForLongName(const char *name) lumpnum_t W_CheckNumForMap(const char *name, boolean checktofirst) { lumpnum_t check = INT16_MAX; - UINT32 uhash, hash = quickncasehash(name, LUMPNUMCACHENAME); + UINT32 uhash; INT32 i; UINT16 firstfile = (checktofirst || (partadd_earliestfile == UINT16_MAX)) ? 0 : partadd_earliestfile; // Check the lumpnumcache first. Loop backwards so that we check // most recent entries first - for (i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--) - { - if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumphash == hash - && strcasecmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name) == 0) - { - lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1); - return lumpnumcache[lumpnumcacheindex].lumpnum; - } - } + auto it = lumpnumcache.find(name); + if (it != lumpnumcache.end()) + return it->second; uhash = W_HashLumpName(name, strlen(name)); // Not a mistake, legacy system for short lumpnames @@ -1555,11 +1546,9 @@ lumpnum_t W_CheckNumForMap(const char *name, boolean checktofirst) if (strlen(name) < LUMPNUMCACHENAME) { // Update the cache. - lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1); - memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', LUMPNUMCACHENAME); - strlcpy(lumpnumcache[lumpnumcacheindex].lumpname, name, LUMPNUMCACHENAME); - lumpnumcache[lumpnumcacheindex].lumpnum = (i << 16) | check; - lumpnumcache[lumpnumcacheindex].lumphash = hash; + lumpnum_t lumpnum = (i << 16) | check; + lumpnumcache.insert({name, lumpnum}); + return lumpnum; } return (i << 16) | check; @@ -1840,8 +1829,8 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si char *decData; // Lump's decompressed real data. size_t retval; // Helper var, lzf_decompress returns 0 when an error occurs. - rawData = Z_Malloc(l->disksize, PU_STATIC, NULL); - decData = Z_Malloc(l->size, PU_STATIC, NULL); + rawData = (char *)Z_Malloc(l->disksize, PU_STATIC, NULL); + decData = (char *)Z_Malloc(l->size, PU_STATIC, NULL); if (fread(rawData, 1, l->disksize, handle) < l->disksize) I_Error("wad %d, lump %d: cannot read compressed data", wad, lump); @@ -1889,8 +1878,8 @@ size_t W_ReadLumpHeaderPwad(UINT16 wad, UINT16 lump, void *dest, size_t size, si unsigned long rawSize = l->disksize; unsigned long decSize = size; - rawData = Z_Malloc(rawSize, PU_STATIC, NULL); - decData = dest; + rawData = (UINT8 *)Z_Malloc(rawSize, PU_STATIC, NULL); + decData = (UINT8 *)dest; if (fread(rawData, 1, rawSize, handle) < rawSize) I_Error("wad %d, lump %d: cannot read compressed data", wad, lump); @@ -2104,15 +2093,15 @@ static void *MakePatch(void *lumpdata, size_t size, INT32 tag, void *cache, bool #ifndef NO_PNG_LUMPS if (Picture_IsLumpPNG((UINT8 *)lumpdata, len)) - ptr = Picture_PNGConvert((UINT8 *)lumpdata, PICFMT_DOOMPATCH, NULL, NULL, NULL, NULL, len, &len, 0); + ptr = Picture_PNGConvert((UINT8 *)lumpdata, PICFMT_DOOMPATCH, NULL, NULL, NULL, NULL, len, &len, (pictureflags_t)0); #endif if (remap) - R_DoPaletteRemapPatch(ptr, len); + R_DoPaletteRemapPatch((softwarepatch_t *)ptr, len); dest = Z_Calloc(sizeof(patch_t), tag, cache); - Patch_Create(ptr, len, dest); + Patch_Create((softwarepatch_t *)ptr, len, dest); return dest; } @@ -2134,7 +2123,7 @@ void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag) // read the lump in full W_ReadLumpHeaderPwad(wad, lump, lumpdata, 0, 0); - if (!Picture_IsLumpPNG(lumpdata,len) && !Picture_CheckIfDoomPatch(lumpdata, len)) + if (!Picture_IsLumpPNG((UINT8 *)lumpdata, len) && !Picture_CheckIfDoomPatch((softwarepatch_t *)lumpdata, len)) return NULL; MakePatch(lumpdata, len, tag, &lumpcache[lump], wadfiles[wad]->compatmode); @@ -2158,7 +2147,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag) if (!TestValidLump(wad, lump)) return NULL; - patch = W_CacheSoftwarePatchNumPwad(wad, lump, tag); + patch = (patch_t *)W_CacheSoftwarePatchNumPwad(wad, lump, tag); if (!patch) return NULL; @@ -2246,7 +2235,7 @@ void *W_CachePatchNameRotated(const char *name, INT32 rotationangle, INT32 tag) { INT32 xpivot = 0, ypivot = 0; - ptr = W_CachePatchNum(num, PU_PATCH); + ptr = (patch_t *)W_CachePatchNum(num, PU_PATCH); // >y pivot centered // >x pivot not centered @@ -2409,7 +2398,7 @@ W_VerifyPK3 (FILE *fp, lumpchecklist_t *checklist, boolean status) fseek(fp, 0, SEEK_END); file_size = ftell(fp); - if (!ResFindSignature(fp, pat_end, max(0, ftell(fp) - (22 + 65536)))) + if (!ResFindSignature(fp, pat_end, std::max(0, ftell(fp) - (22 + 65536)))) return true; fseek(fp, -4, SEEK_CUR); @@ -2434,7 +2423,7 @@ W_VerifyPK3 (FILE *fp, lumpchecklist_t *checklist, boolean status) if (verified == true) { - fullname = malloc(zentry.namelen + 1); + fullname = (char *)malloc(zentry.namelen + 1); if (fgets(fullname, zentry.namelen + 1, fp) != fullname) return true; @@ -2450,7 +2439,7 @@ W_VerifyPK3 (FILE *fp, lumpchecklist_t *checklist, boolean status) dotpos = fullname + strlen(fullname); // Watch for files without extension. memset(lumpname, '\0', 9); // Making sure they're initialized to 0. Is it necessary? - strncpy(lumpname, trimname, min(8, dotpos - trimname)); + strncpy(lumpname, trimname,std::min(8, dotpos - trimname)); if (! W_VerifyName(lumpname, checklist, status)) verified = false; @@ -2640,11 +2629,11 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum) size_t *vsizecache; // Remember that we're assuming that the WAD will have a specific set of lumps in a specific order. - UINT8 *wadData = W_CacheLumpNum(lumpnum, PU_LEVEL); + UINT8 *wadData = (UINT8 *)W_CacheLumpNum(lumpnum, PU_LEVEL); filelump_t *fileinfo = (filelump_t *)(wadData + ((wadinfo_t *)wadData)->infotableofs); i = ((wadinfo_t *)wadData)->numlumps; - vsizecache = Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL); + vsizecache = (size_t *)Z_Malloc(sizeof(size_t)*i, PU_LEVEL, NULL); for (realentry = 0; realentry < i; realentry++) { @@ -2656,7 +2645,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum) numlumps++; } - vlumps = Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL); + vlumps = (virtlump_t *)Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL); // Build the lumps, skipping over empty entries. for (i = 0, realentry = 0; i < numlumps; realentry++) @@ -2667,7 +2656,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum) // Play it safe with the name in this case. memcpy(vlumps[i].name, (fileinfo + realentry)->name, 8); vlumps[i].name[8] = '\0'; - vlumps[i].data = Z_Malloc(vlumps[i].size, PU_LEVEL, NULL); // This is memory inefficient, sorry about that. + vlumps[i].data = (UINT8 *)Z_Malloc(vlumps[i].size, PU_LEVEL, NULL); // This is memory inefficient, sorry about that. memcpy(vlumps[i].data, wadData + (fileinfo + realentry)->filepos, vlumps[i].size); i++; } @@ -2685,7 +2674,7 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum) { const char *fullname = W_CheckFullNameForNum(lumpnum); const char *dirend = strrchr(fullname, '/'); - char *dirname = malloc(dirend - fullname + 2); + char *dirname = (char *)malloc(dirend - fullname + 2); strlcpy(dirname, fullname, dirend - fullname + 2); lastlump = W_CheckNumForFolderEndPK3(dirname, WADFILENUM(lumpnum), lumpnum); free(dirname); @@ -2699,16 +2688,16 @@ virtres_t* vres_GetMap(lumpnum_t lumpnum) } numlumps++; - vlumps = Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL); + vlumps = (virtlump_t *)Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL); for (i = 0; i < numlumps; i++, lumpnum++) { vlumps[i].size = W_LumpLength(lumpnum); memcpy(vlumps[i].name, W_CheckNameForNum(lumpnum), 8); vlumps[i].name[8] = '\0'; - vlumps[i].data = W_CacheLumpNum(lumpnum, PU_LEVEL); + vlumps[i].data = (UINT8 *)W_CacheLumpNum(lumpnum, PU_LEVEL); } } - vres = Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL); + vres = (virtres_t *)Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL); vres->vlumps = vlumps; vres->numlumps = numlumps; @@ -2778,7 +2767,7 @@ void *vres_GetPatch(virtlump_t *vlump, INT32 tag) if (!vlump) return NULL; - patch = MakePatch(vlump->data, vlump->size, tag, NULL, false); + patch = (patch_t *)MakePatch(vlump->data, vlump->size, tag, NULL, false); #ifdef HWRENDER // Software-only compile cache the data without conversion