diff --git a/src/doomdef.h b/src/doomdef.h
index 3b9eeb1938f5843fbaedd43f0d6254f11ce045fd..42ae03c3e11c2acbb2a61267c0c297241600b2ae 100644
--- a/src/doomdef.h
+++ b/src/doomdef.h
@@ -530,6 +530,22 @@ extern boolean capslock;
// i_system.c, replace getchar() once the keyboard has been appropriated
INT32 I_GetKey(void);
+/* http://www.cse.yorku.ca/~oz/hash.html */
+static inline
+UINT32 quickncasehash (const char *p, size_t n)
+{
+ size_t i = 0;
+ UINT32 x = 5381;
+
+ while (i < n && p[i])
+ {
+ x = (x * 33) ^ tolower(p[i]);
+ i++;
+ }
+
+ return x;
+}
+
#ifndef min // Double-Check with WATTCP-32's cdefs.h
#define min(x, y) (((x) < (y)) ? (x) : (y))
#endif
diff --git a/src/p_setup.c b/src/p_setup.c
index bdcb3b217f1651e3a3aa18af22d0368d39ad1a0c..a828a590e30d4f0669ce71000b4d5bff1765f3b3 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -4736,7 +4736,7 @@ static boolean P_LoadAddon(UINT16 wadnum, UINT16 numlumps)
// Reload it all anyway, just in case they
// added some textures but didn't insert a
// TEXTURES/etc. list.
- R_LoadTextures(); // numtexture changes
+ R_LoadTexturesPwad(wadnum); // numtexture changes
// Reload ANIMDEFS
P_InitPicAnims();
diff --git a/src/r_picformats.h b/src/r_picformats.h
index 573fb494628662c2d9eec7f634aee49dfecaf9b5..f3080479fc9c4555004173a6ac43cd7d0f3ef0b6 100644
--- a/src/r_picformats.h
+++ b/src/r_picformats.h
@@ -105,6 +105,7 @@ typedef struct
} spriteinfo_t;
// Portable Network Graphics
+#define PNG_HEADER_SIZE (8)
boolean Picture_IsLumpPNG(const UINT8 *d, size_t s);
#define Picture_ThrowPNGError(lumpname, wadfilename) I_Error("W_Wad: Lump \"%s\" in file \"%s\" is a .png - please convert to either Doom or Flat (raw) image format.", lumpname, wadfilename); // Fears Of LJ Sonic
diff --git a/src/r_textures.c b/src/r_textures.c
index ff5c49675cadcab464828e973a1ea7a8f7b63d77..03f8f53a50a9e80f7df130a425a1331801deb876 100644
--- a/src/r_textures.c
+++ b/src/r_textures.c
@@ -59,6 +59,7 @@ INT32 *texturetranslation;
// Painfully simple texture id cacheing to make maps load faster. :3
static struct {
char name[9];
+ UINT32 hash;
INT32 id;
} *tidcache = NULL;
static INT32 tidcachelen = 0;
@@ -725,6 +726,7 @@ Rloadflats (INT32 i, INT32 w)
UINT16 texstart, texend;
texture_t *texture;
texpatch_t *patch;
+ UINT8 header[PNG_HEADER_SIZE];
// Yes
if (W_FileHasFolders(wadfiles[w]))
@@ -743,7 +745,6 @@ Rloadflats (INT32 i, INT32 w)
// Work through each lump between the markers in the WAD.
for (j = 0; j < (texend - texstart); j++)
{
- UINT8 *flatlump;
UINT16 wadnum = (UINT16)w;
lumpnum_t lumpnum = texstart + j;
size_t lumplength;
@@ -755,7 +756,7 @@ Rloadflats (INT32 i, INT32 w)
continue; // If it is then SKIP IT
}
- flatlump = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
+ W_ReadLumpHeaderPwad(wadnum, lumpnum, header, sizeof header, 0);
lumplength = W_LumpLengthPwad(wadnum, lumpnum);
switch (lumplength)
@@ -788,14 +789,17 @@ Rloadflats (INT32 i, INT32 w)
// Set texture properties.
M_Memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
+ texture->hash = quickncasehash(texture->name, 8);
#ifndef NO_PNG_LUMPS
- if (Picture_IsLumpPNG((UINT8 *)flatlump, lumplength))
+ if (Picture_IsLumpPNG(header, lumplength))
{
+ UINT8 *flatlump = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
INT32 width, height;
Picture_PNGDimensions((UINT8 *)flatlump, &width, &height, NULL, NULL, lumplength);
texture->width = (INT16)width;
texture->height = (INT16)height;
+ Z_Free(flatlump);
}
else
#endif
@@ -814,8 +818,6 @@ Rloadflats (INT32 i, INT32 w)
patch->lump = texstart + j;
patch->flip = 0;
- Z_Unlock(flatlump);
-
texturewidth[i] = texture->width;
textureheight[i] = texture->height << FRACBITS;
i++;
@@ -835,8 +837,8 @@ Rloadtextures (INT32 i, INT32 w)
UINT16 j;
UINT16 texstart, texend, texturesLumpPos;
texture_t *texture;
- softwarepatch_t *patchlump;
texpatch_t *patch;
+ softwarepatch_t patchlump;
// Get the lump numbers for the markers in the WAD, if they exist.
if (W_FileHasFolders(wadfiles[w]))
@@ -876,7 +878,7 @@ Rloadtextures (INT32 i, INT32 w)
continue; // If it is then SKIP IT
}
- patchlump = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
+ W_ReadLumpHeaderPwad(wadnum, lumpnum, &patchlump, PNG_HEADER_SIZE, 0);
#ifndef NO_PNG_LUMPS
lumplength = W_LumpLengthPwad(wadnum, lumpnum);
#endif
@@ -886,20 +888,23 @@ Rloadtextures (INT32 i, INT32 w)
// Set texture properties.
M_Memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
+ texture->hash = quickncasehash(texture->name, 8);
#ifndef NO_PNG_LUMPS
- if (Picture_IsLumpPNG((UINT8 *)patchlump, lumplength))
+ if (Picture_IsLumpPNG((UINT8 *)&patchlump, lumplength))
{
+ UINT8 *png = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
INT32 width, height;
- Picture_PNGDimensions((UINT8 *)patchlump, &width, &height, NULL, NULL, lumplength);
+ Picture_PNGDimensions(png, &width, &height, NULL, NULL, lumplength);
texture->width = (INT16)width;
texture->height = (INT16)height;
+ Z_Free(png);
}
else
#endif
{
- texture->width = SHORT(patchlump->width);
- texture->height = SHORT(patchlump->height);
+ texture->width = SHORT(patchlump.width);
+ texture->height = SHORT(patchlump.height);
}
texture->type = TEXTURETYPE_SINGLEPATCH;
@@ -915,8 +920,6 @@ Rloadtextures (INT32 i, INT32 w)
patch->lump = texstart + j;
patch->flip = 0;
- Z_Unlock(patchlump);
-
texturewidth[i] = texture->width;
textureheight[i] = texture->height << FRACBITS;
i++;
@@ -926,28 +929,54 @@ Rloadtextures (INT32 i, INT32 w)
return i;
}
-//
-// R_LoadTextures
-// Initializes the texture list with the textures from the world map.
-//
-void R_LoadTextures(void)
+static INT32
+count_range
+( const char * marker_start,
+ const char * marker_end,
+ const char * folder,
+ UINT16 wadnum)
{
- INT32 i, w;
UINT16 j;
- UINT16 texstart, texend, texturesLumpPos;
+ UINT16 texstart, texend;
+ INT32 count = 0;
- // Free previous memory before numtextures change.
- if (numtextures)
+ // Count flats
+ if (W_FileHasFolders(wadfiles[wadnum]))
{
- for (i = 0; i < numtextures; i++)
+ texstart = W_CheckNumForFolderStartPK3(folder, wadnum, 0);
+ texend = W_CheckNumForFolderEndPK3(folder, wadnum, texstart);
+ }
+ else
+ {
+ texstart = W_CheckNumForMarkerStartPwad(marker_start, wadnum, 0);
+ texend = W_CheckNumForNamePwad(marker_end, wadnum, texstart);
+ }
+
+ if (texstart != INT16_MAX && texend != INT16_MAX)
+ {
+ // PK3s have subfolders, so we can't just make a simple sum
+ if (W_FileHasFolders(wadfiles[wadnum]))
{
- Z_Free(textures[i]);
- Z_Free(texturecache[i]);
+ for (j = texstart; j < texend; j++)
+ {
+ if (!W_IsLumpFolder(wadnum, j)) // Check if lump is a folder; if not, then count it
+ count++;
+ }
+ }
+ else // Add all the textures between markers
+ {
+ count += (texend - texstart);
}
- Z_Free(texturetranslation);
- Z_Free(textures);
}
+ return count;
+}
+
+static INT32 R_CountTextures(UINT16 wadnum)
+{
+ UINT16 texturesLumpPos;
+ INT32 count = 0;
+
// Load patches and textures.
// Get the number of textures to check.
@@ -955,106 +984,88 @@ void R_LoadTextures(void)
// the markers.
// This system will allocate memory for all duplicate/patched textures even if it never uses them,
// but the alternative is to spend a ton of time checking and re-checking all previous entries just to skip any potentially patched textures.
- for (w = 0, numtextures = 0; w < numwadfiles; w++)
- {
+
#ifdef WALLFLATS
- // Count flats
- if (W_FileHasFolders(wadfiles[w]))
- {
- texstart = W_CheckNumForFolderStartPK3("flats/", (UINT16)w, 0);
- texend = W_CheckNumForFolderEndPK3("flats/", (UINT16)w, texstart);
- }
- else
- {
- texstart = W_CheckNumForMarkerStartPwad("F_START", (UINT16)w, 0);
- texend = W_CheckNumForNamePwad("F_END", (UINT16)w, texstart);
- }
+ count += count_range("F_START", "F_END", "flats/", wadnum);
+#endif
- if (!( texstart == INT16_MAX || texend == INT16_MAX ))
- {
- // PK3s have subfolders, so we can't just make a simple sum
- if (W_FileHasFolders(wadfiles[w]))
- {
- for (j = texstart; j < texend; j++)
- {
- if (!W_IsLumpFolder((UINT16)w, j)) // Check if lump is a folder; if not, then count it
- numtextures++;
- }
- }
- else // Add all the textures between F_START and F_END
- {
- numtextures += (UINT32)(texend - texstart);
- }
- }
-#endif/*WALLFLATS*/
+ // Count the textures from TEXTURES lumps
+ texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", wadnum, 0);
- // Count the textures from TEXTURES lumps
- texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
- while (texturesLumpPos != INT16_MAX)
- {
- numtextures += R_CountTexturesInTEXTURESLump((UINT16)w, (UINT16)texturesLumpPos);
- texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, texturesLumpPos + 1);
- }
+ while (texturesLumpPos != INT16_MAX)
+ {
+ count += R_CountTexturesInTEXTURESLump(wadnum, texturesLumpPos);
+ texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", wadnum, texturesLumpPos + 1);
+ }
- // Count single-patch textures
- if (W_FileHasFolders(wadfiles[w]))
- {
- texstart = W_CheckNumForFolderStartPK3("textures/", (UINT16)w, 0);
- texend = W_CheckNumForFolderEndPK3("textures/", (UINT16)w, texstart);
- }
- else
- {
- texstart = W_CheckNumForMarkerStartPwad(TX_START, (UINT16)w, 0);
- texend = W_CheckNumForNamePwad(TX_END, (UINT16)w, 0);
- }
+ // Count single-patch textures
+ count += count_range(TX_START, TX_END, "textures/", wadnum);
- if (texstart == INT16_MAX || texend == INT16_MAX)
- continue;
+ return count;
+}
- // PK3s have subfolders, so we can't just make a simple sum
- if (W_FileHasFolders(wadfiles[w]))
- {
- for (j = texstart; j < texend; j++)
- {
- if (!W_IsLumpFolder((UINT16)w, j)) // Check if lump is a folder; if not, then count it
- numtextures++;
- }
- }
- else // Add all the textures between TX_START and TX_END
- {
- numtextures += (UINT32)(texend - texstart);
- }
- }
+static void
+recallocuser
+( void * user,
+ size_t old,
+ size_t new)
+{
+ char *p = Z_Realloc(*(void**)user,
+ new, PU_STATIC, user);
- // If no textures found by this point, bomb out
- if (!numtextures)
- I_Error("No textures detected in any WADs!\n");
+ if (new > old)
+ memset(&p[old], 0, (new - old));
+}
+
+static void R_AllocateTextures(INT32 add)
+{
+ const INT32 newtextures = (numtextures + add);
+ const size_t newsize = newtextures * sizeof (void*);
+ const size_t oldsize = numtextures * sizeof (void*);
+
+ INT32 i;
// Allocate memory and initialize to 0 for all the textures we are initialising.
- // There are actually 5 buffers allocated in one for convenience.
- textures = Z_Calloc((numtextures * sizeof(void *)) * 5, PU_STATIC, NULL);
+ recallocuser(&textures, oldsize, newsize);
// Allocate texture column offset table.
- texturecolumnofs = (void *)((UINT8 *)textures + (numtextures * sizeof(void *)));
+ recallocuser(&texturecolumnofs, oldsize, newsize);
// Allocate texture referencing cache.
- texturecache = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 2));
+ recallocuser(&texturecache, oldsize, newsize);
// Allocate texture width table.
- texturewidth = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 3));
+ recallocuser(&texturewidth, oldsize, newsize);
// Allocate texture height table.
- textureheight = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 4));
+ recallocuser(&textureheight, oldsize, newsize);
// Create translation table for global animation.
- texturetranslation = Z_Malloc((numtextures + 1) * sizeof(*texturetranslation), PU_STATIC, NULL);
+ Z_Realloc(texturetranslation, (newtextures + 1) * sizeof(*texturetranslation), PU_STATIC, &texturetranslation);
- for (i = 0; i < numtextures; i++)
- texturetranslation[i] = i;
+ for (i = 0; i < numtextures; ++i)
+ {
+ // R_FlushTextureCache relies on the user for
+ // Z_Free, texturecache has been reallocated so the
+ // user is now garbage memory.
+ Z_SetUser(texturecache[i],
+ (void**)&texturecache[i]);
+ }
- for (i = 0, w = 0; w < numwadfiles; w++)
+ while (i < newtextures)
{
+ texturetranslation[i] = i;
+ i++;
+ }
+}
+
+static INT32 R_DefineTextures(INT32 i, UINT16 w)
+{
#ifdef WALLFLATS
- i = Rloadflats(i, w);
+ i = Rloadflats(i, w);
#endif
- i = Rloadtextures(i, w);
- }
+ return Rloadtextures(i, w);
+}
+
+static void R_FinishLoadingTextures(INT32 add)
+{
+ numtextures += add;
#ifdef HWRENDER
if (rendermode == render_opengl)
@@ -1062,6 +1073,43 @@ void R_LoadTextures(void)
#endif
}
+//
+// R_LoadTextures
+// Initializes the texture list with the textures from the world map.
+//
+void R_LoadTextures(void)
+{
+ INT32 i, w;
+ INT32 newtextures = 0;
+
+ for (w = 0; w < numwadfiles; w++)
+ {
+ newtextures += R_CountTextures((UINT16)w);
+ }
+
+ // If no textures found by this point, bomb out
+ if (!newtextures)
+ I_Error("No textures detected in any WADs!\n");
+
+ R_AllocateTextures(newtextures);
+
+ for (i = 0, w = 0; w < numwadfiles; w++)
+ {
+ i = R_DefineTextures(i, w);
+ }
+
+ R_FinishLoadingTextures(newtextures);
+}
+
+void R_LoadTexturesPwad(UINT16 wadnum)
+{
+ INT32 newtextures = R_CountTextures(wadnum);
+
+ R_AllocateTextures(newtextures);
+ R_DefineTextures(numtextures, wadnum);
+ R_FinishLoadingTextures(newtextures);
+}
+
static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
{
char *texturesToken;
@@ -1368,6 +1416,7 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
// Allocate memory for a zero-patch texture. Obviously, we'll be adding patches momentarily.
resultTexture = (texture_t *)Z_Calloc(sizeof(texture_t),PU_STATIC,NULL);
M_Memcpy(resultTexture->name, newTextureName, 8);
+ resultTexture->hash = quickncasehash(newTextureName, 8);
resultTexture->width = newTextureWidth;
resultTexture->height = newTextureHeight;
resultTexture->type = TEXTURETYPE_COMPOSITE;
@@ -1594,19 +1643,22 @@ void R_ClearTextureNumCache(boolean btell)
INT32 R_CheckTextureNumForName(const char *name)
{
INT32 i;
+ UINT32 hash;
// "NoTexture" marker.
if (name[0] == '-')
return 0;
+ hash = quickncasehash(name, 8);
+
for (i = 0; i < tidcachelen; i++)
- if (!strncasecmp(tidcache[i].name, name, 8))
+ if (tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))
return tidcache[i].id;
// Need to parse the list backwards, so textures loaded more recently are used in lieu of ones loaded earlier
//for (i = 0; i < numtextures; i++) <- old
for (i = (numtextures - 1); i >= 0; i--) // <- new
- if (!strncasecmp(textures[i]->name, name, 8))
+ if (textures[i]->hash == hash && !strncasecmp(textures[i]->name, name, 8))
{
tidcachelen++;
Z_Realloc(tidcache, tidcachelen * sizeof(*tidcache), PU_STATIC, &tidcache);
@@ -1615,6 +1667,7 @@ INT32 R_CheckTextureNumForName(const char *name)
#ifndef ZDEBUG
CONS_Debug(DBG_SETUP, "texture #%s: %s\n", sizeu1(tidcachelen), tidcache[tidcachelen-1].name);
#endif
+ tidcache[tidcachelen-1].hash = hash;
tidcache[tidcachelen-1].id = i;
return i;
}
diff --git a/src/r_textures.h b/src/r_textures.h
index d9c2ab49b875ba9fca5629f5bf102f821a4c1a78..9aa11ad4d9da7fce8b85b961d24b1f2109d3429d 100644
--- a/src/r_textures.h
+++ b/src/r_textures.h
@@ -54,6 +54,7 @@ typedef struct
{
// Keep name for switch changing, etc.
char name[8];
+ UINT32 hash;
UINT8 type; // TEXTURETYPE_
INT16 width, height;
boolean holes;
@@ -76,6 +77,7 @@ extern UINT8 **texturecache; // graphics data for each generated full-size textu
// Load TEXTURES definitions, create lookup tables
void R_LoadTextures(void);
+void R_LoadTexturesPwad(UINT16 wadnum);
void R_FlushTextureCache(void);
// Texture generation
diff --git a/src/w_wad.c b/src/w_wad.c
index cf954a55ea3cebd9f46ad548ae23386a74f032c3..0a8f630a804b2ea2fda9e83b902adb3af66295d1 100644
--- a/src/w_wad.c
+++ b/src/w_wad.c
@@ -361,6 +361,7 @@ static lumpinfo_t* ResGetLumpsStandalone (FILE* handle, UINT16* numlumps, const
lumpinfo->size = ftell(handle);
fseek(handle, 0, SEEK_SET);
strcpy(lumpinfo->name, lumpname);
+ lumpinfo->hash = quickncasehash(lumpname, 8);
// Allocate the lump's long name.
lumpinfo->longname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
@@ -459,6 +460,7 @@ static lumpinfo_t* ResGetLumpsWad (FILE* handle, UINT16* nlmp, const char* filen
lump_p->compression = CM_NOCOMPRESSION;
memset(lump_p->name, 0x00, 9);
strncpy(lump_p->name, fileinfo->name, 8);
+ lump_p->hash = quickncasehash(lump_p->name, 8);
// Allocate the lump's long name.
lump_p->longname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
@@ -634,6 +636,7 @@ static lumpinfo_t* ResGetLumpsZip (FILE* handle, UINT16* nlmp)
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));
+ lump_p->hash = quickncasehash(lump_p->name, 8);
lump_p->longname = Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL);
strlcpy(lump_p->longname, trimname, dotpos - trimname + 1);
@@ -1225,12 +1228,14 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
{
UINT16 i;
static char uname[8 + 1];
+ UINT32 hash;
if (!TestValidLump(wad,0))
return INT16_MAX;
strlcpy(uname, name, sizeof uname);
strupr(uname);
+ hash = quickncasehash(uname, 8);
//
// scan forward
@@ -1241,7 +1246,7 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
{
lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
- if (!strncmp(lump_p->name, uname, sizeof(uname) - 1))
+ if (lump_p->hash == hash && !strncmp(lump_p->name, uname, sizeof(uname) - 1))
return i;
}
@@ -1444,15 +1449,20 @@ lumpnum_t W_CheckNumForLongName(const char *name)
// TODO: Make it search through cache first, maybe...?
lumpnum_t W_CheckNumForMap(const char *name)
{
+ UINT32 hash = quickncasehash(name, 8);
UINT16 lumpNum, end;
UINT32 i;
+ lumpinfo_t *p;
for (i = numwadfiles - 1; i < numwadfiles; i--)
{
if (wadfiles[i]->type == RET_WAD)
{
for (lumpNum = 0; lumpNum < wadfiles[i]->numlumps; lumpNum++)
- if (!strncmp(name, (wadfiles[i]->lumpinfo + lumpNum)->name, 8))
+ {
+ p = wadfiles[i]->lumpinfo + lumpNum;
+ if (p->hash == hash && !strncmp(name, p->name, 8))
return (i<<16) + lumpNum;
+ }
}
else if (W_FileHasFolders(wadfiles[i]))
{
@@ -1464,9 +1474,10 @@ lumpnum_t W_CheckNumForMap(const char *name)
// Now look for the specified map.
for (; lumpNum < end; lumpNum++)
{
- if (!strnicmp(name, wadfiles[i]->lumpinfo[lumpNum].name, 8))
+ p = wadfiles[i]->lumpinfo + lumpNum;
+ if (p->hash == hash && !strnicmp(name, p->name, 8))
{
- const char *extension = strrchr(wadfiles[i]->lumpinfo[lumpNum].fullname, '.');
+ const char *extension = strrchr(p->fullname, '.');
if (!(extension && stricmp(extension, ".wad")))
return (i<<16) + lumpNum;
}
diff --git a/src/w_wad.h b/src/w_wad.h
index f099b9fd2a243adcb2afd0c06fef3aab4e43d23d..c4de55d7774eef96e69470cc8b056d4124d52017 100644
--- a/src/w_wad.h
+++ b/src/w_wad.h
@@ -67,6 +67,7 @@ typedef struct
unsigned long position; // filelump_t filepos
unsigned long disksize; // filelump_t size
char name[9]; // filelump_t name[] e.g. "LongEntr"
+ UINT32 hash;
char *longname; // e.g. "LongEntryName"
char *fullname; // e.g. "Folder/Subfolder/LongEntryName.extension"
char *diskpath; // path to the file e.g. "/usr/games/srb2/Addon/Folder/Subfolder/LongEntryName.extension"