Remove lua_udatalib, and use Lua_CreateFieldTable for mobj and player instead

Need to test this a little but in theory, udatalib doesn't really give
much benefits, and using fields table and enum is safer than messing
with offsetof

src/CMakeLists.txt

@@ -246,6 +246,8 @@ set(SRB2_CONFIG_ASAN OFF CACHE BOOL
 	"Compile with AddressSanitizer (libasan).")
 set(SRB2_CONFIG_UBSAN OFF CACHE BOOL
 	"Compile with UndefinedBehaviorSanitizer (libubsan).")
+set(SRB2_CONFIG_TSAN OFF CACHE BOOL
+	"Compile with ThreadSanitizer (libtsan).")
 
 set(SRB2_CONFIG_MUMBLE ON CACHE BOOL
 	"Enable Mumble support")
@@ -290,7 +292,6 @@ if(${SRB2_CONFIG_HAVE_BLUA})
 		lua_script.c
 		lua_skinlib.c
 		lua_thinkerlib.c
-		lua_udatalib.c
 		lua_glib.c
 	)
 	set(SRB2_LUA_HEADERS
@@ -300,7 +301,6 @@ if(${SRB2_CONFIG_HAVE_BLUA})
 		lua_profile.h
 		lua_libs.h
 		lua_script.h
-		lua_udatalib.h
 		lua_glib.h
 	)
 

src/Makefile

@@ -75,6 +75,7 @@
 # PROFILEMODE=1 - Enable performance profiling (gprof).
 # USEASAN=1 - Enable building with Address Sanitizer.
 # USEUBSAN=1 - Enable building with Undefined Behavior Sanitizer.
+# USETSAN=1 - Enable building with Thread Sanitizer.
 # NOLIBBACKTRACE=1 - Disable using Libbacktrace for crashlog traces.
 #
 # General flags for building:
@@ -261,23 +262,35 @@ debug_opts=-D_DEBUG
 else # build a normal optimized version
 debug_opts=-DNDEBUG
 opts+=-O3
-ifndef NOLTO
-# compile with LTO
-opts+=-flto=auto
-libs+=-flto=auto
-endif
 endif
 
 ifdef USEASAN
 # compile with asan
 opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common
 libs+=-fsanitize=address
+NOLTO=1
 endif
 
 ifdef USEUBSAN
 # compile with ubsan
 opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer
 libs+=-fsanitize=undefined
+NOLTO=1
+endif
+
+ifdef USETSAN
+# compile with tsan
+opts+=-O1 -fsanitize=thread -fno-omit-frame-pointer
+libs+=-fsanitize=thread
+NOLTO=1
+endif
+
+ifndef DEBUGMODE
+ifndef NOLTO
+# compile with LTO
+opts+=-flto=auto
+libs+=-flto=auto
+endif
 endif
 
 ifdef USEJEMALLOC

src/Sourcefile

@@ -97,6 +97,5 @@ lua_playerlib.c
 lua_script.c
 lua_skinlib.c
 lua_thinkerlib.c
-lua_udatalib.c
 lua_glib.c
 lua_profile.cpp

src/command.c

@@ -1739,6 +1739,7 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
 		// send the value of the variable
 		UINT8 buf[128];
 		UINT8 *p = buf;
+
 		if (!(server || (IsPlayerAdmin(consoleplayer))))
 		{
 			CONS_Alert(CONS_NOTICE, "Only the server or admin can change: %s %s\n", var->name, var->string);

src/d_clisrv.c

@@ -811,7 +811,7 @@ static void resynch_read_player(resynch_pak *rsp)
 	players[i].mo->scalespeed = (fixed_t)LONG(rsp->scalespeed);
 
 	// And finally, SET THE MOBJ SKIN damn it.
-	players[i].mo->skin = skins[players[i].skin];
+	players[i].mo->skin = &skins[players[i].skin];
 	players[i].mo->color = players[i].skincolor;
 
 	P_SetThingPosition(players[i].mo);
@@ -4128,7 +4128,7 @@ static void Got_KickCmd(const UINT8 **p, INT32 playernum)
 						if (!players[i].mo->skin)
 							CONS_Printf("Mobj skin: NULL!\n");
 						else
-							CONS_Printf("Mobj skin: %s\n", players[i].mo->skin->name);
+							CONS_Printf("Mobj skin: %s\n", ((skin_t *)players[i].mo->skin)->name);
 						CONS_Printf("Position: %d, %d, %d\n", players[i].mo->x, players[i].mo->y, players[i].mo->z);
 						if (!players[i].mo->state)
 							CONS_Printf("State: S_NULL\n");

src/d_netcmd.c

@@ -1174,14 +1174,14 @@ static void Skin_FindRealNameSkin(consvar_t *cvar)
 	for (i = 0; i < numskins; i++)
 	{
 		// Perfect match with some skin name, no need to find matching realname
-		if (strncasecmp(value, skins[i]->name, sizeof skins[i]->name) == 0)
+		if (strncasecmp(value, skins[i].name, sizeof skins[i].name) == 0)
 			return;
 
-		const char *match = strcasestr(skins[i]->realname, value);
+		const char *match = strcasestr(skins[i].realname, value);
 		if (match != NULL)
 		{
 			matches[nummatches] = i;
-			matches_pos[nummatches] = match - skins[i]->realname;
+			matches_pos[nummatches] = match - skins[i].realname;
 			++nummatches;
 		}
 	}
@@ -1189,7 +1189,7 @@ static void Skin_FindRealNameSkin(consvar_t *cvar)
 	if (nummatches == 1)
 	{
 		// Change the cvar to be the value of the name.
-		CV_StealthSet(cvar, skins[matches[0]]->name);
+		CV_StealthSet(cvar, skins[matches[0]].name);
 	}
 	else if (nummatches > 1)
 	{
@@ -1203,7 +1203,7 @@ static void Skin_FindRealNameSkin(consvar_t *cvar)
 
 		for (i = 0; i < nummatches; ++i)
 		{
-			const char *realname = skins[matches[i]]->realname;
+			const char *realname = skins[matches[i]].realname;
 
 			if (matches_pos[i] == 0)
 				start[0] = 0;
@@ -1218,7 +1218,7 @@ static void Skin_FindRealNameSkin(consvar_t *cvar)
 
 			end = realname + matches_pos[i] + query_length;
 
-			CONS_Printf("%s\x85%s\x80%s (%s)\n", start, match, end, skins[matches[i]]->name);
+			CONS_Printf("%s\x85%s\x80%s (%s)\n", start, match, end, skins[matches[i]].name);
 		}
 
 		CONS_Printf("\x86Try be more specific\n");
@@ -1553,13 +1553,13 @@ static void ForceAllSkins(INT32 forcedskin)
 		if (!dedicated) // But don't do this for dedicated servers, of course.
 		{
 			if (i == consoleplayer)
-				CV_StealthSet(&cv_skin, skins[forcedskin]->name);
+				CV_StealthSet(&cv_skin, skins[forcedskin].name);
 			else if (i == displayplayers[1])
-				CV_StealthSet(&cv_skin2, skins[forcedskin]->name);
+				CV_StealthSet(&cv_skin2, skins[forcedskin].name);
 			else if (i == displayplayers[2])
-				CV_StealthSet(&cv_skin3, skins[forcedskin]->name);
+				CV_StealthSet(&cv_skin3, skins[forcedskin].name);
 			else if (i == displayplayers[3])
-				CV_StealthSet(&cv_skin4, skins[forcedskin]->name);
+				CV_StealthSet(&cv_skin4, skins[forcedskin].name);
 		}
 	}
 }
@@ -1613,8 +1613,8 @@ static void SendNameAndColor(UINT8 splitplayer)
 	{
 		if (player->skincolor)
 			CV_StealthSetValue(playercolor, player->skincolor);
-		else if (skins[player->skin]->prefcolor)
-			CV_StealthSetValue(playercolor, skins[player->skin]->prefcolor);
+		else if (skins[player->skin].prefcolor)
+			CV_StealthSetValue(playercolor, skins[player->skin].prefcolor);
 		else
 			CV_StealthSet(playercolor, playercolor->defaultvalue);
 	}
@@ -1625,7 +1625,7 @@ static void SendNameAndColor(UINT8 splitplayer)
 
 	if (fastcmp(playername->string, player_names[pnum])
 		&& playercolor->value == player->skincolor
-		&& fastcmp(playerskin->string, skins[player->skin]->name))
+		&& fastcmp(playerskin->string, skins[player->skin].name))
 		return;
 
 	if (playerisbot)
@@ -1654,12 +1654,12 @@ static void SendNameAndColor(UINT8 splitplayer)
 		{
 			playerskin->value = foundskin;
 			SetPlayerSkin(pnum, playerskin->string);
-			CV_StealthSet(playerskin, skins[playerskin->value]->name);
+			CV_StealthSet(playerskin, skins[playerskin->value].name);
 		}
 		else
 		{
 			playerskin->value = player->skin;
-			CV_StealthSet(playerskin, skins[player->skin]->name);
+			CV_StealthSet(playerskin, skins[player->skin].name);
 			// will always be same as current
 			SetPlayerSkin(pnum, playerskin->string);
 		}
@@ -1684,7 +1684,7 @@ static void SendNameAndColor(UINT8 splitplayer)
 
 	// Don't change skin if the server doesn't want you to.
 	if (!CanChangeSkin(pnum))
-		CV_StealthSet(playerskin, skins[player->skin]->name);
+		CV_StealthSet(playerskin, skins[player->skin].name);
 
 	// check if player has the skin loaded (cv_skin may have
 	// the name of a skin that was available in the previous game)
@@ -1692,7 +1692,7 @@ static void SendNameAndColor(UINT8 splitplayer)
 	if (playerskin->value < 0)
 	{
 		INT32 skinnum = player->skin;
-		CV_StealthSet(playerskin, skins[skinnum]->name);
+		CV_StealthSet(playerskin, skins[skinnum].name);
 		playerskin->value = skinnum;
 	}
 
@@ -1780,13 +1780,13 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
 
 		// TODO: make cv_skin an array
 		if (playernum == consoleplayer)
-			CV_StealthSet(&cv_skin, skins[forcedskin]->name);
+			CV_StealthSet(&cv_skin, skins[forcedskin].name);
 		else if (playernum == displayplayers[1])
-			CV_StealthSet(&cv_skin2, skins[forcedskin]->name);
+			CV_StealthSet(&cv_skin2, skins[forcedskin].name);
 		else if (playernum == displayplayers[2])
-			CV_StealthSet(&cv_skin3, skins[forcedskin]->name);
+			CV_StealthSet(&cv_skin3, skins[forcedskin].name);
 		else if (playernum == displayplayers[3])
-			CV_StealthSet(&cv_skin4, skins[forcedskin]->name);
+			CV_StealthSet(&cv_skin4, skins[forcedskin].name);
 	}
 	else
 		SetPlayerSkinByNum(playernum, skin);
@@ -4356,10 +4356,10 @@ static void SetPrefcolor(int splitplayer)
 	consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
 	consvar_t *playercolor = colorvars[splitplayer];
 
-	if (skins[player->skin]->prefcolor)
+	if (skins[player->skin].prefcolor)
 	{
-		CV_SetValue(playercolor, skins[player->skin]->prefcolor);
-		CONS_Printf("Set color to %s%s\n", HU_SkinColorToConsoleColor(skins[player->skin]->prefcolor), KartColor_Names[skins[player->skin]->prefcolor]);
+		CV_SetValue(playercolor, skins[player->skin].prefcolor);
+		CONS_Printf("Set color to %s%s\n", HU_SkinColorToConsoleColor(skins[player->skin].prefcolor), KartColor_Names[skins[player->skin].prefcolor]);
 	}
 	else
 	{
@@ -5632,7 +5632,7 @@ static void Skin_OnChange(void)
 	if (!(cv_debug || devparm) && !(multiplayer || netgame) // In single player.
 		&& (gamestate != GS_WAITINGPLAYERS)) // allows command line -warp x +skin y
 	{
-		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin]->name);
+		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
 		return;
 	}
 
@@ -5641,7 +5641,7 @@ static void Skin_OnChange(void)
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
-		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin]->name);
+		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
 	}
 }
 
@@ -5662,7 +5662,7 @@ static void Skin2_OnChange(void)
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
-		CV_StealthSet(&cv_skin2, skins[players[displayplayers[1]].skin]->name);
+		CV_StealthSet(&cv_skin2, skins[players[displayplayers[1]].skin].name);
 	}
 }
 
@@ -5678,7 +5678,7 @@ static void Skin3_OnChange(void)
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
-		CV_StealthSet(&cv_skin3, skins[players[displayplayers[2]].skin]->name);
+		CV_StealthSet(&cv_skin3, skins[players[displayplayers[2]].skin].name);
 	}
 }
 
@@ -5694,7 +5694,7 @@ static void Skin4_OnChange(void)
 	else
 	{
 		CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
-		CV_StealthSet(&cv_skin4, skins[players[displayplayers[3]].skin]->name);
+		CV_StealthSet(&cv_skin4, skins[players[displayplayers[3]].skin].name);
 	}
 }
 
@@ -5737,7 +5737,7 @@ static void Command_ListSkins(void)
 	for (i = page * 10; i < numskins && i < (page + 1) * 10; i++)
 	{
 		int length;
-		skin_t *skin = skins[i];
+		skin_t *skin = &skins[i];
 
 		if ((length = strlen(skin->name)) > longest_name)
 			longest_name = length;
@@ -5745,7 +5745,7 @@ static void Command_ListSkins(void)
 
 	for (i = page * 10; i < numskins && i < (page + 1) * 10; i++)
 	{
-		skin_t *skin = skins[i];
+		skin_t *skin = &skins[i];
 
 		CONS_Printf(
 			"%s[%-*s]\x80 %s\n",
@@ -5775,7 +5775,7 @@ static void Command_SkinSearch(void)
 	{
 		for (s = 0; s < numskins; s++)
 		{
-			skin_t *skininput = skins[s];
+			skin_t *skininput = &skins[s];
 
 			if (strcasestr(skininput->realname, COM_Argv(i)))
 			{
@@ -5799,7 +5799,7 @@ static void Color_OnChange(void)
 
 	if (!(cv_debug || devparm) && !(multiplayer || netgame || modeattacking)) // In single player.
 	{
-		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin]->name);
+		CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
 		return;
 	}
 

src/dedicated/CMakeLists.txt

@@ -119,20 +119,25 @@ target_compile_definitions(SRB2SDL2 PRIVATE
 	-DHAVE_THREADS
 )
 
-if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE)
+if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE AND NOT SRB2_CONFIG_ASAN AND NOT SRB2_CONFIG_UBSAN AND NOT SRB2_CONFIG_TSAN)
 	set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
 endif()
 
 if(SRB2_CONFIG_ASAN)
-	target_compile_options(SRB2SDL2 PRIVATE -fsanitize=address)
+	target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=address -fno-omit-frame-pointer -fno-common)
 	target_link_options(SRB2SDL2 PRIVATE -fsanitize=address)
 endif()
 
 if(SRB2_CONFIG_UBSAN)
-	target_compile_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
+	target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=undefined -fno-omit-frame-pointer)
 	target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
 endif()
 
+if(SRB2_CONFIG_TSAN)
+	target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=thread -fno-omit-frame-pointer)
+	target_link_options(SRB2SDL2 PRIVATE -fsanitize=thread)
+endif()
+
 ## strip debug symbols into separate file when using gcc
 # if(CMAKE_COMPILER_IS_GNUCC)
 # 	if(${CMAKE_BUILD_TYPE} MATCHES Debug)

src/discord.c

@@ -474,6 +474,7 @@ void DRPC_UpdatePresence(void)
 	char charname[11+SKINNAMESIZE+1];
 
 	boolean joinSecretSet = false;
+	char *clientJoinSecret = NULL;
 
 	DiscordRichPresence discordPresence;
 	memset(&discordPresence, 0, sizeof(discordPresence));
@@ -530,7 +531,8 @@ void DRPC_UpdatePresence(void)
 			// Grab the host's IP for joining.
 			if ((join = DRPC_GetServerIP()) != NULL)
 			{
-				discordPresence.joinSecret = DRPC_XORIPString(join);
+				clientJoinSecret = DRPC_XORIPString(join);
+				discordPresence.joinSecret = clientJoinSecret;
 				joinSecretSet = true;
 			}
 		}
@@ -684,7 +686,7 @@ void DRPC_UpdatePresence(void)
 		// Character image
 		while (supportedSkins[checkSkin] != NULL)
 		{
-			if (fastcmp(skins[players[consoleplayer].skin]->name, supportedSkins[checkSkin]))
+			if (fastcmp(skins[players[consoleplayer].skin].name, supportedSkins[checkSkin]))
 			{
 				snprintf(charimg, 21, "char%s", supportedSkins[checkSkin]);
 				discordPresence.smallImageKey = charimg;
@@ -701,7 +703,7 @@ void DRPC_UpdatePresence(void)
 			discordPresence.smallImageKey = "charcustom";
 		}
 
-		snprintf(charname, 28, "Character: %s", skins[players[consoleplayer].skin]->realname);
+		snprintf(charname, 28, "Character: %s", skins[players[consoleplayer].skin].realname);
 		discordPresence.smallImageText = charname; // Character name
 	}
 
@@ -712,6 +714,7 @@ void DRPC_UpdatePresence(void)
 	}
 
 	Discord_UpdatePresence(&discordPresence);
+	free(clientJoinSecret);
 }
 
 #endif // HAVE_DISCORDRPC

src/f_finale.c

@@ -324,7 +324,7 @@ void F_IntroTicker(void)
 			// Need to use M_Random otherwise it always uses the same sound
 			INT32 rskin = M_RandomKey(numskins);
 			UINT8 rtaunt = M_RandomKey(2);
-			sfxenum_t rsound = skins[rskin]->soundsid[SKSKBST1+rtaunt];
+			sfxenum_t rsound = skins[rskin].soundsid[SKSKBST1+rtaunt];
 			S_StartSound(NULL, rsound);
 		}
 	}
@@ -1162,17 +1162,17 @@ void F_StartWaitingPlayers(void)
 	finalecount = 0;
 
 	randskin = M_RandomKey(numskins);
-	boolean waithires = skins[randskin]->flags && SF_HIRES;
+	boolean waithires = skins[randskin].flags && SF_HIRES;
 
 	Z_Free(waitcolormap);
-	waitcolormap = R_GetTranslationColormap(randskin, skins[randskin]->prefcolor, 0);
+	waitcolormap = R_GetTranslationColormap(randskin, skins[randskin].prefcolor, 0);
 
 	if (waithires)
-		waitscale = waitscale * FIXED_TO_FLOAT(skins[randskin]->highresscale); // need to set scale here cause im lazy
+		waitscale = waitscale * FIXED_TO_FLOAT(skins[randskin].highresscale); // need to set scale here cause im lazy
 
 	for (i = 0; i < 2; i++)
 	{
-		sprframe = &skins[randskin]->spritedef.spriteframes[(6+(i*3)) & FF_FRAMEMASK];
+		sprframe = &skins[randskin].spritedef.spriteframes[(6+(i*3)) & FF_FRAMEMASK];
 		driver[i] = W_CachePatchNum(sprframe->lumppat[1], PU_CACHE);
 	}
 }

src/g_demo.c

@@ -63,7 +63,6 @@
 
 // for replay dates
 #include <time.h>
-#include <locale.h>
 
 // menu demo things
 UINT32 demoDelayTime = 15*TICRATE;
@@ -203,7 +202,7 @@ static INT32 GetSkinNumClosestToStats(UINT8 kartspeed, UINT8 kartweight)
 
 	for (i = 0; i < numskins; i++)
 	{
-		stat_diff = abs(skins[i]->kartspeed - kartspeed) + abs(skins[i]->kartweight - kartweight);
+		stat_diff = abs(skins[i].kartspeed - kartspeed) + abs(skins[i].kartweight - kartweight);
 
 		if (stat_diff < closest_stats)
 		{
@@ -266,7 +265,7 @@ void G_ReadDemoExtraData(void)
 			kartspeed = READUINT8(demobuf.p);
 			kartweight = READUINT8(demobuf.p);
 
-			if (!fasticmp(skins[player->skin]->name, name))
+			if (!fasticmp(skins[player->skin].name, name))
 				FindClosestSkinForStats(p, kartspeed, kartweight);
 
 			player->kartspeed = kartspeed;
@@ -396,12 +395,12 @@ void G_WriteDemoExtraData(void)
 			{
 				// Skin
 				memset(name, 0, 16);
-				strncpy(name, skins[players[i].skin]->name, 16);
+				strncpy(name, skins[players[i].skin].name, 16);
 				memcpy(demobuf.p, name, 16);
 				demobuf.p += 16;
 
-				WRITEUINT8(demobuf.p, skins[players[i].skin]->kartspeed);
-				WRITEUINT8(demobuf.p, skins[players[i].skin]->kartweight);
+				WRITEUINT8(demobuf.p, skins[players[i].skin].kartspeed);
+				WRITEUINT8(demobuf.p, skins[players[i].skin].kartweight);
 			}
 
 			if (demo_extradata[i] & DXD_COLOR)
@@ -1807,7 +1806,7 @@ void G_BeginRecording(void)
 
 		// Skin
 		memset(name, 0, 16);
-		strncpy(name, skins[player->skin]->name, 16);
+		strncpy(name, skins[player->skin].name, 16);
 		memcpy(demobuf.p, name, 16);
 		demobuf.p += 16;
 
@@ -1821,8 +1820,8 @@ void G_BeginRecording(void)
 		WRITEUINT32(demobuf.p, player->score);
 
 		// Kart speed and weight
-		WRITEUINT8(demobuf.p, skins[player->skin]->kartspeed);
-		WRITEUINT8(demobuf.p, skins[player->skin]->kartweight);
+		WRITEUINT8(demobuf.p, skins[player->skin].kartspeed);
+		WRITEUINT8(demobuf.p, skins[player->skin].kartweight);
 	}
 
 	WRITEUINT8(demobuf.p, 0xFF); // Denote the end of the player listing
@@ -1878,7 +1877,7 @@ void G_WriteStanding(UINT8 ranking, char *name, INT32 skinnum, UINT8 color, UINT
 
 	// Skin
 	memset(temp, 0, 16);
-	strncpy(temp, skins[skinnum]->name, 16);
+	strncpy(temp, skins[skinnum].name, 16);
 	memcpy(demobuf.p, temp, 16);
 	demobuf.p += 16;
 
@@ -2351,7 +2350,7 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
 
 		for (i = 0; i < numskins; i++)
 		{
-			if (fasticmp(skins[i]->name, temp))
+			if (fasticmp(skins[i].name, temp))
 			{
 				pdemo->standings[count].skin = i;
 				break;
@@ -2387,7 +2386,9 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
 #if defined (_WIN32)
 // return the file creation time
 // useful for demos that were renamed
-static long G_GetCreationTime(char *filepath)
+// windows only, as file creation times are
+// very unreliable (or non existant depending on fs) on linux
+static time_t G_GetCreationTime(char *filepath)
 {
 	struct stat fileinfo;
 
@@ -2398,35 +2399,24 @@ static long G_GetCreationTime(char *filepath)
 }
 #endif
 
-static char *G_GetDemoDate(menudemo_t *pdemo)
+static char *G_GetDemoDate(menudemo_t *pdemo, const char *dateformat)
 {
 	char *endPos = NULL;
-	static char datetime[11];
+	char *datetime;
 	time_t file_time = 0;
-	const char *format = NULL;
-	struct tm *tm_buf = NULL;
+	struct tm tm_buf;
 	CLEANUP(pfree) char *filename = NULL;
 
 	// get le filepath
 	filename = strdup(pdemo->filepath);
 
 	if (!filename)
-	{
-#if defined (_WIN32)
-		// if we cant get a filename try just getting the file creation time
-		file_time = G_GetCreationTime(pdemo->filepath);
-		goto skipfilenametime;
-#else
 		return NULL;
-#endif
-	}
 
 	// get the actual filename Zzz...
 	nameonly(filename);
 
-	// the first 10 characters of a replay name usually is a unix timestamp
-
-	// not long enough to contain a valid timestamp
+	// the first 10 characters of a replay name is a unix timestamp
 	if (strlen(filename) < 10)
 	{
 #if defined (_WIN32)
@@ -2458,67 +2448,49 @@ static char *G_GetDemoDate(menudemo_t *pdemo)
 #endif
 	}
 
-#if defined (_WIN32)
-skipfilenametime:
-#endif
-
 	// then throw it into localtime to get an actual human readable format lmao
-	tm_buf = localtime(&file_time);
-
-	// cant believe we ended up in 1970
-	if (tm_buf == NULL || tm_buf->tm_year <= 110)
+#if defined(_WIN32)
+skipfilenametime:
+	if ((localtime_s(&tm_buf, &file_time) != 0) ||
+		(tm_buf.tm_year <= 110)) // cant believe we ended up in 1970
 	{
-#if defined (_WIN32)
 		// uh ohh, we got an invalid time
 		// try one more time getting the creation time
 		file_time = G_GetCreationTime(pdemo->filepath);
-		tm_buf = localtime(&file_time);
 
-		if (tm_buf == NULL || tm_buf->tm_year <= 110)
+		if ((localtime_s(&tm_buf, &file_time) != 0) ||
+			(tm_buf.tm_year <= 110))
 			return NULL;
-
-		goto gotcreationtime;
+	}
 #else
+	if ((localtime_r(&file_time, &tm_buf) == NULL) ||
+		(tm_buf.tm_year <= 110)) // cant believe we ended up in 1970
 		return NULL;
 #endif
-	}
 
-#if defined (_WIN32)
-gotcreationtime:
-#endif
+	datetime = malloc(sizeof(pdemo->date)); // mallocma balls
 
-	// US ppl are special (:
-	if (cv_demodateformat.value == 2)
-		format = "%m.%d.%Y";
-	else if (cv_demodateformat.value == 1)
-		format = "%d.%m.%Y";
-	else
-	{
-		const char *locale = setlocale(LC_TIME, NULL);
+	// no mallocma balls... :c
+	if (!datetime)
+		return NULL;
 
-		if (locale == NULL)
-			format = "%d.%m.%Y"; // fallback to non US format
-		else if (strstr(locale, "en_US"))
-			format = "%m.%d.%Y";
-		else
-			format = "%d.%m.%Y";
-	}
-
-	if (strftime(datetime, sizeof(datetime), format, tm_buf) == 0)
+	if (strftime(datetime, sizeof(pdemo->date), dateformat, &tm_buf) == 0)
 	{
+		free(datetime);
 		return NULL;
 	}
 
 	return datetime;
 }
 
-void G_LoadDemoTitle(menudemo_t *pdemo)
+void G_LoadDemoTitle(menudemo_t *pdemo, const char *dateformat)
 {
 	UINT8 infobuffer[96], *info_p;
 	UINT16 pdemoversion;
-	char *demodate = NULL;
 	size_t count;
 
+	memset(pdemo->date, 0, sizeof(pdemo->date));
+
 	FILE *handle = fopen(pdemo->filepath, "rb");
 
 	if (!handle)
@@ -2546,8 +2518,6 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
 
 	pdemoversion = READUINT16(info_p);
 
-	memset(pdemo->date, 0, sizeof(pdemo->date));
-
 	switch (pdemoversion)
 	{
 		case DEMOVERSION: // latest always supported
@@ -2555,13 +2525,12 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
 			memcpy(pdemo->title, info_p, 64);
 
 			// demo date
-			demodate = G_GetDemoDate(pdemo);
-
+			char *demodate = G_GetDemoDate(pdemo, dateformat);
 			if (demodate)
 			{
 				strlcpy(pdemo->date, demodate, sizeof(pdemo->date));
+				free(demodate);
 			}
-
 			break;
 #ifdef DEMO_COMPAT_100
 		case 0x0001:
@@ -3029,7 +2998,7 @@ void G_DoPlayDemo(char *defdemoname)
 		kartspeed[p] = READUINT8(demobuf.p);
 		kartweight[p] = READUINT8(demobuf.p);
 
-		if (!fasticmp(skins[players[p].skin]->name, skin))
+		if (!fasticmp(skins[players[p].skin].name, skin))
 			FindClosestSkinForStats(p, kartspeed[p], kartweight[p]);
 
 		// Look for the next player
@@ -3106,7 +3075,7 @@ void G_AddGhost(char *defdemoname)
 	CLEANUP(Z_Pfree) UINT8 *buffer = NULL;
 	mapthing_t *mthing;
 	UINT16 count, ghostversion;
-	skin_t *ghskin = skins[0];
+	skin_t *ghskin = &skins[0];
 	UINT8 kartspeed = UINT8_MAX, kartweight = UINT8_MAX;
 
 	name[16] = '\0';
@@ -3313,9 +3282,9 @@ void G_AddGhost(char *defdemoname)
 
 	for (i = 0; i < numskins; i++)
 	{
-		if (fasticmp(skins[i]->name, skin))
+		if (fasticmp(skins[i].name, skin))
 		{
-			ghskin = skins[i];
+			ghskin = &skins[i];
 			break;
 		}
 	}
@@ -3323,7 +3292,7 @@ void G_AddGhost(char *defdemoname)
 	if (i == numskins)
 	{
 		if (kartspeed != UINT8_MAX && kartweight != UINT8_MAX)
-			ghskin = skins[GetSkinNumClosestToStats(kartspeed, kartweight)];
+			ghskin = &skins[GetSkinNumClosestToStats(kartspeed, kartweight)];
 
 		CONS_Alert(CONS_NOTICE, M_GetText("Ghost %s: Invalid character. Falling back to %s.\n"), pdemoname, ghskin->name);
 	}

src/g_demo.h

@@ -98,7 +98,7 @@ void G_SetDemoTime(UINT32 ptime, UINT32 plap);
 UINT8 G_CmpDemoTime(char *oldname, char *newname);
 
 void G_LoadDemoInfo(menudemo_t *pdemo);
-void G_LoadDemoTitle(menudemo_t *pdemo); // For use in replay search feature
+void G_LoadDemoTitle(menudemo_t *pdemo, const char *dateformat); // For use in replay search feature
 void G_DeferedPlayDemo(const char *demo);
 
 typedef enum

src/g_game.c

@@ -3935,9 +3935,9 @@ void G_DeferedInitNew(boolean pencoremode, const char *mapname, INT32 pickedchar
 	}
 
 	if (!color && !modeattacking)
-		color = skins[pickedchar]->prefcolor;
+		color = skins[pickedchar].prefcolor;
 	SetPlayerSkinByNum(consoleplayer, pickedchar);
-	CV_StealthSet(&cv_skin, skins[pickedchar]->name);
+	CV_StealthSet(&cv_skin, skins[pickedchar].name);
 
 	if (color)
 		CV_StealthSetValue(&cv_playercolor, color);

src/hardware/hw_bsp.c

@@ -96,7 +96,7 @@ static void HWR_FreePoly(poly_t *poly)
 // divfrac = how far along partline vector is crossing pt
 static boolean fracdivline(fdivline_t *partline, polyvertex_t *v1, polyvertex_t *v2)
 {
-	double frac1, frac2;
+	double frac;
 	double num; // numerator
 	double den; // denominator
 	double v1x, v1y, v1dx, v1dy; // polygon side vector, v1->v2
@@ -122,24 +122,23 @@ static boolean fracdivline(fdivline_t *partline, polyvertex_t *v1, polyvertex_t
 	// first check the frac along the polygon segment,
 	// (do not accept hit with the extensions)
 	num = (v3x - v1x)*v3dy + (v1y - v3y)*v3dx;
-	frac1 = num / den;
+	frac = num / den;
 
 	// 0= cross at v1, 1.0= cross at v2
-	if (frac1 < 0.0 || frac1 > 1.0)  // double
+	if (frac < 0.0 || frac > 1.0)  // double
 		return false;  // not within the polygon side
 
 	// now get the frac along the BSP line
 	// which is useful to determine what is left, what is right
 	num = (v3x - v1x)*v1dy + (v1y - v3y)*v1dx;
-	frac2 = num / den;
 
-	partline->divfrac = frac2;  // how far along partline vector
+	partline->divfrac = num / den;  // how far along partline vector
 
 	// [WDJ] find the interception point along the segment.
 	// It should be slightly more accurate because it is always closer to the
 	// crossing point than arbitrary positions on the partition line.
-	partline->divpt.x = v1x + v1dx*frac1;
-	partline->divpt.y = v1y + v1dy*frac1;
+	partline->divpt.x = v1x + v1dx*frac;
+	partline->divpt.y = v1y + v1dy*frac;
 
 	return true;
 }
@@ -161,6 +160,71 @@ static boolean SameVertex(polyvertex_t *p1, polyvertex_t *p2)
 	return true;
 }
 
+// Adapted from function in prboom.
+// Point is to rightside of divline when result > 0,
+// but result is multiplied by length of divline.
+// Returns near 0, when point is on, or nearly on, the divline.
+static inline double point_rightside(fdivline_t *dl, polyvertex_t *v4)
+{
+	// Cross product of dl and vector dl->(x,y) to v4,
+	// is > 0 when v4 is to right side of divline.
+	// Viewed along divline from vertex, looking towards positive dx,dy.
+	// If divline is rotated until dy>0 and dx = 0, then true when rotated
+	// vertex position is to the right of the divline (v4->x > dl->x).
+	return ((((double)(v4->x) - (double)(dl->x)) * (double)(dl->dy))
+		 - (((double)(v4->y) - (double)(dl->y)) * (double)(dl->dx)));
+}
+
+// [WDJ] The front and back MUST match the BSP determination, else it will assign
+// this poly to the wrong sector.
+// May have 1 point on the line, and other points might be very close to the line.
+// Can only trust a test of a point that is NOT on the line.
+// Using a tstdist = 0.5f worked, but it might break on very small poly.
+// Avactor.wad had polys with d = 9.09, 5552, 1.64, 1011, 14252, 0.0136, 0.00634, 14655, 3,
+// -0.3044, 7, 1.53, etc..,
+// and one poly with d = -0.023 with the rest of the points d > 0.
+// One 14 point poly with divline len=8, had to test 9 points to find d = 36.
+// Typical: divline len=70 d=6828, divline len=1.0 d=35, divline len=1.414 d=5.
+// The result of point_rightside is proportional to the length of divline.
+// The divline length can be from 1.414 to 14000.
+static void UnsplitPoly(fdivline_t *dlnp, poly_t *poly,
+						poly_t **frontpoly, poly_t **backpoly)
+{
+	int32_t i;
+	double d;
+	const double tstd = hypot((double)dlnp->dx, (double)dlnp->dy) / 2.0;
+	double sumd = 0; // accumulated left or rightness.
+
+	for (i = 0; i < poly->numpts; i++)
+	{
+		// Look for a point that is obviously to the left or right.
+		d = point_rightside(dlnp, &poly->pts[i]);  // d > 0 is right
+		sumd += d;
+
+		if (d > tstd)
+			goto poly_rightside;
+
+		if (d < -tstd)
+			goto poly_leftside;
+	}
+
+	// Did not find an obvious left or right point, then
+	if (sumd < 0)
+		goto poly_leftside;
+
+poly_rightside:
+	// poly is to rightside of divline.
+	*frontpoly = poly;
+	*backpoly = NULL;
+	return;
+
+poly_leftside:
+	// poly is to leftside of divline.
+	*frontpoly = NULL;
+	*backpoly = poly;
+	return;
+}
+
 // split a _CONVEX_ polygon in two convex polygons
 // outputs:
 //   frontpoly : polygon on right side of bsp line
@@ -263,10 +327,7 @@ static void SplitPoly (fdivline_t *dlnp,        // splitting parametric line
 		// linedefs where each side point the same sector, that is:
 		// the deep water effect with the original Doom
 
-		//TODO: make sure front poly is to front of partition line?
-
-		*frontpoly = poly;
-		*backpoly  = NULL;
+		UnsplitPoly(dlnp, poly, frontpoly, backpoly);
 		return;
 	}
 
@@ -274,16 +335,14 @@ static void SplitPoly (fdivline_t *dlnp,        // splitting parametric line
 	if (pe < 0)
 	{
 		//I_Error("SplitPoly: only one point for split line (%d %d)", ps, pe);
-		*frontpoly = poly;
-		*backpoly  = NULL;
+		UnsplitPoly(dlnp, poly, frontpoly, backpoly);
 		return;
 	}
 
 	if (pe <= ps)
 	{
 		//I_Error("SplitPoly: invalid splitting line (%d %d)", ps, pe);
-		*frontpoly = poly;
-		*backpoly  = NULL;
+		UnsplitPoly(dlnp, poly, frontpoly, backpoly);
 		return;
 	}
 
@@ -388,6 +447,10 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly)
 	vertex_t *v1, *v2;
 	fdivline_t cutseg; // x, y, dx, dy as start of node_t struct
 
+	// empty poly? just save us some time then
+	if (poly->numpts <= 0)
+		return frontpoly;
+
 	// for each seg of the subsector
 	for (; segcount--; lseg++)
 	{
@@ -489,6 +552,23 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly)
 			// need 2 points
 			if (pe >= 0)
 			{
+				// Cuts that miss the polygon.
+				if (ps_frac < 0.0 && cutseg.divfrac < 0.0)
+					continue;
+
+				if (ps_frac > 1.0 && cutseg.divfrac > 1.0)
+					continue;
+#define FRAC_EP 0.01f
+				// Reject cuts that could make the polygon non-convex.
+
+				// Cannot make normal cut, ps_frac end is loose.
+				if ((ps_frac < (0.0 - FRAC_EP)) || (ps_frac > (1.0f + FRAC_EP)))
+					continue;
+
+				// Cannot make normal cut, cutseg.divfrac end is loose.
+				if ((cutseg.divfrac < (0.0 - FRAC_EP)) || (cutseg.divfrac > (1.0f + FRAC_EP)))
+					continue;
+#undef FRAC_EP
 				// generate FRONT poly
 				frontpoly = HWR_AllocPoly(poly_num_pts);
 
@@ -680,7 +760,11 @@ static void WalkBSPNode(INT32 bspnum, poly_t *poly, UINT16 *leafnode, fixed_t *b
 		memcpy(bbox, bsp->bbox[0], 4*sizeof (fixed_t));
 	}
 	else
-		I_Error("WalkBSPNode: no front poly?");
+	{
+		// [WDJ] Having no front poly is as likely as no back poly, since
+		// logic in Split Poly was changed to check poly direction.
+		// I_Error("HWR_WalkBSPNode: no front poly, bspnum= %d\n", bspnum);
+	}
 
 	// Recursively divide back space.
 	if (backpoly)

src/hardware/hw_cache.c

@@ -614,24 +614,12 @@ void HWR_FreeMapTextures(void)
 	gl_numtextures = 0;
 }
 
-#define NAME    flatcheck
-#define KEY_TY  UINT32
-#define HASH_FN vt_hash_integer
-#define CMPR_FN vt_cmpr_integer
-#include "../verstable.h"
-
 static void HWR_PrecacheLevelFlats(void)
 {
-	// lookup for flats that may´ve been already loaded
-	flatcheck flatpresent;
 	size_t i;
-#if 0
-	size_t j;
-#endif
 	INT32 k;
 
-	// this kinda messes up encore remapping behavior at times
-	// so just disable it for now ig
+	// FIXME: this needs to account for FOFs to properly work
 #ifdef GLENCORE
 	if (encoremap)
 	{
@@ -639,9 +627,6 @@ static void HWR_PrecacheLevelFlats(void)
 	}
 #endif
 
-	flatcheck_init(&flatpresent);
-	flatcheck_reserve(&flatpresent, numlevelflats);
-
 	// special case for encore
 #if 0
 #ifdef GLENCORE
@@ -650,6 +635,7 @@ static void HWR_PrecacheLevelFlats(void)
 		// go through all sectors to determine if it should be remapped for encore
 		for (i = 0; i < numsectors; i++)
 		{
+			size_t j;
 			sector_t *sec = &sectors[i];
 
 			// gotta check sector floor and ceiling
@@ -692,11 +678,7 @@ static void HWR_PrecacheLevelFlats(void)
 		{
 			const levelflat_t *levelflat = &levelflats[i];
 
-			if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum)))
-			{
-				HWR_GetFlat(levelflat->lumpnum, false);
-				flatcheck_insert(&flatpresent, levelflat->lumpnum);
-			}
+			HWR_GetFlat(levelflat->lumpnum, false);
 
 			if (levelflat->speed) // is it an animated flat ?
 			{
@@ -704,17 +686,11 @@ static void HWR_PrecacheLevelFlats(void)
 				for (k = 0; k < levelflat->numpics; k++)
 				{
 					lumpnum_t lump = levelflat->baselumpnum + k;
-					if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
-					{
-						HWR_GetFlat(lump, false);
-						flatcheck_insert(&flatpresent, lump);
-					}
+					HWR_GetFlat(lump, false);
 				}
 			}
 		}
 	}
-
-	flatcheck_cleanup(&flatpresent);
 }
 
 static void HWR_PrecacheLevelTextures(void)
@@ -738,7 +714,7 @@ static void HWR_PrecacheLevelTextures(void)
 	{
 		const line_t *line = &lines[i];
 #ifdef GLENCORE
-		const int noencoremap = ((encoremap && (line->flags & ML_TFERLINE)) ? 2 : 1);
+		const boolean noencoremap = (encoremap && (line->flags & ML_TFERLINE));
 #endif
 		// two sides
 		for (j = 0; j < 2; j++)
@@ -755,25 +731,27 @@ static void HWR_PrecacheLevelTextures(void)
 			{
 				const INT32 texnum = sidetex[f];
 
-				if (texnum < 0 || texnum >= (signed)gl_numtextures)
+				if (texnum <= 0 || (unsigned)texnum >= gl_numtextures)
 					continue;
 
-				if (texturepresent[texnum])
-					continue;
+				if (!(texturepresent[texnum] & 1))
+				{
+					texturepresent[texnum] |= 1;
+					HWR_GetTexture(texnum, false);
+				}
 #ifdef GLENCORE
-				texturepresent[texnum] = 1|noencoremap;
-#else
-				texturepresent[texnum] = 1;
-#endif
-				HWR_GetTexture(texnum, false);
-#ifdef GLENCORE
-				if (noencoremap & 2)
+				if (noencoremap
+					&& !(texturepresent[texnum] & 2))
+				{
+					texturepresent[texnum] |= 2;
 					HWR_GetTexture(texnum, true);
+				}
 #endif
 			}
 		}
 	}
 
+	// check for animated textures
 	for (anim = anims; anim < lastanim; anim++)
 	{
 		if (!anim->istexture)
@@ -792,6 +770,7 @@ static void HWR_PrecacheLevelTextures(void)
 			{
 				HWR_GetTexture(animtexnum, false);
 			}
+
 #ifdef GLENCORE
 			if (texpresent & 2)
 			{
@@ -913,7 +892,7 @@ GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean noencore)
 	GLMapTexture_t *gltex;
 	GLMipmap_t *glMipmap;
 
-	if (tex < 0 || tex >= (signed)gl_numtextures)
+	if (tex < 0 || (unsigned)tex >= gl_numtextures)
 	{
 #ifdef PARANOIA
 		I_Error("HWR_GetTexture: Invalid texture ID %d", tex);

src/hardware/hw_main.cpp

@@ -255,6 +255,7 @@ static void CV_screentextures_OnChange(void)
 #endif
 		intermissionbginit = false;
 	}
+
 	GL_SetSpecialState(HWD_SET_SCREEN_TEXTURES, cv_glscreentextures.value);
 	M_UpdateOGLMenu();
 }
@@ -263,12 +264,11 @@ static void CV_screentextures_OnChange(void)
 static void CV_glframebuffer_OnChange(void)
 {
 	ONLY_IF_GL_LOADED
-	if ((cv_glframebuffer.value != 0 && cv_glscreentextures.value != 2)
-	|| (!supportFBO && cv_glframebuffer.value != 0)) // screen FBO needs screen textures
-		CV_SetValue(&cv_glframebuffer, 0);
+	// screen FBO needs screen textures currently
+	if (cv_glframebuffer.value != 0 && ((cv_glscreentextures.value != 2) || !supportFBO))
+		CV_StealthSetValue(&cv_glframebuffer, 0); // dont recursively call this lul
 
-	I_DownSample();
-	RefreshOGLSDLSurface();
+	I_CheckDownSampleState(true);
 	M_UpdateOGLMenu();
 	intermissionbginit = false;
 }
@@ -610,7 +610,7 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 			fflatsize = 1024.0f;
 			flatflag = 1023;
 			break;
-		case 262144:// 512x512 lump
+		case 262144: // 512x512 lump
 			fflatsize = 512.0f;
 			flatflag = 511;
 			break;
@@ -721,7 +721,7 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 
 	HWR_ProcessPolygon(&Surf, planeVerts, nrPlaneVerts, PolyFlags, shader, false);
 
-	if (gl_maphashorizonlines && subsector && cv_glhorizonlines.value)
+	if (gl_maphashorizonlines && subsector && !FOFsector && cv_glhorizonlines.value)
 	{
 		// Horizon lines
 		FOutVector horizonpts[6];
@@ -742,7 +742,6 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
 
 			line_t* ld = line->linedef;
 
-			// this check sucks and is a hotspot lel
 			if (LIKELY(ld->special != HORIZONSPECIAL))
 				continue;
 
@@ -1240,46 +1239,44 @@ static inline boolean HWR_BlendMidtextureSurface(FSurfaceInfo *pSurf)
 
 	pSurf->PolyColor.s.alpha = 0xFF;
 
-	if (LIKELY(!gl_curline->polyseg))
-	{
-		// check if linedef alpha is within range
-		const boolean linealpha = (gl_linedef->alpha >= 0 && gl_linedef->alpha < FRACUNIT);
+	// check if linedef alpha is within range
+	const boolean linealpha = (gl_linedef->alpha >= 0 && gl_linedef->alpha < FRACUNIT);
 
-		// set alpha for transparent walls
-		switch (gl_linedef->special)
-		{
-			// Translucent linedef types
-			case 102:
-			case 121 ... 125:
-			case 141 ... 145:
-			case 174:
-			case 175:
-			case 192:
-			case 195:
-			case 221:
-			case 253:
-			case 256:
-				if (gl_linedef->blendmode && linealpha)
+	// set alpha for transparent walls
+	switch (gl_linedef->special)
+	{
+		// Translucent linedef types
+		case 102:
+		case 121 ... 125:
+		case 141 ... 145:
+		case 174:
+		case 175:
+		case 192:
+		case 195:
+		case 221:
+		case 253:
+		case 256:
+			if (gl_linedef->blendmode && linealpha)
+				blendmode = HWR_SurfaceBlend(gl_linedef->blendmode, R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
+			else
+				blendmode = PF_Translucent;
+			break;
+		default:
+			if (gl_linedef->blendmode)
+			{
+				if (linealpha)
 					blendmode = HWR_SurfaceBlend(gl_linedef->blendmode, R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
 				else
-					blendmode = PF_Translucent;
-				break;
-			default:
-				if (gl_linedef->blendmode)
-				{
-					if (linealpha)
-						blendmode = HWR_SurfaceBlend(gl_linedef->blendmode, R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
-					else
-						blendmode = HWR_GetBlendModeFlag(gl_linedef->blendmode);
-				}
-				else if (linealpha)
-					blendmode = HWR_TranstableToAlpha(R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
-				else
-					blendmode = PF_Masked;
-				break;
-		}
+					blendmode = HWR_GetBlendModeFlag(gl_linedef->blendmode);
+			}
+			else if (linealpha)
+				blendmode = HWR_TranstableToAlpha(R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
+			else
+				blendmode = PF_Masked;
+			break;
 	}
-	else if (gl_curline->polyseg->translucency > 0)
+
+	if (gl_curline->polyseg && gl_curline->polyseg->translucency > 0)
 	{
 		// Polyobject translucency is shared between all of its lines
 		if (gl_curline->polyseg->translucency >= NUMTRANSMAPS) // wall not drawn
@@ -1386,7 +1383,8 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 	// two sided line
 	if (gl_backsector)
 	{
-		INT32 gl_toptexture = 0, gl_bottomtexture = 0;
+		const INT32 gl_toptexture = R_GetTextureNum(gl_sidedef->toptexture);
+		const INT32 gl_bottomtexture = R_GetTextureNum(gl_sidedef->bottomtexture);
 
 		fixed_t texturevpeg;
 
@@ -1397,7 +1395,7 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 		if (!gl_curline->polyseg) // Don't do it for polyobjects
 		{
 			// Sky Ceilings
-			wallVerts[3].y = wallVerts[2].y = FLOATMAX;
+			wallVerts[2].y = wallVerts[3].y = FLOATMAX; // draw to top of map space
 
 			auto draw_sky_walls = []
 			(int vert1, int vert2, fixed_t world, fixed_t worldslope, auto& wwallVerts, auto& sSurf) FUNCINLINE
@@ -1407,6 +1405,9 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 				HWR_DrawSkyWall(wwallVerts, &sSurf);
 			};
 
+			// worldtop = front ceiling
+			// worldhigh = back ceiling
+
 			if (gl_frontsector->ceilingpic == skyflatnum)
 			{
 				if (gl_backsector->ceilingpic == skyflatnum)
@@ -1425,6 +1426,17 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 					worldtop = worldhigh;
 					worldtopslope = worldhighslope;
 				}
+				else if (!gl_toptexture &&
+						 (worldhigh <= worldtop && worldhighslope <= worldtopslope) && // Assuming ESLOPE is always on with my changes
+						 (worldhigh != worldtop || worldhighslope != worldtopslope))
+				{
+					// Only the frontsector is sky.
+					// If there's no upper texture, extend the sky wall
+					// down to the lower of the two ceilings.
+					fixed_t top = std::min(worldtop, worldhigh);
+					fixed_t topslope = std::min(worldtopslope, worldhighslope);
+					draw_sky_walls(0, 1, top, topslope, wallVerts, Surf);
+				}
 				else
 				{
 					// Only the frontsector is sky, just draw a skywall from the front ceiling
@@ -1437,8 +1449,11 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 				draw_sky_walls(0, 1, worldtop, worldtopslope, wallVerts, Surf);
 			}
 
+			// worldbottom = front floor
+			// worldlow = back floor
+
 			// Sky Floors
-			wallVerts[0].y = wallVerts[1].y = FLOATMIN;
+			wallVerts[0].y = wallVerts[1].y = FLOATMIN; // draw to bottom of map space
 
 			if (gl_frontsector->floorpic == skyflatnum)
 			{
@@ -1450,7 +1465,7 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 					if ((worldlow >= worldbottom && worldlowslope >= worldbottomslope)
 					&& (worldlow != worldbottom || worldlowslope != worldbottomslope)
 					// Removing the second line above will render more rarely visible skywalls. Example: Cave garden ceiling in Dark race
-					&& !(gl_sidedef->bottomtexture))
+					&& !(gl_bottomtexture))
 					{
 						draw_sky_walls(3, 2, worldlow, worldlowslope, wallVerts, Surf);
 					}
@@ -1461,15 +1476,25 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 					draw_sky_walls(3, 2, worldbottom, worldbottomslope, wallVerts, Surf);
 				}
 			}
-			else if ((gl_backsector->floorpic == skyflatnum) && !(gl_sidedef->bottomtexture))
+			else if ((gl_backsector->floorpic == skyflatnum) && !(gl_bottomtexture))
 			{
 				// Only the backsector has sky, just draw a skywall from the back floor if there's no bottomtexture
 				draw_sky_walls(3, 2, worldlow, worldlowslope, wallVerts, Surf);
 			}
+			else if (gl_frontsector->ceilingpic == skyflatnum &&
+					 gl_backsector->ceilingpic == skyflatnum &&
+					 (worldlow >= worldbottom && worldlowslope >= worldbottomslope)
+					 && (worldlow != worldbottom || worldlowslope != worldbottomslope)
+					 // Removing the second line above will render more rarely visible skywalls. Example: Cave garden ceiling in Dark race
+					 && !(gl_bottomtexture))
+			{
+				// Both ceilings are sky, but neither floor is sky.
+				// If there's a lower wall gap without a bottom texture,
+				// draw a skywall from the backsector's higher floor.
+				draw_sky_walls(3, 2, worldlow, worldlowslope, wallVerts, Surf);
+			}
 		}
 
-		gl_toptexture = R_GetTextureNum(gl_sidedef->toptexture);
-
 		// check TOP TEXTURE
 		if (gl_toptexture && (worldhighslope < worldtopslope || worldhigh < worldtop))
 		{
@@ -1533,8 +1558,6 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
 				HWR_ProjectWall(wallVerts, &Surf, PF_Masked, lightnum, colormap);
 		}
 
-		gl_bottomtexture = R_GetTextureNum(gl_sidedef->bottomtexture);
-
 		// check BOTTOM TEXTURE
 		if (gl_bottomtexture && (worldlowslope > worldbottomslope || worldlow > worldbottom))
 		{
@@ -2962,7 +2985,7 @@ static void HWR_Subsector(size_t num)
 					}
 					else
 					{
-						HWR_GetFlat(flatlump, R_NoEncore(gl_frontsector, !bottom));
+						HWR_GetFlat(flatlump, R_NoEncore(rover->master->frontsector, bottom));
 						light = R_GetPlaneLight(gl_frontsector, centerHeight, underside);
 
 						HWR_RenderPlane(sub, &extrasubsectors[num], !bottom, roverheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, flatlump,
@@ -3296,7 +3319,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
 	// technically this_scale gets multiplied and added to sprite y/x scale, but this thing needs it for some crap so ill just throw it in here again
 	this_scale = FixedToFloat(spr->mobj->scale);
 
-	const skin_t *moskin = R_GetMobjSkin(spr->mobj);
+	const skin_t *moskin = K_GetMobjSkin(spr->mobj);
 	if (moskin && moskin->flags & SF_HIRES)
 		this_scale *= FixedToFloat(moskin->highresscale);
 
@@ -3460,8 +3483,12 @@ static inline void HWR_ApplyDispoffset(gl_vissprite_t *spr, FOutVector *wallVert
 {
 	HWR_RotateSpritePolyToAim(spr, wallVerts, false, papersprite);
 
-	const float sprdist = sqrtf((spr->x1 - gl_viewx)*(spr->x1 - gl_viewx) + (spr->z1 - gl_viewy)*(spr->z1 - gl_viewy) + (spr->gzt - gl_viewz)*(spr->gzt - gl_viewz));
-	const float distfact = ((2.0f*spr->dispoffset) + 20.0f) / sprdist;
+	const float f_xdiff = (spr->x1 - gl_viewx);
+	const float f_ydiff = (spr->z1 - gl_viewy);
+	const float f_zdiff = (spr->gzt - gl_viewz);
+
+	const float sprdist = sqrtf((f_xdiff*f_xdiff) + (f_ydiff*f_ydiff) + (f_zdiff*f_zdiff));
+	const float distfact = ((2.0f * spr->dispoffset) + 20.0f) / sprdist;
 
 	for (size_t i = 0; i < 4; i++)
 	{
@@ -4287,7 +4314,10 @@ static void HWR_RenderDrawNodes(void)
 					gl_frontsector = NULL;
 
 					if (!(plane->blend & PF_NoTexture))
-						HWR_GetFlat(plane->lumpnum, R_NoEncore(plane->FOFSector, plane->isceiling));
+					{
+						const boolean ceiling = plane->FOFSector ? !plane->isceiling : plane->isceiling; // match software!
+						HWR_GetFlat(plane->lumpnum, R_NoEncore(plane->FOFSector, ceiling));
+					}
 
 					HWR_RenderPlane(NULL, plane->xsub, plane->isceiling, plane->fixedheight, plane->blend, plane->lightlevel,
 									plane->lumpnum, plane->FOFSector, plane->alpha, plane->planecolormap);
@@ -4361,8 +4391,17 @@ static void HWR_DrawSprites(void)
 			{
 				if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
 				{
-					/* fuck you */
-					md2_t *md2 = &R_GetMobjSkin(spr->mobj)->playermodel;
+					md2_t *md2;
+
+					if (spr->mobj->localskin)
+					{
+						if (spr->mobj->skinlocal)
+							md2 = &md2_localplayermodels[(skin_t *)spr->mobj->localskin - localskins];
+						else
+							md2 = &md2_playermodels     [(skin_t *)spr->mobj->localskin -      skins];
+					}
+					else
+						md2 = &md2_playermodels[(skin_t *)spr->mobj->skin - skins];
 
 					// 8/1/19: Only don't display player models if no default SPR_PLAY is found.
 					if (((md2->notfound || md2->scale < 0.0f) && ((!cv_glfallbackplayermodel.value) || md2_models[SPR_PLAY].notfound || md2_models[SPR_PLAY].scale < 0.0f)) || spr->mobj->state == &states[S_PLAY_SIGN])
@@ -4584,7 +4623,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
 
 	rot = (thing->frame & FF_FRAMEMASK);
 
-	sprskin = R_GetMobjSkin(thing);
+	sprskin = K_GetMobjSkin(thing);
 
 	//Fab : 02-08-98: 'skin' override spritedef currently used for skin
 	if (sprskin && thing->sprite == SPR_PLAY)
@@ -5860,7 +5899,7 @@ void HWR_Startup(void)
 		HWR_TogglePaletteRendering();
 
 		if (msaa)
-			GL_SetSpecialState(HWD_SET_MSAA, a2c ? 2 : 1);
+			GL_SetSpecialState(HWD_SET_MSAA, 1);
 
 		HWR_RegisterCommands();
 	}
@@ -5948,7 +5987,7 @@ void HWR_Shutdown(void)
 	GL_FlushScreenTextures();
 	HWR_ClearAllTextures();
 #ifdef USE_FBO_OGL
-	GL_Framebuffer_Disable();
+	GL_FBO_Disable();
 #endif
 }
 

src/hardware/hw_main.h

@@ -43,7 +43,6 @@ void HWR_Startup(void);
 void HWR_Shutdown(void);
 
 extern unsigned msaa;
-extern boolean a2c;
 
 extern FTransform atransform;
 extern float gl_viewsin, gl_viewcos;

src/hardware/hw_md2.c

@@ -73,6 +73,8 @@
 #endif
 
 md2_t md2_models[NUMSPRITES] = {};
+md2_t md2_playermodels[MAXSKINS] = {};
+md2_t md2_localplayermodels[MAXLOCALSKINS] = {};
 
 /*
  * free model
@@ -419,7 +421,6 @@ static void md2_loadTexture(md2_t *model)
 			}
 		}
 	}
-
 	GL_SetTexture(glPatch->mipmap);
 	HWR_UnlockCachedPatch(glPatch);
 }
@@ -477,7 +478,6 @@ static void md2_loadBlendTexture(md2_t *model)
 		glPatch->mipmap->width = (UINT16)w;
 		glPatch->mipmap->height = (UINT16)h;
 	}
-
 	GL_SetTexture(glPatch->mipmap); // We do need to do this so that it can be cleared and knows to recreate it when necessary
 	HWR_UnlockCachedPatch(glPatch);
 
@@ -487,19 +487,6 @@ static void md2_loadBlendTexture(md2_t *model)
 // Don't spam the console, or the OS with fopen requests!
 static boolean nomd2s = false;
 
-// initializes an md2 model
-static void HWR_InitModel(md2_t *md2)
-{
-	md2->scale = -1.0f;
-	md2->model = NULL;
-	md2->glpatch = NULL;
-	md2->skinnum = -1;
-	md2->notexturefile = false;
-	md2->noblendfile = false;
-	md2->notfound = true;
-	md2->error = false;
-}
-
 void HWR_InitMD2(void)
 {
 	size_t i;
@@ -509,22 +496,38 @@ void HWR_InitMD2(void)
 	float scale, offset;
 
 	CONS_Printf("InitMD2()...\n");
-
-	for (s = 0; s < numskins; s++)
+	for (s = 0; s < MAXSKINS; s++)
 	{
-		skin_t *skin = skins[s];
-		HWR_InitModel(&skin->playermodel);
+		md2_playermodels[s].scale = -1.0f;
+		md2_playermodels[s].model = NULL;
+		md2_playermodels[s].glpatch = NULL;
+		md2_playermodels[s].skin = -1;
+		md2_playermodels[s].notexturefile = false;
+		md2_playermodels[s].noblendfile = false;
+		md2_playermodels[s].notfound = true;
+		md2_playermodels[s].error = false;
 	}
-
-	for (s = 0; s < numlocalskins; s++)
+	for (s = 0; s < MAXLOCALSKINS; s++)
 	{
-		skin_t *skin = localskins[s];
-		HWR_InitModel(&skin->playermodel);
+		md2_localplayermodels[s].scale = -1.0f;
+		md2_localplayermodels[s].model = NULL;
+		md2_localplayermodels[s].glpatch = NULL;
+		md2_localplayermodels[s].skin = -1;
+		md2_localplayermodels[s].notexturefile = false;
+		md2_localplayermodels[s].noblendfile = false;
+		md2_localplayermodels[s].notfound = true;
+		md2_localplayermodels[s].error = false;
 	}
-
 	for (i = 0; i < NUMSPRITES; i++)
 	{
-		HWR_InitModel(&md2_models[i]);
+		md2_models[i].scale = -1.0f;
+		md2_models[i].model = NULL;
+		md2_models[i].glpatch = NULL;
+		md2_models[i].skin = -1;
+		md2_models[s].notexturefile = false;
+		md2_models[s].noblendfile = false;
+		md2_models[i].notfound = true;
+		md2_models[i].error = false;
 	}
 
 	// read the mdls.dat file
@@ -541,7 +544,6 @@ void HWR_InitMD2(void)
 			return;
 		}
 	}
-
 	while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
 	{
 		for (i = 0; i < NUMSPRITES; i++)
@@ -556,21 +558,18 @@ void HWR_InitMD2(void)
 			}
 		}
 
-		for (s = 0; s < numskins; s++)
+		for (s = 0; s < MAXSKINS; s++)
 		{
-			skin_t *skin = skins[s];
-
-			if (fasticmp(name, skin->name))
+			if (fasticmp(name, skins[s].name))
 			{
-				skin->playermodel.skinnum = s;
-				skin->playermodel.scale = scale;
-				skin->playermodel.offset = offset;
-				skin->playermodel.notfound = false;
-				strcpy(skin->playermodel.filename, filename);
+				md2_playermodels[s].skin = s;
+				md2_playermodels[s].scale = scale;
+				md2_playermodels[s].offset = offset;
+				md2_playermodels[s].notfound = false;
+				strcpy(md2_playermodels[s].filename, filename);
 				goto md2found;
 			}
 		}
-
 		// no sprite/player skin name found?!?D
 		CONS_Printf("Unknown sprite/player skin %s detected in mdls.dat\n", name);
 md2found:
@@ -580,16 +579,12 @@ md2found:
 	fclose(f);
 }
 
-void HWR_AddPlayerMD2(INT32 skinnum, boolean local) // For MD2's that were added after startup
+void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added after startup
 {
 	FILE *f;
 	char name[20], filename[32];
 	float scale, offset;
-
-	skin_t *skin = R_GetSkinArray(local)[skinnum];
-
-	// ensure we ALWAYS initialize the model even if no mdls.dat was found!
-	HWR_InitModel(&skin->playermodel);
+	md2_t *md2s;
 
 	if (nomd2s)
 		return;
@@ -603,7 +598,6 @@ void HWR_AddPlayerMD2(INT32 skinnum, boolean local) // For MD2's that were added
 	if (!f)
 	{
 		f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
-
 		if (!f)
 		{
 			CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
@@ -612,25 +606,25 @@ void HWR_AddPlayerMD2(INT32 skinnum, boolean local) // For MD2's that were added
 		}
 	}
 
+	md2s = (local ? md2_localplayermodels : md2_playermodels);
+
 	// Check for any MD2s that match the names of player skins!
 	while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
 	{
-		if (fasticmp(name, skin->name))
+		if (fasticmp(name, K_GetSkinArray(local)[skin].name))
 		{
-			skin->playermodel.skinnum = skinnum;
-			skin->playermodel.scale = scale;
-			skin->playermodel.offset = offset;
-			skin->playermodel.notfound = false;
-			strcpy(skin->playermodel.filename, filename);
+			md2s[skin].skin = skin;
+			md2s[skin].scale = scale;
+			md2s[skin].offset = offset;
+			md2s[skin].notfound = false;
+			strcpy(md2s[skin].filename, filename);
 			goto playermd2found;
 		}
 	}
 
-	//CONS_Printf("MD2 for player skin %s not found\n", skins[skinnum].name);
-	skin->playermodel.notfound = true;
-
+	//CONS_Printf("MD2 for player skin %s not found\n", skins[skin].name);
+	md2s[skin].notfound = true;
 playermd2found:
-
 	fclose(f);
 }
 
@@ -680,7 +674,6 @@ void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startu
 
 	//CONS_Printf("MD2 for sprite %s not found\n", sprnames[spritenum]);
 	md2_models[spritenum].notfound = true;
-
 spritemd2found:
 	fclose(f);
 }
@@ -1153,6 +1146,8 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 
 	// Look at HWR_ProjectSprite for more
 	{
+		md2_t *md2s = NULL;
+		int skinnum = 0;
 		patch_t *gpatch, *blendgpatch;
 		GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
 		INT32 durs = spr->mobj->state->tics;
@@ -1212,29 +1207,36 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 		// dont forget to enabled the depth test because we can't do this like
 		// before: polygons models are not sorted
 
-		// 1. load model+texture if not already loaded
-		// 2. draw model with correct position, rotation,...
-
-		// Use the player MD2 list if the mobj has a skin and is using the player sprites
-		if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
+		/* fuck you */
+		if (spr->mobj->localskin)
 		{
-			/* fuck you */
-			md2_t *md2s = &R_GetMobjSkin(spr->mobj)->playermodel;
-
-			if (!md2s->notfound)
+			if (spr->mobj->skinlocal)
 			{
-				md2 = md2s;
-				md2->skinnum = R_GetMobjSkinNum(spr->mobj);
-				sprinfo = &spriteinfo[spr->mobj->sprite];
+				md2s = md2_localplayermodels;
+				skinnum = (skin_t *)spr->mobj->localskin - localskins;
 			}
-			else // if we can't find the player md2, use SPR_PLAY's MD2.
+			else
 			{
-				md2 = &md2_models[spr->mobj->sprite];
-				sprinfo = &spriteinfo[spr->mobj->sprite];
+				md2s = md2_playermodels;
+				skinnum = (skin_t *)spr->mobj->localskin - skins;
 			}
 		}
-		else
+		else if (spr->mobj->skin)
 		{
+			md2s = md2_playermodels;
+			skinnum = (skin_t *)spr->mobj->skin - skins;
+		}
+
+		// 1. load model+texture if not already loaded
+		// 2. draw model with correct position, rotation,...
+		if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY && !md2s[skinnum].notfound) // Use the player MD2 list if the mobj has a skin and is using the player sprites
+		{
+			md2 = &md2s[skinnum];
+			md2->skin = skinnum;
+			sprinfo = &spriteinfo[spr->mobj->sprite];
+		}
+		else
+		{	// if we can't find the player md2, use SPR_PLAY's MD2.
 			md2 = &md2_models[spr->mobj->sprite];
 			sprinfo = &spriteinfo[spr->mobj->sprite];
 		}
@@ -1297,7 +1299,6 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 				&& gpatch->width == blendgpatch->width && gpatch->height == blendgpatch->height)
 			{
 				INT32 tcskinnum = TC_DEFAULT;
-
 				if ((spr->mobj->flags & MF_BOSS) && (spr->mobj->flags2 & MF2_FRET) && (leveltime & 1)) // Bosses "flash"
 				{
 					if (spr->mobj->type == MT_CYBRAKDEMON)
@@ -1312,16 +1313,13 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 					if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
 					{
 						if (spr->mobj->colorized)
-						{
 							tcskinnum = TC_RAINBOW;
-						}
 						else
 						{
-							tcskinnum = (INT32)R_GetMobjSkinNum(spr->mobj);
+							tcskinnum = (INT32)(K_GetMobjSkinNum(K_GetMobjSkin(spr->mobj), spr->mobj->skinlocal));
 						}
 					}
-					else
-						tcskinnum = TC_DEFAULT;
+					else tcskinnum = TC_DEFAULT;
 				}
 
 				HWR_GetBlendedTexture(gpatch, blendgpatch, tcskinnum, spr->colormap, (skincolors_t)spr->mobj->color);
@@ -1385,7 +1383,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
 			p.z = FIXED_TO_FLOAT(interp.z);
 
 		if ((spr->mobj->skin || spr->mobj->localskin) && spr->mobj->sprite == SPR_PLAY)
-			sprdef = &R_GetMobjSkin(spr->mobj)->spritedef;
+			sprdef = &K_GetMobjSkin(spr->mobj)->spritedef;
 		else
 			sprdef = &sprites[spr->mobj->sprite];
 

src/hardware/hw_md2.h

@@ -33,11 +33,13 @@ typedef struct
 	void        *blendglpatch;
 	boolean     noblendfile; // true if blend texture file was not found
 	boolean     notfound;
-	INT32       skinnum;
+	INT32       skin;
 	boolean     error;
 } md2_t;
 
 extern md2_t md2_models[NUMSPRITES];
+extern md2_t md2_playermodels[MAXSKINS];
+extern md2_t md2_localplayermodels[MAXLOCALSKINS];
 
 void HWR_InitMD2(void);
 void HWR_DrawMD2(gl_vissprite_t *spr);

src/hardware/hw_shaders.h

@@ -193,26 +193,6 @@
 	"}\n" \
 	"#endif\0"
 
-#define GLSL_SOFTWARE_FRAGMENT_SHADER_NOPAL \
-	"uniform sampler2D tex;\n" \
-	"uniform vec4 poly_color;\n" \
-	"uniform vec4 tint_color;\n" \
-	"uniform vec4 fade_color;\n" \
-	"uniform float lighting;\n" \
-	"uniform float fade_start;\n" \
-	"uniform float fade_end;\n" \
-	GLSL_DOOM_COLORMAP \
-	GLSL_DOOM_LIGHT_EQUATION \
-	"void main(void) {\n" \
-		"vec4 texel = texture2D(tex, gl_TexCoord[0].st);\n" \
-		"vec4 base_color = texel * poly_color;\n" \
-		"vec4 final_color = base_color;\n" \
-		GLSL_SOFTWARE_TINT_EQUATION \
-		GLSL_SOFTWARE_FADE_EQUATION \
-		"final_color.a = texel.a * poly_color.a;\n" \
-		"gl_FragColor = final_color;\n" \
-	"}\n" \
-
 // hand tuned adjustments for light level calculation
 #define GLSL_FLOOR_FUDGES \
 	"#define STARTMAP_FUDGE 1.06\n" \

src/hardware/r_opengl/r_opengl.c

@@ -136,8 +136,7 @@ enum
 {
 	FBO_NONE,
 	FBO_ARB,
-	FBO_EXT,
-	FBO_EXT_STENCIL // supports stencil attachment
+	FBO_EXT
 };
 
 typedef struct
@@ -161,7 +160,7 @@ GL_DEPTH24_STENCIL8 GL_DEPTH_COMPONENT_EXT
 GL_DEPTH_STENCIL_ATTACHMENT GL_DEPTH_ATTACHMENT_EXT
 #endif
 
-static void GL_Framebuffer_DeleteAttachments(void);
+static void GL_FBO_DeleteAttachments(void);
 #endif
 
 // needed for glportals
@@ -769,28 +768,22 @@ static GLRGBAFloat shader_defaultcolor = {1.0f, 1.0f, 1.0f, 1.0f};
 #ifdef USE_FBO_OGL
 static int GLFramebuffer_CheckExt(void)
 {
-	// in opengl 3.0 and up fbos are standart and always supported
-	if (majorGL >= 3)
-		return FBO_ARB;
-
-	// gl versions from 2.1 may still support framebuffer objects
-
-	// maybe, just maybe, we support the standart extensions
+	// check for the standard arb extensions
+	// these should be there from version 3.0 onwards
 	if (GL_isExtAvailable("GL_ARB_framebuffer_no_attachments", gl_extensions) &&
 		GL_isExtAvailable("GL_ARB_framebuffer_object", gl_extensions) &&
 		GL_isExtAvailable("GL_ARB_framebuffer_sRGB", gl_extensions))
+	{
 		return FBO_ARB;
+	}
 
-	// nope, try the older 2.1 extensions
+	// gl versions from 2.1 and older may still support framebuffer objects
+	// depending on vendor and driver support
 	if (GL_isExtAvailable("GL_EXT_framebuffer_no_attachments", gl_extensions) &&
 		GL_isExtAvailable("GL_EXT_framebuffer_object", gl_extensions) &&
-		GL_isExtAvailable("GL_EXT_framebuffer_sRGB", gl_extensions))
+		GL_isExtAvailable("GL_EXT_framebuffer_sRGB", gl_extensions) &&
+		GL_isExtAvailable("GL_EXT_packed_depth_stencil", gl_extensions)) // we use the stencil buffer for stuff like portals, so its better to make stencil extension a requirement
 	{
-		// perhaps we may even support a stencil attachment
-		if (GL_isExtAvailable("GL_EXT_packed_depth_stencil", gl_extensions))
-			return FBO_EXT_STENCIL;
-
-		// no stencil support, sad
 		return FBO_EXT;
 	}
 
@@ -908,36 +901,41 @@ void SetupGLFunc4(void)
 
 			GL_DBG_Printf("\nFBO: ARB extensions found\n");
 		}
-		else if (fbocheck == FBO_EXT || fbocheck == FBO_EXT_STENCIL) // uh oh only support for EXT prefix fbos...
+		else if (fbocheck == FBO_EXT) // uh oh only support old fbo extensions...
 		{
-			GetGLfunc(glGenFramebuffersEXT);
-			GetGLfunc(glBindFramebufferEXT);
-			GetGLfunc(glDeleteFramebuffersEXT);
-			GetGLfunc(glFramebufferTexture2DEXT);
-			GetGLfunc(glCheckFramebufferStatusEXT);
-			GetGLfunc(glGenRenderbuffersEXT);
-			GetGLfunc(glBindRenderbufferEXT);
-			GetGLfunc(glDeleteRenderbuffersEXT);
-			GetGLfunc(glRenderbufferStorageEXT);
-			GetGLfunc(glFramebufferRenderbufferEXT);
-
 			// remapping galore huehue
 			// do this so we dont have to dupe half our code
+			GetGLfunc(glGenFramebuffersEXT);
 			pglGenFramebuffers = pglGenFramebuffersEXT;
+
+			GetGLfunc(glBindFramebufferEXT);
 			pglBindFramebuffer = pglBindFramebufferEXT;
+
+			GetGLfunc(glDeleteFramebuffersEXT);
 			pglDeleteFramebuffers  = pglDeleteFramebuffersEXT;
+
+			GetGLfunc(glFramebufferTexture2DEXT);
 			pglFramebufferTexture2D = pglFramebufferTexture2DEXT;
+
+			GetGLfunc(glCheckFramebufferStatusEXT);
 			pglCheckFramebufferStatus = pglCheckFramebufferStatusEXT;
+
+			GetGLfunc(glGenRenderbuffersEXT);
 			pglGenRenderbuffers = pglGenRenderbuffersEXT;
+
+			GetGLfunc(glBindRenderbufferEXT);
 			pglBindRenderbuffer = pglBindRenderbufferEXT;
+
+			GetGLfunc(glDeleteRenderbuffersEXT);
 			pglDeleteRenderbuffers = pglDeleteRenderbuffersEXT;
+
+			GetGLfunc(glRenderbufferStorageEXT);
 			pglRenderbufferStorage = pglRenderbufferStorageEXT;
+
+			GetGLfunc(glFramebufferRenderbufferEXT);
 			pglFramebufferRenderbuffer = pglFramebufferRenderbufferEXT;
 
-			if (fbocheck == FBO_EXT)
-				GL_DBG_Printf("\nFBO: EXT extensions found, no stencil\n");
-			else if (fbocheck == FBO_EXT_STENCIL)
-				GL_DBG_Printf("\nFBO: EXT extensions with packed depth-stencil\n");
+			GL_DBG_Printf("\nFBO: EXT extensions with packed depth-stencil\n");
 		}
 
 		supportFBO = fbocheck;
@@ -1151,7 +1149,7 @@ void GL_SetModelView(GLint w, GLint h)
 		GL_FlushScreenTextures();
 
 #ifdef USE_FBO_OGL
-		GL_Framebuffer_DeleteAttachments();
+		GL_FBO_DeleteAttachments();
 #endif
 	}
 
@@ -2641,11 +2639,7 @@ void GL_SetSpecialState(hwdspecialstate_t IdState, INT32 Value)
 
 		case HWD_SET_MSAA:
 			if (Value)
-			{
 				pglEnable(GL_MULTISAMPLE);
-				if (Value == 2)
-					pglEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
-			}
 			break;
 
 		case HWD_SET_TEXTUREANISOTROPICMODE:
@@ -3246,7 +3240,7 @@ void GL_SetTransform(FTransform *stransform)
 }
 
 #ifdef USE_FBO_OGL
-static void GL_Framebuffer_DeleteAttachments(void)
+static void GL_FBO_DeleteAttachments(void)
 {
 	if (supportFBO == FBO_NONE || !framebufferobject.init)
 		return;
@@ -3266,9 +3260,9 @@ static void GL_Framebuffer_DeleteAttachments(void)
 	framebufferobject.init = false;
 }
 
-static void GL_Framebuffer_Generate(void)
+static void GL_FBO_Generate(void)
 {
-	if (supportFBO == FBO_NONE || framebufferobject.init || !UseScreenFBO())
+	if (supportFBO == FBO_NONE || framebufferobject.init)
 		return;
 
 	// Generate the framebuffer
@@ -3283,7 +3277,7 @@ static void GL_Framebuffer_Generate(void)
 	{
 		pglGenTextures(1, &framebufferobject.tex);
 		pglBindTexture(GL_TEXTURE_2D, framebufferobject.tex);
-		pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, screen_width, screen_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, screen_width, screen_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 		Clamp2D(GL_TEXTURE_WRAP_S);
@@ -3306,18 +3300,13 @@ static void GL_Framebuffer_Generate(void)
 			pglRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8, screen_width, screen_height);
 			pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
 		}
-		else if (supportFBO == FBO_EXT || supportFBO == FBO_EXT_STENCIL)
+		else if (supportFBO == FBO_EXT)
 		{
-			pglRenderbufferStorage(GL_RENDERBUFFER_EXT, (supportFBO == FBO_EXT_STENCIL) ? GL_DEPTH_STENCIL_EXT : GL_DEPTH_COMPONENT, screen_width, screen_height);
-
-			// attach a renderbuffer to depth attachment point
+			pglRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, screen_width, screen_height);
+			// attach the renderbuffer to depth attachment point
 			pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
-
-			if (supportFBO == FBO_EXT_STENCIL)
-			{
-				// attach a renderbuffer to stencil attachment point
-				pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
-			}
+			// attach the renderbuffer to stencil attachment point
+			pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
 		}
 
 		// Clear the renderbuffer
@@ -3329,7 +3318,7 @@ static void GL_Framebuffer_Generate(void)
 	if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
 	{
 		//pglGetError(); TODO:implement this or smth
-		GL_MSG_Error("GL_Framebuffer_Generate: Failed to create Framebuffer Object");
+		GL_MSG_Error("GL_FBO_Generate: Failed to create Framebuffer Object");
 
 		// if this fails, dont retry it a gazillion times
 		// this wouldnt recover
@@ -3344,7 +3333,7 @@ static void GL_Framebuffer_Generate(void)
 	framebufferobject.init = true;
 }
 
-void GL_Framebuffer_Unbind(void)
+void GL_FBO_BindMainFrameBuffer(void)
 {
 	if (supportFBO == FBO_NONE || !framebufferobject.init)
 		return;
@@ -3353,22 +3342,22 @@ void GL_Framebuffer_Unbind(void)
 	pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0);
 }
 
-void GL_Framebuffer_Enable(void)
+void GL_FBO_Enable(void)
 {
-	if (supportFBO == FBO_NONE || !UseScreenFBO())
+	if (supportFBO == FBO_NONE)
 		return;
 
-	GL_Framebuffer_Generate();
+	GL_FBO_Generate();
 
 	// failed
-	if (supportFBO == FBO_NONE || !framebufferobject.init)
+	if (!framebufferobject.init)
 		return;
 
 	pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);
 	pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
 }
 
-void GL_Framebuffer_Disable(void)
+void GL_FBO_Disable(void)
 {
 	if (supportFBO == FBO_NONE || !framebufferobject.init)
 		return;
@@ -3381,7 +3370,7 @@ void GL_Framebuffer_Disable(void)
 		pglDeleteFramebuffers(1, &framebufferobject.fboobj);
 	framebufferobject.fboobj = 0;
 
-	GL_Framebuffer_DeleteAttachments();
+	GL_FBO_DeleteAttachments();
 }
 #endif
 
@@ -3732,6 +3721,7 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
 void GL_MakeScreenTexture(int tex)
 {
 	boolean firstTime;
+	static GLint lastfiltermode[NUMSCREENTEXTURES] = {-1, -1, -1, -1, -1};
 
 	if (!gl_enable_screen_textures)
 		return;
@@ -3744,16 +3734,29 @@ void GL_MakeScreenTexture(int tex)
 
 	pglBindTexture(GL_TEXTURE_2D, screenTextures[tex]);
 
+	// if were downsampling, choose to do that with linear filter instead of nearest neighbor
+	// otherwise well get ugly mixels
+	GLint filtermode = I_IsDownsampling() ? GL_LINEAR : GL_NEAREST;
+
+	// avoid redundant calls to this, prob doesent really matter tbh
+	if (filtermode != lastfiltermode[tex] || firstTime)
+	{
+		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtermode);
+		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtermode);
+
+		lastfiltermode[tex] = filtermode;
+	}
+
 	if (firstTime)
 	{
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-		pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 		Clamp2D(GL_TEXTURE_WRAP_S);
 		Clamp2D(GL_TEXTURE_WRAP_T);
 		pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, screen_texsizew, screen_texsizeh, 0);
 	}
 	else
+	{
 		pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen_texsizew, screen_texsizeh);
+	}
 
 	tex_downloaded = screenTextures[tex];
 }

src/hardware/r_opengl/r_opengl.h

@@ -98,9 +98,9 @@ extern PFNglGetString pglGetString;
 #endif
 
 #ifdef USE_FBO_OGL
-void GL_Framebuffer_Unbind(void);
-void GL_Framebuffer_Enable(void);
-void GL_Framebuffer_Disable(void);
+void GL_FBO_BindMainFrameBuffer(void);
+void GL_FBO_Enable(void);
+void GL_FBO_Disable(void);
 extern int supportFBO;
 #endif
 

src/hu_stuff.c

@@ -2654,12 +2654,9 @@ static inline void HU_DrawSpectatorTicker(void)
 
 				if (player->mo && player->mo->color)
 				{
-					const UINT8 *colormap = NULL;
-
+					const UINT8 *colormap = R_GetTranslationColormap(player->skin, player->mo->color, GTC_CACHE);
 					if (player->mo->colorized)
 						colormap = R_GetTranslationColormap(TC_RAINBOW, player->mo->color, GTC_CACHE);
-					else
-						colormap = R_GetTranslationColormap(player->skin, player->mo->color, GTC_CACHE);
 
 					if (K_UseHighResPortraits())
 						V_DrawSmallMappedPatch((templength - duptweak), height+10, V_TRANSLUCENT, R_GetSkinFaceWant(player), colormap);

src/i_video.h

@@ -126,11 +126,9 @@ boolean I_CheckNativeRes(void);
 void I_SetBorderlessWindow(void);
 
 #ifdef USE_FBO_OGL
-
-void RefreshOGLSDLSurface(void);
-void I_DownSample(void);
+void I_CheckDownSampleState(boolean forcerefresh);
+boolean I_IsDownsampling(void);
 boolean UseScreenFBO(void);
-extern boolean downsample;
 #endif
 
 // So we can call this from i_video event loop

src/k_hud.c

@@ -1221,8 +1221,10 @@ boolean K_UseHighResPortraits(void)
 // accounts for localskins
 patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum)
 {
-	const skin_t *skin = R_GetSkinArray(player->skinlocal)[skinnum];
-	return (K_UseHighResPortraits() ? skin->facewantprefix : skin->facerankprefix);
+	if (!player->skinlocal)
+		return (K_UseHighResPortraits() ? facewantprefix[skinnum] : facerankprefix[skinnum]);
+	else
+		return (K_UseHighResPortraits() ? localfacewantprefix[skinnum] : localfacerankprefix[skinnum]);
 }
 
 INT32 K_calcSplitFlags(INT32 snapflags)
@@ -1424,7 +1426,7 @@ static void K_drawKartStats(void)
 		flags |= V_HUDTRANS;
 		flags2 = flags|V_ALLOWLOWERCASE|V_SkinColorToHighlightcolor(stplyr->skincolor);
 
-		fakeskin = R_GetPlayerSkin(stplyr);
+		fakeskin = K_GetPlayerSkin(stplyr);
 
 		// Skin name
 		if (cv_showstats_skinname.value)
@@ -3107,7 +3109,7 @@ static void K_drawNameTags(void)
 		cm = R_GetTranslationColormap(players[i].skin, players[i].mo->color, GTC_CACHE);
 		tagcolor = colortranslations[players[i].mo->color][7];
 		vflags = trans | V_NOSCALESTART;
-		usenametagrestat = ((cv_nametagrestat.value == 1 && (players[i].kartspeed != skins[players[i].skin]->kartspeed || players[i].kartweight != skins[players[i].skin]->kartweight)) || cv_nametagrestat.value == 2);
+		usenametagrestat = ((cv_nametagrestat.value == 1 && (players[i].kartspeed != skins[players[i].skin].kartspeed || players[i].kartweight != skins[players[i].skin].kartweight)) || cv_nametagrestat.value == 2);
 		tagwidthsmall = cv_smallnametags.value ? V_SmallStringWidth(player_names[i], V_ALLOWLOWERCASE) : V_ThinStringWidth(player_names[i], V_ALLOWLOWERCASE);
 		tagwidth = vid.dup*tagwidthsmall;
 
@@ -3592,12 +3594,12 @@ static void K_drawKartMinimapHead(mobj_t *mo, INT32 x, INT32 y, INT32 flags)
 	INT32 rot = 0;
 #endif
 
-	skin = R_GetMobjSkin(mo);
+	skin = K_GetMobjSkin(mo);
 
 	if (!skin)
 		return;
 
-	minimaphead = skin->facemmapprefix;
+	minimaphead = (skinlocal ? localfacemmapprefix : facemmapprefix)[K_GetMobjSkinNum(skin, skinlocal)];
 
 	if (minimaphead == NULL)
 		return;
@@ -3828,7 +3830,7 @@ static void K_drawKartMinimap(void)
 				else
 				{
 					// special case if startcolor is not the default (160 / Green)
-					if (R_GetMobjSkin(mobj)->starttranscolor != skins[0]->starttranscolor)
+					if (K_GetMobjSkin(mobj)->starttranscolor != skins[0].starttranscolor)
 					{
 						colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
 					}
@@ -4903,7 +4905,7 @@ void K_drawKartHUD(void)
 		for (c = 1; c < MAXSKINCOLORS; c++)
 		{
 			UINT8 *cm = R_GetTranslationColormap(TC_RAINBOW, c, GTC_CACHE);
-			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT>>1, 0, skins[stplyr->skin]->facewantprefix, cm);
+			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT>>1, 0, facewantprefix[stplyr->skin], cm);
 
 			x += 16;
 			if (x > BASEVIDWIDTH-16)

src/k_hud.h

@@ -78,8 +78,6 @@ INT32 K_getMinimapTrans(void);
 void K_getLapsDrawinfo(drawinfo_t *out);
 void K_getMinimapDrawinfo(drawinfo_t *out);
 
-patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum);
-
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/k_kart.c

@@ -592,7 +592,7 @@ void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, bo
 	if (color >= MAXTRANSLATIONS)
 		I_Error("Invalid skin color #%hu.", (UINT16)color);
 
-	starttranscolor = (skinnum != TC_DEFAULT) ? R_GetSkinArray(local)[skinnum]->starttranscolor : DEFAULT_STARTTRANSCOLOR;
+	starttranscolor = (skinnum != TC_DEFAULT) ? K_GetSkinArray(local)[skinnum].starttranscolor : DEFAULT_STARTTRANSCOLOR;
 
 	if (starttranscolor >= NUM_PALETTE_ENTRIES)
 		I_Error("Invalid startcolor #%d.", starttranscolor);
@@ -632,6 +632,60 @@ UINT8 K_GetKartColorByName(const char *name)
 	return 0;
 }
 
+//
+// returns the players skinnumber
+// accounts for localskins
+//
+INT32 K_GetSkinNum(player_t *player)
+{
+	return player->localskin ? (player->localskin - 1) : player->skin;
+}
+
+//
+// returns the mobj skinnumber
+// accounts for localskins ?
+//
+INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local)
+{
+	return skin - K_GetSkinArray(local);
+}
+
+//
+// returns the mobj skinnumber
+// accounts for localskins
+//
+INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local)
+{
+	return localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
+}
+
+//
+// returns the players skinnumber
+// accounts for localskins
+//
+skin_t *K_GetMobjSkin(const mobj_t *mobj)
+{
+	return mobj->localskin ? mobj->localskin : mobj->skin;
+}
+
+//
+// returns the skin array to use
+// accounts for localskins
+//
+skin_t *K_GetSkinArray(boolean local)
+{
+	return local ? localskins : skins;
+}
+
+//
+// returns the players skin
+// accounts for localskins
+//
+skin_t *K_GetPlayerSkin(player_t *player)
+{
+	return &K_GetSkinArray(player->skinlocal)[K_GetSkinNum(player)];
+}
+
 //}
 
 //{ SRB2kart Net Variables
@@ -1935,7 +1989,7 @@ static void K_PlayGenericCombatSound(mobj_t *source, mobj_t *other, sfxenum_t sf
 	// I HATE LOCALSKINS! I HATE LOCALSKINS! :AAAAAAAAAA:
 	if (source->player)
 	{
-		skin = R_GetPlayerSkin(source->player);
+		skin = K_GetPlayerSkin(source->player);
 	}
 
 	if (!skin)
@@ -3289,8 +3343,8 @@ static void K_StretchPlayerGravity(player_t *player)
 
 	mobj_t *pmo = player->mo;
 
-	fixed_t tempxscale = pmo->realxscale;
-	fixed_t tempyscale = pmo->realyscale;
+	const fixed_t tempxscale = pmo->realxscale;
+	const fixed_t tempyscale = pmo->realyscale;
 
 	stretchScaleFactor = FixedDiv(mapobjectscale*60, cv_gravstretch.value);
 	stretchScaleFactor = min(stretchScaleFactor, MAXSTRETCHDIV);
@@ -3344,8 +3398,8 @@ static void K_SaltySquish(player_t *player)
 
 	mobj_t *pmo = player->mo;
 
-	fixed_t tempxscale = pmo->realxscale;
-	fixed_t tempyscale = pmo->realyscale;
+	const fixed_t tempxscale = pmo->realxscale;
+	const fixed_t tempyscale = pmo->realyscale;
 
 	if (pmo->stretchslam > 0)
 	{

src/lua_baselib.c

@@ -1766,8 +1766,6 @@ static int lib_rSetPlayerSkin(lua_State *L)
 		INT32 i = luaL_checkinteger(L, 2);
 		if (i < 0 || i >= MAXSKINS)
 			return luaL_error(L, "skin number (argument #2) %d out of range (0 - %d)", i, MAXSKINS-1);
-		if (i >= numskins)
-			return 0;
 		SetPlayerSkinByNum(player-players, i);
 	}
 	else // skin name
@@ -2633,7 +2631,7 @@ static int lib_kLossSound(lua_State *L)
 	if (!mobj->player)
 		return luaL_error(L, "K_PlayLossSound: mobj_t isn't a player object.");
 
-	sfx_id = R_GetMobjSkin(mobj)->soundsid[S_sfx[sfx_klose].skinsound];
+	sfx_id = ((skin_t *)mobj->skin)->soundsid[S_sfx[sfx_klose].skinsound];
 	S_StartSound(mobj, sfx_id);
 	return 0;
 }

src/lua_consolelib.c

@@ -182,14 +182,19 @@ void COM_Lua_f(void)
 			len = (argc+1)*256;
 
 		buf = malloc(len);
+		if (buf == NULL)
+			I_Error("Failed to allocate buffer for COM_Lua_f");
+
 		p = buf;
 		WRITEUINT8(p, argc);
 		for (i = 0; i < argc; i++)
 			WRITESTRINGN(p, COM_Argv(i), 255);
-		if (flags & 2)
+
+		if (flags & COM_SPLITSCREEN)
 			SendNetXCmdForPlayer(1, XD_LUACMD, buf, p-buf);
 		else
 			SendNetXCmd(XD_LUACMD, buf, p-buf);
+
 		free(buf);
 		return;
 	}

src/lua_hooklib.c

@@ -962,7 +962,7 @@ static void res_botai(Hook_State *hook)
 
 int LUA_HookBotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
 {
-	const char *skin = tails->skin->name;
+	const char *skin = ((skin_t *)tails->skin)->name;
 
 	Hook_State hook = {};
 	BotAI_State botai = {};

src/lua_hud.h

@@ -53,6 +53,4 @@ boolean LUA_HudEnabled(enum hud option);
 
 void LUA_SetHudHook(int hook, huddrawlist_h list);
 
-#define LOCALSKINIMMERSION (hud_running && cv_luaimmersion.value)
-
 #endif // __LUA_HUD_H__

src/lua_hudlib.c

@@ -487,7 +487,7 @@ static int libd_getSpritePatch(lua_State *L)
 		{
 			const char *name = luaL_checkstring(L, 1);
 			for (skn = 0; skn < numskins; skn++)
-				if (fastcmp(skins[skn]->name, name))
+				if (fastcmp(skins[skn].name, name))
 					break;
 			if (skn >= numskins)
 				return 0;
@@ -527,9 +527,9 @@ static int libd_getSpritePatch(lua_State *L)
 	}
 	else // player skin
 	{
-		sprdef = &skins[skn]->spritedef;
+		sprdef = &skins[skn].spritedef;
 #ifdef ROTSPRITE
-		sprinfo = &skins[skn]->sprinfo;
+		sprinfo = &skins[skn].sprinfo;
 #endif
 	}
 
@@ -1056,8 +1056,6 @@ static int libd_getColormap(lua_State *L)
 		skinnum = (INT32)luaL_checkinteger(L, 1);
 		if (skinnum < TC_BLINK || skinnum >= MAXSKINS)
 			return luaL_error(L, "skin number %d is out of range (%d - %d)", skinnum, TC_BLINK, MAXSKINS-1);
-		if (skinnum >= numskins)
-			return 0;
 	}
 	else // skin name
 	{

src/lua_maplib.c

@@ -18,7 +18,6 @@
 #include "p_slopes.h"
 #include "r_main.h"
 
-#include "lua_udatalib.h"
 #include "lua_script.h"
 #include "lua_libs.h"
 #include "lua_hud.h" // hud_running errors
@@ -256,15 +255,6 @@ static const char *const vector_opt[] = {
 static const char *const array_opt[] ={"iterate",NULL};
 static const char *const valid_opt[] ={"valid",NULL};
 
-#define pushsubsector(L, subsector) LUA_PushUserdata(L, subsector, META_SUBSECTOR)
-int udatalib_getter_subsector(lua_State *L)
-UDATALIB_SIMPLE_GETTER(subsector_t*, pushsubsector)
-#undef pushsubsector
-
-#define pushslope(L, slope) LUA_PushUserdata(L, slope, META_SLOPE)
-int udatalib_getter_slope(lua_State *L)
-UDATALIB_SIMPLE_GETTER(pslope_t*, pushslope)
-#undef pushslope
 // iterates through a sector's thinglist!
 static int lib_iterateSectorThinglist(lua_State *L)
 {

src/lua_skinlib.c

@@ -18,10 +18,6 @@
 
 #include "lua_script.h"
 #include "lua_libs.h"
-#include "lua_hud.h" // hud_running errors
-
-#define SKINARR (LOCALSKINIMMERSION ? allskins : skins)
-#define NSKINS (LOCALSKINIMMERSION ? numallskins : numskins)
 
 enum skin {
 	skin_valid = 0,
@@ -154,15 +150,13 @@ static int skin_num(lua_State *L)
 	// skins are always valid, only added, never removed
 	I_Assert(skin != NULL);
 
-	lua_pushinteger(L, LOCALSKINIMMERSION ? skin->allskinnum : skin->skinnum);
+	lua_pushinteger(L, skin-skins);
 	return 1;
 }
 
 static int lib_iterateSkins(lua_State *L)
 {
 	INT32 i;
-	skin_t **skinar = SKINARR;
-	const INT32 nskins = NSKINS;
 
 	if (lua_gettop(L) < 2)
 	{
@@ -175,17 +169,14 @@ static int lib_iterateSkins(lua_State *L)
 	lua_remove(L, 1); // state is unused.
 
 	if (!lua_isnil(L, 1))
-	{
-		skin_t *skin = (*((skin_t **)luaL_checkudata(L, 1, META_SKIN)));
-		i = (INT32)(LOCALSKINIMMERSION ? skin->allskinnum : skin->skinnum) + 1;
-	}
+		i = (INT32)(*((skin_t **)luaL_checkudata(L, 1, META_SKIN)) - allskins) + 1;
 	else
 		i = 0;
 
 	// skins are always valid, only added, never removed
-	if (i < nskins)
+	if (i < numallskins)
 	{
-		LUA_PushUserdata(L, skinar[i], META_SKIN);
+		LUA_PushUserdata(L, &allskins[i], META_SKIN);
 		return 1;
 	}
 
@@ -197,40 +188,32 @@ static int lib_getSkin(lua_State *L)
 	const char *field;
 	INT32 i;
 
-	skin_t **skinar = SKINARR;
-	const INT32 nskins = NSKINS;
-
 	// find skin by number
 	if (lua_type(L, 2) == LUA_TNUMBER)
 	{
-		const INT32 skinmax = LOCALSKINIMMERSION ? numallskins : MAXSKINS;
-
 		i = luaL_checkinteger(L, 2);
-
-		if (i < 0 || i >= skinmax)
-			return luaL_error(L, "skins[] index %d out of range (0 - %d)", i, skinmax-1);
-		if (i >= nskins)
+		if (i < 0 || i >= MAXSKINS)
+			return luaL_error(L, "skins[] index %d out of range (0 - %d)", i, MAXSKINS-1);
+		if (i >= numallskins)
 			return 0;
-
-		LUA_PushUserdata(L, skinar[i], META_SKIN);
-
+		LUA_PushUserdata(L, &allskins[i], META_SKIN);
 		return 1;
 	}
 
 	field = luaL_checkstring(L, 2);
 
 	// special function iterate
-	if (fastcmp(field, "iterate"))
+	if (fastcmp(field,"iterate"))
 	{
 		lua_pushcfunction(L, lib_iterateSkins);
 		return 1;
 	}
 
 	// find skin by name
-	for (i = 0; i < nskins; i++)
-		if (fastcmp(skinar[i]->name, field))
+	for (i = 0; i < numallskins; i++)
+		if (fastcmp(allskins[i].name, field))
 		{
-			LUA_PushUserdata(L, skinar[i], META_SKIN);
+			LUA_PushUserdata(L, &allskins[i], META_SKIN);
 			return 1;
 		}
 
@@ -239,7 +222,7 @@ static int lib_getSkin(lua_State *L)
 
 static int lib_numSkins(lua_State *L)
 {
-	lua_pushinteger(L, NSKINS);
+	lua_pushinteger(L, numallskins);
 	return 1;
 }
 

src/lua_udatalib.c

@@ -1,137 +0,0 @@
-// SONIC ROBO BLAST 2 KART SATURN
-//-----------------------------------------------------------------------------
-// Copyright (C) 2025 by Indev.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file  lua_udatalib.c
-/// \brief Implementation of lua userdata object metatables based on getter/setter functions
-
-#include "doomtype.h"
-#include "m_fixed.h"
-#include "lua_udatalib.h"
-
-// Getters
-int udatalib_getter_fixed(lua_State *L)
-UDATALIB_SIMPLE_GETTER(fixed_t, lua_pushinteger)
-
-int udatalib_getter_angle(lua_State *L)
-UDATALIB_SIMPLE_GETTER(angle_t, lua_pushangle)
-
-int udatalib_getter_uint8(lua_State *L)
-UDATALIB_SIMPLE_GETTER(UINT8, lua_pushinteger)
-
-int udatalib_getter_sint8(lua_State *L)
-UDATALIB_SIMPLE_GETTER(SINT8, lua_pushinteger)
-
-int udatalib_getter_uint16(lua_State *L)
-UDATALIB_SIMPLE_GETTER(UINT16, lua_pushinteger)
-
-int udatalib_getter_int16(lua_State *L)
-UDATALIB_SIMPLE_GETTER(INT16, lua_pushinteger)
-
-int udatalib_getter_uint32(lua_State *L)
-UDATALIB_SIMPLE_GETTER(UINT32, lua_pushinteger)
-
-int udatalib_getter_int32(lua_State *L)
-UDATALIB_SIMPLE_GETTER(INT32, lua_pushinteger)
-
-int udatalib_getter_uint64(lua_State *L)
-UDATALIB_SIMPLE_GETTER(UINT64, lua_pushinteger)
-
-int udatalib_getter_int64(lua_State *L)
-UDATALIB_SIMPLE_GETTER(INT64, lua_pushinteger)
-
-int udatalib_getter_string(lua_State *L)
-UDATALIB_SIMPLE_GETTER(const char*, lua_pushstring)
-
-int udatalib_getter_boolean(lua_State *L)
-UDATALIB_SIMPLE_GETTER(boolean, lua_pushboolean)
-
-int udatalib_getter_spritenum(lua_State *L)
-UDATALIB_SIMPLE_GETTER(spritenum_t, lua_pushinteger)
-
-int udatalib_getter_tic(lua_State *L)
-UDATALIB_SIMPLE_GETTER(tic_t, lua_pushinteger)
-
-// Setters
-int udatalib_setter_fixed(lua_State *L)
-UDATALIB_SIMPLE_SETTER(fixed_t, luaL_checkfixed)
-
-int udatalib_setter_angle(lua_State *L)
-UDATALIB_SIMPLE_SETTER(angle_t, luaL_checkangle)
-
-int udatalib_setter_uint8(lua_State *L)
-UDATALIB_SIMPLE_SETTER(UINT8, (UINT8)luaL_checkinteger)
-
-int udatalib_setter_sint8(lua_State *L)
-UDATALIB_SIMPLE_SETTER(SINT8, luaL_checkinteger)
-
-int udatalib_setter_uint16(lua_State *L)
-UDATALIB_SIMPLE_SETTER(UINT16, (UINT16)luaL_checkinteger)
-
-int udatalib_setter_int16(lua_State *L)
-UDATALIB_SIMPLE_SETTER(INT16, luaL_checkinteger)
-
-int udatalib_setter_uint32(lua_State *L)
-UDATALIB_SIMPLE_SETTER(UINT32, (UINT32)luaL_checkinteger)
-
-int udatalib_setter_int32(lua_State *L)
-UDATALIB_SIMPLE_SETTER(INT32, luaL_checkinteger)
-
-int udatalib_setter_uint64(lua_State *L)
-UDATALIB_SIMPLE_SETTER(UINT64, (UINT64)luaL_checkinteger)
-
-int udatalib_setter_int64(lua_State *L)
-UDATALIB_SIMPLE_SETTER(INT64, luaL_checkinteger)
-
-int udatalib_setter_string(lua_State *L)
-UDATALIB_SIMPLE_SETTER(const char*, luaL_checkstring)
-
-int udatalib_setter_boolean(lua_State *L)
-UDATALIB_SIMPLE_SETTER(boolean, luaL_checkboolean)
-
-// ffs
-int udatalib_setter_boolean_nocheck(lua_State *L)
-UDATALIB_SIMPLE_SETTER(boolean, lua_toboolean)
-
-int udatalib_setter_spritenum(lua_State *L)
-UDATALIB_SIMPLE_SETTER(spritenum_t, luaL_checkinteger)
-
-int udatalib_setter_tic(lua_State *L)
-UDATALIB_SIMPLE_SETTER(tic_t, (tic_t)luaL_checkinteger)
-
-
-void udatalib_addfield(lua_State *L, int mt, udata_field_t field)
-{
-    int idx = abs_index(L, mt);
-
-    lua_createtable(L, 2, 0); // Push table
-
-    lua_pushinteger(L, field.offset); // Push offset
-    lua_pushcclosure(L, field.getter, 1); // Pop offset, push closure
-
-    lua_rawseti(L, -2, UDATALIB_GETTER); // Pop closure, add to table
-
-    lua_pushinteger(L, field.offset); // Push offset
-    lua_pushcclosure(L, field.setter, 1); // Pop offset, push closure
-
-    lua_rawseti(L, -2, UDATALIB_SETTER); // Pop closure, add to table
-
-    lua_pushstring(L, field.name); // Push field name
-    lua_pushvalue(L, -2); // Copy table
-    lua_rawset(L, idx); // Pop field name and table, add to metatable
-
-    lua_pop(L, 1); // Pop field table
-}
-
-void udatalib_addfields(lua_State *L, int mt, const udata_field_t fields[])
-{
-    for (unsigned i = 0; fields[i].name != NULL; ++i)
-    {
-        udatalib_addfield(L, mt, fields[i]);
-        //CONS_Printf("Add field name=%s, offset=%d, getter=%p, setter=%p\n", fields[i].name, fields[i].offset, fields[i].getter, fields[i].setter);
-    }
-}

src/lua_udatalib.h

@@ -1,114 +0,0 @@
-// SONIC ROBO BLAST 2 KART SATURN
-//-----------------------------------------------------------------------------
-// Copyright (C) 2025 by Indev.
-//
-// This program is free software distributed under the
-// terms of the GNU General Public License, version 2.
-// See the 'LICENSE' file for more details.
-//-----------------------------------------------------------------------------
-/// \file  lua_udatalib.h
-/// \brief Implementation of lua userdata object metatables based on getter/setter functions
-
-#ifndef __LUA_UDATALIB_H__
-#define __LUA_UDATALIB_H__
-
-#include "doomdef.h"
-#include "lua_script.h"
-#include "lua_libs.h"
-#include "fastcmp.h"
-
-// Indices in getter/setter tables for fields
-#define UDATALIB_GETTER 1
-#define UDATALIB_SETTER 2
-
-typedef struct udata_field_s {
-    const char *name;
-    size_t offset;
-    lua_CFunction getter;
-    lua_CFunction setter;
-} udata_field_t;
-
-// Simple setters and getters, for situations where getter is simply
-// "return obj.field" and setter is "obj.field = value"
-int udatalib_getter_fixed(lua_State *L);
-int udatalib_getter_angle(lua_State *L);
-int udatalib_getter_uint8(lua_State *L);
-int udatalib_getter_sint8(lua_State *L);
-int udatalib_getter_uint16(lua_State *L);
-int udatalib_getter_int16(lua_State *L);
-int udatalib_getter_uint32(lua_State *L);
-int udatalib_getter_int32(lua_State *L);
-int udatalib_getter_uint64(lua_State *L);
-int udatalib_getter_int64(lua_State *L);
-int udatalib_getter_string(lua_State *L);
-int udatalib_getter_boolean(lua_State *L);
-int udatalib_getter_spritenum(lua_State *L);
-int udatalib_getter_mobj(lua_State *L);
-int udatalib_getter_subsector(lua_State *L);
-int udatalib_getter_mobjtype(lua_State *L);
-int udatalib_getter_player(lua_State *L);
-int udatalib_getter_mapthing(lua_State *L);
-int udatalib_getter_slope(lua_State *L);
-int udatalib_getter_cmd(lua_State *L);
-int udatalib_getter_playerstate(lua_State *L);
-int udatalib_getter_powers(lua_State *L);
-int udatalib_getter_kartstuff(lua_State *L);
-int udatalib_getter_pflags(lua_State *L);
-int udatalib_getter_panim(lua_State *L);
-int udatalib_getter_tic(lua_State *L);
-
-int udatalib_setter_fixed(lua_State *L);
-int udatalib_setter_angle(lua_State *L);
-int udatalib_setter_uint8(lua_State *L);
-int udatalib_setter_sint8(lua_State *L);
-int udatalib_setter_uint16(lua_State *L);
-int udatalib_setter_int16(lua_State *L);
-int udatalib_setter_uint32(lua_State *L);
-int udatalib_setter_int32(lua_State *L);
-int udatalib_setter_uint64(lua_State *L);
-int udatalib_setter_int64(lua_State *L);
-int udatalib_setter_string(lua_State *L);
-int udatalib_setter_boolean(lua_State *L);
-int udatalib_setter_boolean_nocheck(lua_State *L);
-int udatalib_setter_spritenum(lua_State *L);
-int udatalib_setter_mobj(lua_State *L);
-int udatalib_setter_playerstate(lua_State *L);
-int udatalib_setter_pflags(lua_State *L);
-int udatalib_setter_panim(lua_State *L);
-int udatalib_setter_tic(lua_State *L);
-
-// Adds setter and getter for field and stores it as field.name..".get" and
-// field.name..".set" in table at index mt. (metatable, usually)
-void udatalib_addfield(lua_State *L, int mt, udata_field_t field);
-
-// Convinience function to add array of fields at once.
-void udatalib_addfields(lua_State *L, int mt, const udata_field_t fields[]);
-
-// I miss C++ template functons :(
-
-// Get pointer to field value within getter or setter
-#define UDATALIB_GETFIELD(type, field) \
-{ \
-    size_t offset = lua_tointeger(L, lua_upvalueindex(1)); \
-    field = (type*)((uint8_t*)lua_touserdata(L, 1) + offset); \
-}
-
-// Creates implementation for simple getter and setter. Super lazy, yes.
-// Assumes userdata is a pointer to actual data. Maybe not really safe.
-#define UDATALIB_SIMPLE_GETTER(type, pushf) \
-{ \
-    type *field; \
-    UDATALIB_GETFIELD(type, field) \
-    pushf(L, *field); \
-    return 1; \
-}
-
-#define UDATALIB_SIMPLE_SETTER(type, checkf) \
-{ \
-    type *field; \
-    UDATALIB_GETFIELD(type, field) \
-    *field = checkf(L, 2); \
-    return 0; \
-}
-
-#endif

src/m_argv.c

@@ -13,6 +13,12 @@
 
 #include <string.h>
 
+#ifdef HAVE_THREADS
+#define local_for_thread _Thread_local
+#else
+#define local_for_thread
+#endif
+
 #include "doomdef.h"
 #include "command.h"
 #include "m_argv.h"
@@ -31,8 +37,11 @@ char **myargv = NULL;
 boolean myargmalloc = false;
 
 /**	\brief founded the parm
+ *
+ * thread_local because it can potentially be used from multiple threads (global variables aaaaaa)
+ * (myargc and myargv don't have to be thread_local because they are never modified after being set up)
 */
-static INT32 found;
+static local_for_thread INT32 found;
 
 
 /**	\brief	The M_CheckParm function
@@ -91,7 +100,7 @@ INT32 M_CheckProtoParam(const char *check)
 const char *M_GetProtoParam(void)
 {
 	INT32 i;
-	static char *string;
+	char *string;
 
 	for (i = 1; i < myargc; i++)
 	{

src/m_menu.c

@@ -809,7 +809,7 @@ static void M_ChangeCvar(INT32 choice)
 		{
 			INT32 skinno = R_SkinAvailable(cv_chooseskin.string);
 			if (skinno != -1)
-				CV_SetValue(cv,skins[skinno]->prefcolor);
+				CV_SetValue(cv,skins[skinno].prefcolor);
 			return;
 		}
 
@@ -2851,11 +2851,11 @@ static void M_PatchSkinNameTable(void)
 
 	memset(skins_cons_t, 0, sizeof (skins_cons_t));
 
-	for (j = 0; j < numskins; j++)
+	for (j = 0; j < MAXSKINS; j++)
 	{
-		if (skins[j]->name[0] != '\0')
+		if (skins[j].name[0] != '\0')
 		{
-			skins_cons_t[j].strvalue = skins[j]->name;
+			skins_cons_t[j].strvalue = skins[j].name;
 			skins_cons_t[j].value = j+1;
 		}
 		else
@@ -3984,6 +3984,14 @@ menudemo_t *demolist = NULL; // Replays that that have been checked to match wit
 menudemo_t *demolist_all = NULL; // All replays
 size_t demolist_all_size = 0;
 boolean replaynamesloaded = false;
+// Whenever we start a replay load thread, we increment this number and then thread will remember current value,
+// and by the end it will compare it with current value, and if it is equal it means thread can store data it has loaded.
+// If it's not equal, that means we started more than one thread (left and re-entered menu for example)
+size_t replaythreadnum = 0;
+
+// for replay dates
+#include <locale.h>
+const char *demodateformat = "%d.%m.%Y";
 
 #ifdef HAVE_THREADS
 I_mutex replayquerymutex;
@@ -4013,12 +4021,15 @@ static SINT8 replayScrollDelay = TICRATE, replayScrollDir = 1;
 
 static void ReplayNamesLoadThread(void* userdata)
 {
+	(void)userdata;
+
 	Lock_search_state();
 
 	size_t demolist_all_size_local = demolist_all_size;
 	menudemo_t *demolist_all_local = (menudemo_t*)malloc(sizeof(menudemo_t)*demolist_all_size_local);
 	memcpy(demolist_all_local, demolist_all, sizeof(menudemo_t)*demolist_all_size_local);
-	char *replaydirpath = (char*)userdata;
+	size_t localreplaythreadnum = replaythreadnum;
+	const char *localdemodateformat = demodateformat;
 
 	Unlock_search_state();
 
@@ -4026,19 +4037,13 @@ static void ReplayNamesLoadThread(void* userdata)
 	{
 		if (demolist_all_local[i].type != MD_SUBDIR)
 		{
-			G_LoadDemoTitle(&demolist_all_local[i]);
-
-			// this is fucking horrid, but i wanna be able to search for dates
-			/*if (demolist_all_local[i].date[0] != '\0')
-			{
-				snprintf(demolist_all_local[i].title, sizeof(demolist_all_local[i].title), "%s %s", demolist_all_local[i].title, demolist_all_local[i].date);
-			}*/
+			G_LoadDemoTitle(&demolist_all_local[i], localdemodateformat);
 		}
 	}
 
 	Lock_search_state();
 
-	if (fastcmp(menupath, replaydirpath) && demolist_all)
+	if (replaythreadnum == localreplaythreadnum && demolist_all)
 	{
 		memcpy(demolist_all, demolist_all_local, sizeof(menudemo_t)*demolist_all_size);
 		replaynamesloaded = true;
@@ -4047,22 +4052,32 @@ static void ReplayNamesLoadThread(void* userdata)
 	Unlock_search_state();
 
 	// Was allocated before thread start, we need to free it
-	free(replaydirpath);
 	free(demolist_all_local);
 }
 
 static void LoadReplayNames(void)
 {
-	char *replaydirpath = strdup(menupath);
-
 	Lock_search_state();
+	replaythreadnum++;
 	replaynamesloaded = false;
+	if (cv_demodateformat.value == 2)
+		demodateformat = "%m.%d.%Y";
+	else if (cv_demodateformat.value == 1)
+		demodateformat = "%d.%m.%Y";
+	else
+	{
+		// get the date format here
+		// setlocale reads/writes global state
+		const char *locale = setlocale(LC_TIME, NULL);
+		// US ppl are special (:
+		demodateformat = (locale && strstr(locale, "en_US")) ? "%m.%d.%Y" : "%d.%m.%Y";
+	}
 	Unlock_search_state();
 
 #ifdef HAVE_THREADS
-	I_spawn_thread("replay-names-load", ReplayNamesLoadThread, replaydirpath);
+	I_spawn_thread("replay-names-load", ReplayNamesLoadThread, NULL);
 #else
-	ReplayNamesLoadThread(replaydirpath);
+	ReplayNamesLoadThread(NULL);
 #endif
 }
 
@@ -4101,8 +4116,12 @@ static void M_HutCheckReplays(size_t maxnum)
 		// Mark as done
 		replayqueryfound = replayquerycheck = sizedirmenu;
 
+		Lock_search_state();
+
 		memcpy(demolist, demolist_all, sizeof(menudemo_t) * sizedirmenu);
 
+		Unlock_search_state();
+
 		return;
 	}
 
@@ -4251,13 +4270,15 @@ static boolean M_HandleReplayHutQuery(INT32 choice)
 	char tmp[MAXREPLAYQUERY+1];
 	memcpy(tmp, replayqueryinput_buffer, MAXREPLAYQUERY+1);
 
-	Lock_search_state();
+	// Honestly not sure if locks for replaynamesloaded are necessary...
+	// Thread sanitizer does report race condition whenever replaynamesloaded is accessed without lock
+	// but really it is only ever set to false in main thread and only set to true in replay load thread,
+	// and both are done via locks. If replaynamesloaded is true, it is never gonna suddenly switch from true to false
+	// while we're in main thread, and if it would switch from false to true it is not really a big deal, we will just skip
+	// 1 frame where replay names were loaded
+
 	if (!replaynamesloaded)
-	{
-		Unlock_search_state();
 		return false;
-	}
-	Unlock_search_state();
 
 	if (M_TextInputHandle(&replayqueryinput, choice))
 	{
@@ -4543,9 +4564,9 @@ static void DrawReplayHutReplayInfo(void)
 			}
 
 			// Character face!
-			if (replaydemolist->standings[0].skin < numskins && W_CheckNumForName(skins[replaydemolist->standings[0].skin]->facewant) != LUMPERROR)
+			if (replaydemolist->standings[0].skin < numskins && W_CheckNumForName(skins[replaydemolist->standings[0].skin].facewant) != LUMPERROR)
 			{
-				patch = skins[replaydemolist->standings[0].skin]->facewantprefix;
+				patch = facewantprefix[replaydemolist->standings[0].skin];
 				colormap = R_GetTranslationColormap(
 					replaydemolist->standings[0].skin,
 					replaydemolist->standings[0].color,
@@ -4766,9 +4787,9 @@ static void M_DrawReplayStartMenu(void)
 			V_DrawString(BASEVIDWIDTH-92, STARTY + i*20 + 9, V_SNAPTOTOP, va("%d", timeorscore));
 
 		// Character face!
-		if (replaydemolist->standings[i].skin < numskins && W_CheckNumForName(skins[replaydemolist->standings[i].skin]->facerank) != LUMPERROR)
+		if (replaydemolist->standings[i].skin < numskins && W_CheckNumForName(skins[replaydemolist->standings[i].skin].facerank) != LUMPERROR)
 		{
-			patch = skins[replaydemolist->standings[i].skin]->facerankprefix;
+			patch = facerankprefix[replaydemolist->standings[i].skin];
 			colormap = R_GetTranslationColormap(
 				replaydemolist->standings[i].skin,
 				replaydemolist->standings[i].color,
@@ -4957,15 +4978,13 @@ static void M_DrawPlaybackMenu(void)
 
 		if (i >= playback_view1 && i <= playback_view4)
 		{
-			if (modeattacking)
-				continue;
+			if (modeattacking) continue;
 
 			if (splitscreen >= i - playback_view1)
 			{
 				INT32 ply = displayplayers[i - playback_view1];
 
-				icon = skins[players[ply].skin]->facerankprefix;
-
+				icon = facerankprefix[players[ply].skin];
 				if (i != itemOn)
 					inactivemap = R_GetTranslationColormap(players[ply].skin, players[ply].skincolor, GTC_MENUCACHE);
 			}
@@ -6251,17 +6270,17 @@ void M_DrawTimeAttackMenu(void)
 	SHOWMODDEDGAME
 
 	const INT32 skinnum = max(cv_chooseskin.value-1, 0); // dont think its needed but better safe than sorry!
-	const skin_t *skin = skins[skinnum];
+	const skin_t *skin = &skins[skinnum];
 
 	// Character face!
 	if (W_CheckNumForName(skin->facewant) != LUMPERROR)
 	{
-		const INT32 charx = (BASEVIDWIDTH-x - skins[skinnum]->facewantprefix->width);
+		const INT32 charx = (BASEVIDWIDTH-x - facewantprefix[skinnum]->width);
 
 		UINT8 *colormap = NULL;
 
 		colormap = R_GetTranslationColormap(skinnum, cv_playercolor.value, GTC_MENUCACHE);
-		V_DrawMappedPatch(charx, y, 0, skins[skinnum]->facewantprefix, colormap);
+		V_DrawMappedPatch(charx, y, 0, facewantprefix[skinnum], colormap);
 
 		// draw stats
 		// speed
@@ -7709,7 +7728,7 @@ static void M_DrawMPMainMenu(void)
 					break;
 			}
 
-			if (pskin >= numskins)
+			if (pskin >= MAXSKINS)
 				pskin = 0;
 
 			if (!trans && i > cv_splitplayers.value)
@@ -7717,7 +7736,7 @@ static void M_DrawMPMainMenu(void)
 
 			colmap = R_GetTranslationColormap(pskin, pcol, GTC_MENUCACHE);
 
-			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT, trans, skins[pskin]->facewantprefix, colmap);
+			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT, trans, facewantprefix[pskin], colmap);
 
 			if (itemOn == 2 && i == setupm_pselect)
 			{
@@ -7978,12 +7997,12 @@ static void M_DrawSetupMultiPlayerMenu(void)
 	else
 		M_DrawTextInput(mx + 40, my + nameboxaddy, &setupm_input, 0);
 
-#define GETSELECTEDSKINNAME (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]]->realname : skins[setupm_fakeskin]->realname)
-#define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]]->kartspeed : skins[setupm_fakeskin]->kartspeed)
-#define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]]->kartweight : skins[setupm_fakeskin]->kartweight)
+#define GETSELECTEDSKINNAME (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].realname : skins[setupm_fakeskin].realname)
+#define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartspeed : skins[setupm_fakeskin].kartspeed)
+#define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartweight : skins[setupm_fakeskin].kartweight)
 
 	// draw skin string
-	st = V_StringWidth(skins[setupm_fakeskin]->realname, 0);
+	st = V_StringWidth(skins[setupm_fakeskin].realname, 0);
 	switch (cv_skinselectmenu.value)
 	{
 		case SKINMENUTYPE_EXTENDED:
@@ -8005,10 +8024,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
 				skintodisplay = skinstats[setupm_skinxpos][setupm_skinypos][(I_GetTime()/TICRATE)%SELECTEDSTATSCOUNT];
 
 			tw = V_StringWidth("Character", 0);
-			st = V_StringWidth(skins[skintodisplay]->realname, 0);
+			st = V_StringWidth(skins[skintodisplay].realname, 0);
 			V_DrawString((mx+(tw/2)) - (st/2), my + 37,
 				((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE,
-				skins[skintodisplay]->realname);
+				skins[skintodisplay].realname);
 			// the menu is now 2d, no need for scroll arrows...
 			if (itemOn == 1 && setupm_skinlockedselect)
 			{
@@ -8022,7 +8041,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 		default:
 			V_DrawString(BASEVIDWIDTH - mx - st, my + 16,
 						((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0)|highlightflags|V_ALLOWLOWERCASE,
-						skins[setupm_fakeskin]->realname);
+						skins[setupm_fakeskin].realname);
 			if (itemOn == 1)
 			{
 				V_DrawCharacter(BASEVIDWIDTH - mx - 10 - st - (skullAnimCounter/5), my + 16,
@@ -8128,10 +8147,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
 
 			for (i = 0; i < numskins; i++) // draw the stat dots
 			{
-				if (i != setupm_fakeskin && R_SkinAvailable(skins[i]->name) != -1)
+				if (i != setupm_fakeskin && R_SkinAvailable(skins[i].name) != -1)
 				{
-					speed = skins[i]->kartspeed;
-					weight = skins[i]->kartweight;
+					speed = skins[i].kartspeed;
+					weight = skins[i].kartweight;
 					V_DrawFixedPatch((((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1), (((staty+71) + (weight*4))<<FRACBITS), FRACUNIT>>1, 0, statdot, NULL);
 				}
 			}
@@ -8187,10 +8206,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
 
 			for (i = 0; i < numskins; i++) // draw the stat dots
 			{
-				if (i != setupm_fakeskin && R_SkinAvailable(skins[i]->name) != -1)
+				if (i != setupm_fakeskin && R_SkinAvailable(skins[i].name) != -1)
 				{
-					speed = skins[i]->kartspeed;
-					weight = skins[i]->kartweight;
+					speed = skins[i].kartspeed;
+					weight = skins[i].kartweight;
 					V_DrawFixedPatch(((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS, ((my+76) + ((weight-1)*8))<<FRACBITS, FRACUNIT, 0, statdot, NULL);
 				}
 			}
@@ -8224,8 +8243,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					continue;
 				}
 
-				face = skins[skinn]->facerankprefix;
-				cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
+				face = facerankprefix[skinn];
+				cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
 
 				V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 			}
@@ -8262,8 +8281,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					continue;
 				}
 
-				face = skins[skinn]->facerankprefix;
-				cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
+				face = facerankprefix[skinn];
+				cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
 
 				V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 			}
@@ -8277,7 +8296,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 				if (setupm_skinselect < numskins)
 				{
 					const UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
-					cursor = skins[skinsorted[setupm_skinselect]]->facewantprefix;
+					cursor = facewantprefix[skinsorted[setupm_skinselect]];
 					V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
 				}
 				else
@@ -8291,8 +8310,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			{ // stat dot
 				const INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
 
-				speed = skins[selectedskin]->kartspeed;
-				weight = skins[selectedskin]->kartweight;
+				speed = skins[selectedskin].kartspeed;
+				weight = skins[selectedskin].kartweight;
 
 				const INT32 x = (((statx+46) + (speed*4))<<FRACBITS) + (FRACUNIT>>1);
 				const INT32 y = (((staty+71) + (weight*4))<<FRACBITS);
@@ -8331,8 +8350,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					}
 
 					skinn = skinstats[s][w][(I_GetTime() / TICRATE) % skinstatscount[s][w]];
-					face = skins[skinn]->facerankprefix;
-					cmap = R_GetTranslationColormap(skinn, skins[skinn]->prefcolor, GTC_MENUCACHE);
+					face = facerankprefix[skinn];
+					cmap = R_GetTranslationColormap(skinn, skins[skinn].prefcolor, GTC_MENUCACHE);
 
 					V_DrawFixedPatch(x << FRACBITS, y << FRACBITS, FRACUNIT, 0, face, cmap);
 				}
@@ -8349,7 +8368,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 					const UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
 					const INT32 skinn = skinstats[setupm_skinxpos][setupm_skinypos][(I_GetTime() / TICRATE) % skinstatscount[setupm_skinxpos][setupm_skinypos]];
 
-					cursor = skins[skinn]->facewantprefix;
+					cursor = facewantprefix[skinn];
 					V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
 				}
 				else
@@ -8363,8 +8382,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
 #undef SKINXSHIFT
 		default:
 			{
-				speed = skins[setupm_fakeskin]->kartspeed;
-				weight = skins[setupm_fakeskin]->kartweight;
+				speed = skins[setupm_fakeskin].kartspeed;
+				weight = skins[setupm_fakeskin].kartweight;
 
 				const INT32 x = ((BASEVIDWIDTH - mx - 80) + ((speed-1)*8))<<FRACBITS;
 				const INT32 y = ((my+76) + ((weight-1)*8))<<FRACBITS;
@@ -8448,14 +8467,14 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			if (!(k++))
 			{
 				scale = FRACUNIT;
-				face = skins[col]->facewantprefix;
+				face = facewantprefix[col];
 				offx = 12;
 				offy = 0;
 			}
 			else
 			{
 				scale = FRACUNIT/2;
-				face = skins[col]->facerankprefix;
+				face = facerankprefix[col];
 				offx = 8;
 				offy = 8;
 			}
@@ -8509,15 +8528,15 @@ static void M_DrawSetupMultiPlayerMenu(void)
 			break;
 	}
 
-	if (skintodisplay >= numskins)
+	if (skintodisplay >= MAXSKINS)
 		skintodisplay = 0;
 
-	skinnum = R_SkinAvailable(skins[skintodisplay]->name);
+	skinnum = R_SkinAvailable(skins[skintodisplay].name);
 
-	if (skinnum < 0 || skinnum >= numskins)
+	if (skinnum < 0 || skinnum >= MAXSKINS)
 		skinnum = 0;
 
-	sprdef = &skins[skinnum]->spritedef;
+	sprdef = &skins[skinnum].spritedef;
 
 	if (!sprdef->numframes) // No frames ??
 		return; // Can't render!
@@ -8535,7 +8554,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
 	{
 		UINT8 *colormap = R_GetTranslationColormap(skintodisplay, setupm_fakecolor, GTC_MENUCACHE);
 #ifdef HWRENDER
-		md2_t *md2 = &skins[skinnum]->playermodel;
+		md2_t *md2 = &md2_playermodels[skinnum];
 #endif
 		mx += 36;
 		my += 131;
@@ -8566,11 +8585,11 @@ static void M_DrawSetupMultiPlayerMenu(void)
 
 			patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
 
-			if (skins[skintodisplay]->flags & SF_HIRES)
+			if (skins[skintodisplay].flags & SF_HIRES)
 			{
 				V_DrawFixedPatch(mx<<FRACBITS,
 								 my<<FRACBITS,
-								 skins[skintodisplay]->highresscale,
+								 skins[skintodisplay].highresscale,
 								 flags, patch, colormap);
 			}
 			else
@@ -8877,7 +8896,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
 			}
 			else if (itemOn == 2)
 			{
-				UINT8 col = skins[setupm_fakeskin]->prefcolor;
+				UINT8 col = skins[setupm_fakeskin].prefcolor;
 				if (setupm_fakecolor != col)
 				{
 					S_StartSound(NULL, sfx_menu1); // Tails
@@ -9100,7 +9119,7 @@ static boolean M_QuitMultiPlayerMenu(void)
 	}
 
 	// you know what? always putting these in the buffer won't hurt anything.
-	COM_BufAddText(va("%s \"%s\"\n", setupm_cvskin->name, skins[setupm_fakeskin]->name));
+	COM_BufAddText(va("%s \"%s\"\n", setupm_cvskin->name, skins[setupm_fakeskin].name));
 	COM_BufAddText(va("%s %d\n", setupm_cvcolor->name, setupm_fakecolor));
 
 	return true;
@@ -9876,7 +9895,7 @@ static void M_DrawLocalSkinMenu(void)
 	UINT8 frame;
 	INT32 skintodisplay = 0;
 	UINT32 speenframe;
-	skin_t *displayskin;
+	skin_t displayskin;
 
 	mx = OP_ForkedBirdDef.x;
 	my = OP_ForkedBirdDef.y;
@@ -9918,7 +9937,7 @@ static void M_DrawLocalSkinMenu(void)
 
 	displayskin = allskins[skintodisplay];
 
-	sprdef = &displayskin->spritedef;
+	sprdef = &displayskin.spritedef;
 
 	if (!sprdef->numframes) // No frames ??
 		return; // Can't render!
@@ -9931,25 +9950,25 @@ static void M_DrawLocalSkinMenu(void)
 	V_DrawFill(mx + 220 - (charw/2), my+54, charw, 84, 239);
 #undef charw
 
-	// FIXME: is using just "skins" array even correct?
-	UINT8 *colormap = R_GetLocalTranslationColormap(skins[displayskin->skinnum], (displayskin->localskin ? localskins[displayskin->skinnum] : NULL), cv_playercolor.value, GTC_MENUCACHE, displayskin->localskin);
+	// FIXME: is skins[displayskin.localnum] even correct?
+	UINT8 *colormap = R_GetLocalTranslationColormap(&skins[displayskin.localnum], (displayskin.localskin ? &localskins[displayskin.localnum] : NULL), cv_playercolor.value, GTC_MENUCACHE, displayskin.localskin);
 
-	V_DrawMappedPatch(mx, my+50, 0, (patch_t *)W_CachePatchName(displayskin->facewant, PU_PATCH), colormap);
-	V_DrawMappedPatch(mx+8, my+85, 0, (patch_t *)W_CachePatchName(displayskin->facerank, PU_PATCH), colormap);
+	V_DrawMappedPatch(mx, my+50, 0, (patch_t *)W_CachePatchName(displayskin.facewant, PU_PATCH), colormap);
+	V_DrawMappedPatch(mx+8, my+85, 0, (patch_t *)W_CachePatchName(displayskin.facerank, PU_PATCH), colormap);
 
 	V_DrawString(mx, my+108, V_ALLOWLOWERCASE, "Character");
 
-	if (strlen(displayskin->realname) > 10)
-		V_DrawThinString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin->realname);
+	if (strlen(displayskin.realname) > 10)
+		V_DrawThinString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin.realname);
 	else
-		V_DrawString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin->realname);
+		V_DrawString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin.realname);
 
 	// draw player sprite
 	mx += 220;
 	my += 120;
 
 #ifdef HWRENDER
-	md2_t *md2 = &displayskin->playermodel;
+	md2_t *md2 = (displayskin.localskin ? &md2_localplayermodels[displayskin.localnum] : &md2_playermodels[skintodisplay]);
 
 	// if we have 3d models enabled and a model exists
 	// try to show it instead of the sprite
@@ -9977,9 +9996,9 @@ static void M_DrawLocalSkinMenu(void)
 
 		patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
 
-		if (displayskin->flags & SF_HIRES)
+		if (displayskin.flags & SF_HIRES)
 		{
-			V_DrawFixedPatch(mx<<FRACBITS, my<<FRACBITS, displayskin->highresscale, flags, patch, colormap);
+			V_DrawFixedPatch(mx<<FRACBITS, my<<FRACBITS, displayskin.highresscale, flags, patch, colormap);
 		}
 		else
 		{

src/p_enemy.c

@@ -2312,7 +2312,7 @@ void A_1upThinker(void *thing)
 		}
 	}
 
-	if (closestplayer == -1 || skins[players[closestplayer].skin]->spritedef.numframes <= states[S_PLAY_BOX1].frame)
+	if (closestplayer == -1 || skins[players[closestplayer].skin].spritedef.numframes <= states[S_PLAY_BOX1].frame)
 	{ // Closest player not found (no players in game?? may be empty dedicated server!), or does not have correct sprite.
 		actor->frame = 0;
 
@@ -2337,7 +2337,7 @@ void A_1upThinker(void *thing)
 	}
 
 	actor->tracer->color = players[closestplayer].mo->color;
-	actor->tracer->skin = skins[players[closestplayer].skin];
+	actor->tracer->skin = &skins[players[closestplayer].skin];
 }
 
 // Function: A_MonitorPop
@@ -2436,7 +2436,7 @@ void A_MonitorPop(void *thing)
 				if (actor->tracer) // Remove the old lives icon.
 					P_RemoveMobj(actor->tracer);
 
-				if (!newmobj->target->skin || newmobj->target->skin->spritedef.numframes <= states[S_PLAY_BOX1].frame)
+				if (!newmobj->target->skin || ((skin_t *)newmobj->target->skin)->spritedef.numframes <= states[S_PLAY_BOX1].frame)
 					newmobj->frame -= 2; // No lives icon for this player, use the default.
 				else
 				{ // Spawn the lives icon.
@@ -2448,7 +2448,7 @@ void A_MonitorPop(void *thing)
 						P_SetTarget(&newmobj->tracer, remains);
 
 						remains->color = newmobj->target->player->mo->color;
-						remains->skin = skins[newmobj->target->player->skin];
+						remains->skin = &skins[newmobj->target->player->skin];
 						P_SetMobjState(remains, newmobj->info->seestate);
 					}
 				}
@@ -3995,14 +3995,14 @@ void A_SignPlayer(void *thing)
 
 	P_SetTarget(&ov->target, actor);
 	ov->color = actor->target->player->skincolor;
-	ov->skin = skins[actor->target->player->skin];
+	ov->skin = &skins[actor->target->player->skin];
 
 	// needs - 1 or else it pukes an error out
 	// same thing happens on p_mobj.c
 	if (actor->target->skinlocal)
-		ov->localskin = localskins[actor->target->player->localskin - 1];
+		ov->localskin = &localskins[actor->target->player->localskin - 1];
 	else if (actor->target->player->localskin)
-		ov->localskin = skins[actor->target->player->localskin - 1];
+		ov->localskin = &skins[actor->target->player->localskin - 1];
 	ov->skinlocal = actor->target->skinlocal;
 
 	P_SetMobjState(ov, actor->info->seestate); // S_PLAY_SIGN

src/p_mobj.c

@@ -6154,7 +6154,7 @@ angle_t P_MobjPitchAndRoll(mobj_t *mobj)
 
 	if (mobj->skin && mobj->sprite == SPR_PLAY)
 	{
-		sprdef = &mobj->skin->spritedef;
+		sprdef = &((skin_t *)mobj->skin)->spritedef;
 
 		if (rot >= sprdef->numframes)
 			sprdef = &sprites[mobj->sprite];
@@ -9187,6 +9187,12 @@ static boolean P_MobjPushableThink(mobj_t *mobj)
 
 static void P_FiringThink(mobj_t *mobj)
 {
+	if (!mobj->target)
+		return;
+
+	if (mobj->health <= 0)
+		return;
+
 	if (mobj->state->action == (actionf_p1)A_Boss1Laser)
 	{
 		var1 = mobj->state->var1;
@@ -9249,7 +9255,12 @@ void P_MobjThinker(mobj_t *mobj)
 	mobj->flags2 &= ~MF2_PUSHED;
 	mobj->eflags &= ~(MFE_SPRUNG|MFE_JUSTBOUNCEDWALL);
 
+#ifdef PHOBOS_BUILD
+	P_SetTarget(&tmfloorthing, NULL);
+	P_SetTarget(&tmhitthing, NULL);
+#else
 	tmfloorthing = tmhitthing = NULL;
+#endif
 
 	// do NOT trigger linedef executors for "local" mobjs
 	if (!mobj->islocal)
@@ -9265,8 +9276,13 @@ void P_MobjThinker(mobj_t *mobj)
 	}
 
 	if (mobj->scale != mobj->destscale)
+	{
 		P_MobjScaleThink(mobj); // Slowly scale up/down to reach your destscale.
 
+		if (P_MobjWasRemovedCompat(mobj))
+			return;
+	}
+
 	if (!mobj->player)
 	{
 		if (mobj->type == MT_GHOST && mobj->fuse > 0 // Not guaranteed to be MF_SCENERY or not MF_SCENERY!
@@ -9311,6 +9327,21 @@ void P_MobjThinker(mobj_t *mobj)
 	{
 		if (!P_MobjDeadThink(mobj))
 			return;
+
+		// Fading tile
+		if (mobj->type >= MT_BOUNCEPICKUP && mobj->type <= MT_GRENADEPICKUP)
+		{
+			INT32 value = mobj->info->damage/10;
+			value = mobj->fuse/value;
+			value = 10-value;
+			value--;
+
+			if (value <= 0)
+				value = 1;
+
+			mobj->frame &= ~FF_TRANSMASK;
+			mobj->frame |= value << FF_TRANSSHIFT;
+		}
 	}
 	else
 	{
@@ -9321,7 +9352,7 @@ void P_MobjThinker(mobj_t *mobj)
 	if (P_MobjWasRemoved(mobj))
 		return;
 
-	if (mobj->flags2 & MF2_FIRING && mobj->target && mobj->health > 0)
+	if (mobj->flags2 & MF2_FIRING)
 		P_FiringThink(mobj);
 
 	if (mobj->flags & MF_AMBIENT)
@@ -9388,23 +9419,27 @@ void P_MobjThinker(mobj_t *mobj)
 		P_ButteredSlope(mobj);
 	}
 
-	if (mobj->flags & (MF_ENEMY|MF_BOSS) && mobj->health &&
-		P_CheckDeathPitCollide(mobj)) // extra pit check in case these didn't have momz
+	if (mobj->health)
 	{
-		P_KillMobj(mobj, NULL, NULL);
-		return;
-	}
-
-	// Crush enemies!
-	if (mobj->ceilingz - mobj->floorz < mobj->height)
-	{
-		if (((mobj->flags & (MF_ENEMY|MF_BOSS) && mobj->flags & MF_SHOOTABLE) || mobj->type == MT_EGGSHIELD) &&
-			!(mobj->flags & MF_NOCLIPHEIGHT) &&
-			  mobj->health > 0)
+		// extra pit check in case these didn't have momz
+		if ((mobj->flags & (MF_ENEMY|MF_BOSS)) &&
+			P_CheckDeathPitCollide(mobj))
 		{
 			P_KillMobj(mobj, NULL, NULL);
 			return;
 		}
+
+		// Crush enemies!
+		if ((mobj->ceilingz - mobj->floorz) < mobj->height)
+		{
+			if ((((mobj->flags & (MF_ENEMY|MF_BOSS)) && (mobj->flags & MF_SHOOTABLE)) || mobj->type == MT_EGGSHIELD) &&
+				!(mobj->flags & MF_NOCLIPHEIGHT) &&
+				  mobj->health > 0)
+			{
+				P_KillMobj(mobj, NULL, NULL);
+				return;
+			}
+		}
 	}
 
 	if (P_MobjWasRemovedCompat(mobj))
@@ -9412,24 +9447,6 @@ void P_MobjThinker(mobj_t *mobj)
 
 	// Can end up here if a player dies.
 	P_CycleMobjState(mobj);
-
-	if (P_MobjWasRemoved(mobj))
-		return;
-
-	if ((mobj->health == 0) && // Fading tile
-		(mobj->type >= MT_BOUNCEPICKUP && mobj->type <= MT_GRENADEPICKUP))
-	{
-		INT32 value = mobj->info->damage/10;
-		value = mobj->fuse/value;
-		value = 10-value;
-		value--;
-
-		if (value <= 0)
-			value = 1;
-
-		mobj->frame &= ~FF_TRANSMASK;
-		mobj->frame |= value << FF_TRANSSHIFT;
-	}
 }
 
 // Quick, optimized function for the Rail Rings
@@ -9683,20 +9700,13 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
 
 	// All mobjs are created at 100% scale.
 	mobj->scale = FRACUNIT;
-	mobj->destscale = mobj->scale;
-	mobj->scalespeed = FRACUNIT/12;
-
-	if (mapobjectscale != FRACUNIT) //&& !(mobj->type == MT_BLACKEGGMAN)
-	{
-		mobj->destscale = mapobjectscale;
-		mobj->scalespeed = mapobjectscale/12;
-	}
+	mobj->destscale = mapobjectscale;
+	mobj->scalespeed = mapobjectscale/12;
 
 	// Sprite rendering
 	mobj->blendmode = AST_TRANSLUCENT;
-	mobj->realxscale = mobj->realyscale = mobj->scale;
-	mobj->spritexscale = mobj->realxscale;
-	mobj->spriteyscale = mobj->realyscale;
+	mobj->realxscale = mobj->realyscale =
+	mobj->spritexscale = mobj->spriteyscale = mobj->scale;
 
 	// set subsector and/or block links
 	P_SetThingPosition(mobj);
@@ -10138,20 +10148,13 @@ mobj_t *P_SpawnShadowMobj(mobj_t * caster)
 
 	// All mobjs are created at 100% scale.
 	mobj->scale = FRACUNIT;
-	mobj->destscale = mobj->scale;
-	mobj->scalespeed = FRACUNIT/12;
-
-	if (mapobjectscale != FRACUNIT) //&& !(mobj->type == MT_BLACKEGGMAN)
-	{
-		mobj->destscale = mapobjectscale;
-		mobj->scalespeed = mapobjectscale/12;
-	}
+	mobj->destscale = mapobjectscale;
+	mobj->scalespeed = mapobjectscale/12;
 
 	// Sprite rendering
 	mobj->blendmode = AST_TRANSLUCENT;
-	mobj->realxscale = mobj->realyscale = mobj->scale;
-	mobj->spritexscale = mobj->realxscale;
-	mobj->spriteyscale = mobj->realyscale;
+	mobj->realxscale = mobj->realyscale =
+	mobj->spritexscale = mobj->spriteyscale = mobj->scale;
 
 	// set subsector and/or block links
 	P_SetThingPosition(mobj);
@@ -10251,7 +10254,9 @@ static precipmobj_t *P_SpawnPrecipMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype
 	P_CalculatePrecipFloor(mobj);
 
 	if (mobj->floorz != starting_floorz)
-		mobj->precipflags |= PCF_FOF;
+	{
+		; //mobj->precipflags |= PCF_FOF;
+	}
 	else
 	{
 		const INT32 special = GETSECSPECIAL(mobj->subsector->sector->special, 1);
@@ -10385,7 +10390,13 @@ void P_RemoveMobj(mobj_t *mobj)
 
 	// clear the reference from the mapthing
 	if (mobj->spawnpoint)
+	{
+#ifdef PHOBOS_BUILD
+		P_SetTarget(&mobj->spawnpoint->mobj, NULL);
+#else
 		mobj->spawnpoint->mobj = NULL;
+#endif
+	}
 
 	R_RemoveMobjInterpolator(mobj);
 
@@ -10596,6 +10607,9 @@ void P_PrecipitationEffects(void)
 				P_SpawnLightningFlash(ss); // Spawn a quick flash thinker
 	}
 
+	if (sound_disabled)
+		return; // Sound off? D'aw, no fun.
+
 	const mobj_t *pmo = players[displayplayers[0]].mo;
 
 	// Local effects from here on out!
@@ -10603,9 +10617,6 @@ void P_PrecipitationEffects(void)
 	if (!playeringame[displayplayers[0]] || !pmo)
 		return;
 
-	if (sound_disabled)
-		return; // Sound off? D'aw, no fun.
-
 	const boolean sounds_rain = ((cv_drawdist_precip.value != 0) && rainsfx && (!leveltime || leveltime % 80 == 1));
 
 	if (!sounds_rain && !sounds_thunder)
@@ -10853,7 +10864,9 @@ void P_SpawnPlayer(INT32 playernum)
 	mobj_t *mobj;
 
 	if (p->playerstate == PST_REBORN)
+	{
 		G_PlayerReborn(playernum);
+	}
 
 	for (i = 0; i < MAXPLAYERS; i++)
 	{
@@ -10927,9 +10940,15 @@ void P_SpawnPlayer(INT32 playernum)
 	}
 
 	mobj = P_SpawnMobj(0, 0, 0, MT_PLAYER);
+
 	I_Assert(mobj != NULL);
+
+#ifdef PHOBOS_BUILD
+	mobj->player = p;
+	P_SetTarget(&p->mo, mobj);
+#else
 	(mobj->player = p)->mo = mobj;
-	//P_SetTarget(&p->mo, mobj);
+#endif
 
 	mobj->angle = mobj->old_angle = 0;
 
@@ -10939,9 +10958,9 @@ void P_SpawnPlayer(INT32 playernum)
 	// set 'spritedef' override in mobj for player skins.. (see ProjectSprite)
 	// (usefulness: when body mobj is detached from player (who respawns),
 	// the dead body mobj retains the skin through the 'spritedef' override).
-	mobj->skin = skins[p->skin];
+	mobj->skin = &skins[p->skin];
 
-	mobj->localskin = (p->localskin ? R_GetPlayerSkin(p) : NULL);
+	mobj->localskin = (p->localskin ? K_GetPlayerSkin(p) : NULL);
 	mobj->skinlocal = p->skinlocal;
 
 	mobj->health = p->health;

src/p_mobj.h

@@ -258,17 +258,13 @@ typedef enum
 // PRECIPITATION flags ?! ?! ?!
 //
 typedef enum {
-	PCF_INVISIBLE = 1, // Don't draw.
+	PCF_INVISIBLE = 1,    // Don't draw.
 	PCF_PIT       = 1<<1, // Above pit.
-	PCF_FOF       = 1<<2, // Above FOF.
-	PCF_MOVINGFOF = 1<<3, // Above MOVING FOF (this means we need to keep floorz up to date...)
-	PCF_SPLASH    = 1<<4, // Splashed on the ground, return to the ceiling after the animation's over
-	PCF_THUNK     = 1<<5, // Ran the thinker this tic.
+	PCF_SPLASH    = 1<<2, // Splashed on the ground, return to the ceiling after the animation's over
+	PCF_THUNK     = 1<<3, // Ran the thinker this tic.
 } precipflag_t;
 
 
-typedef struct skin_s skin_t;
-
 // Map Object definition.
 typedef struct mobj_s
 {
@@ -344,9 +340,9 @@ typedef struct mobj_s
 	struct mobj_s *hnext;
 	struct mobj_s *hprev;
 
-	skin_t *skin; // overrides 'sprite' when non-NULL (for player bodies to 'remember' the skin)
-	skin_t *localskin;
-	boolean skinlocal; // if the skin is from a LOCALLY loaded skin
+	void *skin; // overrides 'sprite' when non-NULL (for player bodies to 'remember' the skin)
+	void *localskin;
+	boolean skinlocal;
 
 	// Player and mobj sprites in multiplayer modes are modified
 	//  using an internal color lookup table for re-indexing.

src/p_saveg.c

@@ -1344,7 +1344,7 @@ static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8
 	if (diff2 & MD2_CVMEM)
 		WRITEINT32(save->p, mobj->cvmem);
 	if (diff2 & MD2_SKIN)
-		WRITESKIN(save->p, (skinnum_t)mobj->skin->skinnum);
+		WRITESKIN(save->p, (skinnum_t)((skin_t *)mobj->skin - skins));
 	if (diff2 & MD2_COLOR)
 		WRITEUINT8(save->p, mobj->color);
 	if (diff2 & MD2_EXTVAL1)
@@ -2221,7 +2221,7 @@ static void LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
 	if (diff2 & MD2_CVMEM)
 		mobj->cvmem = READINT32(save->p);
 	if (diff2 & MD2_SKIN)
-		mobj->skin = skins[READSKIN(save->p)];
+		mobj->skin = &skins[READSKIN(save->p)];
 	if (diff2 & MD2_COLOR)
 		mobj->color = READUINT8(save->p);
 	if (diff2 & MD2_EXTVAL1)

src/p_setup.c

@@ -570,13 +570,13 @@ static void P_LoadSegs(UINT8 *data)
 
 			if (seg->sidedef == &sides[seg->linedef->sidenum[0]])
 			{
-				seg->v1 = lines[ms->linedef].v1;
-				seg->v2 = lines[ms->linedef].v2;
+				seg->v1 = lines[rawlinedef].v1;
+				seg->v2 = lines[rawlinedef].v2;
 			}
 			else
 			{
-				seg->v1 = lines[ms->linedef].v2;
-				seg->v2 = lines[ms->linedef].v1;
+				seg->v1 = lines[rawlinedef].v2;
+				seg->v2 = lines[rawlinedef].v1;
 			}
 		}
 		else
@@ -584,7 +584,6 @@ static void P_LoadSegs(UINT8 *data)
 			seg->v1 = &vertexes[v1];
 			seg->v2 = &vertexes[v2];
 		}
-
 #ifdef HWRENDER
 		if (rendermode == render_opengl)
 		{
@@ -597,7 +596,6 @@ static void P_LoadSegs(UINT8 *data)
 			//seg->fv2.z = FixedToFloat(seg->v2->z);
 		}
 #endif
-
 		seg->length = P_SegLength(seg);
 
 		P_UpdateSegLightOffset(seg);
@@ -2096,6 +2094,13 @@ static void P_LoadMapBSP(const virtres_t* virt)
 	virtlump_t* virtsegs     = vres_Find(virt, "SEGS");
 	virtlump_t* virtnodes    = vres_Find(virt, "NODES");
 
+	if (!virtssectors)
+		I_Error("SSECTORS lump not found");
+	if (!virtsegs)
+		I_Error("SEGS lump not found");
+	if (!virtnodes)
+		I_Error("NODES lump not found");
+
 	numsubsectors = virtssectors->size / sizeof(mapsubsector_t);
 	numnodes      = virtnodes->size    / sizeof(mapnode_t);
 	numsegs       = virtsegs->size     / sizeof(mapseg_t);
@@ -2478,28 +2483,28 @@ static void P_ForceCharacter(const char *forcecharskin)
 		if (splitscreen)
 		{
 			SetPlayerSkin(displayplayers[1], forcecharskin);
-			if ((unsigned)cv_playercolor2.value != skins[players[displayplayers[1]].skin]->prefcolor && !modeattacking)
+			if ((unsigned)cv_playercolor2.value != skins[players[displayplayers[1]].skin].prefcolor && !modeattacking)
 			{
-				CV_StealthSetValue(&cv_playercolor2, skins[players[displayplayers[1]].skin]->prefcolor);
-				players[displayplayers[1]].skincolor = skins[players[displayplayers[1]].skin]->prefcolor;
+				CV_StealthSetValue(&cv_playercolor2, skins[players[displayplayers[1]].skin].prefcolor);
+				players[displayplayers[1]].skincolor = skins[players[displayplayers[1]].skin].prefcolor;
 			}
 
 			if (splitscreen > 1)
 			{
 				SetPlayerSkin(displayplayers[2], forcecharskin);
-				if ((unsigned)cv_playercolor3.value != skins[players[displayplayers[2]].skin]->prefcolor && !modeattacking)
+				if ((unsigned)cv_playercolor3.value != skins[players[displayplayers[2]].skin].prefcolor && !modeattacking)
 				{
-					CV_StealthSetValue(&cv_playercolor3, skins[players[displayplayers[2]].skin]->prefcolor);
-					players[displayplayers[2]].skincolor = skins[players[displayplayers[2]].skin]->prefcolor;
+					CV_StealthSetValue(&cv_playercolor3, skins[players[displayplayers[2]].skin].prefcolor);
+					players[displayplayers[2]].skincolor = skins[players[displayplayers[2]].skin].prefcolor;
 				}
 
 				if (splitscreen > 2)
 				{
 					SetPlayerSkin(displayplayers[3], forcecharskin);
-					if ((unsigned)cv_playercolor4.value != skins[players[displayplayers[3]].skin]->prefcolor && !modeattacking)
+					if ((unsigned)cv_playercolor4.value != skins[players[displayplayers[3]].skin].prefcolor && !modeattacking)
 					{
-						CV_StealthSetValue(&cv_playercolor4, skins[players[displayplayers[3]].skin]->prefcolor);
-						players[displayplayers[3]].skincolor = skins[players[displayplayers[3]].skin]->prefcolor;
+						CV_StealthSetValue(&cv_playercolor4, skins[players[displayplayers[3]].skin].prefcolor);
+						players[displayplayers[3]].skincolor = skins[players[displayplayers[3]].skin].prefcolor;
 					}
 				}
 			}
@@ -2507,10 +2512,10 @@ static void P_ForceCharacter(const char *forcecharskin)
 
 		SetPlayerSkin(consoleplayer, forcecharskin);
 		// normal player colors in single player
-		if ((unsigned)cv_playercolor.value != skins[players[consoleplayer].skin]->prefcolor && !modeattacking)
+		if ((unsigned)cv_playercolor.value != skins[players[consoleplayer].skin].prefcolor && !modeattacking)
 		{
-			CV_StealthSetValue(&cv_playercolor, skins[players[consoleplayer].skin]->prefcolor);
-			players[consoleplayer].skincolor = skins[players[consoleplayer].skin]->prefcolor;
+			CV_StealthSetValue(&cv_playercolor, skins[players[consoleplayer].skin].prefcolor);
+			players[consoleplayer].skincolor = skins[players[consoleplayer].skin].prefcolor;
 		}
 	}
 }
@@ -2537,8 +2542,8 @@ static void P_LoadRecordGhosts(void)
 			if (cv_ghost_besttime.value == 1 && players[consoleplayer].skin != i)
 				continue;
 
-			if (FIL_FileExists(va("%s-%s-time-best.lmp", gpath, skins[i]->name)))
-				G_AddGhost(va("%s-%s-time-best.lmp", gpath, skins[i]->name));
+			if (FIL_FileExists(va("%s-%s-time-best.lmp", gpath, skins[i].name)))
+				G_AddGhost(va("%s-%s-time-best.lmp", gpath, skins[i].name));
 		}
 	}
 
@@ -2550,8 +2555,8 @@ static void P_LoadRecordGhosts(void)
 			if (cv_ghost_bestlap.value == 1 && players[consoleplayer].skin != i)
 				continue;
 
-			if (FIL_FileExists(va("%s-%s-lap-best.lmp", gpath, skins[i]->name)))
-				G_AddGhost(va("%s-%s-lap-best.lmp", gpath, skins[i]->name));
+			if (FIL_FileExists(va("%s-%s-lap-best.lmp", gpath, skins[i].name)))
+				G_AddGhost(va("%s-%s-lap-best.lmp", gpath, skins[i].name));
 		}
 	}
 
@@ -2563,8 +2568,8 @@ static void P_LoadRecordGhosts(void)
 			if (cv_ghost_last.value == 1 && players[consoleplayer].skin != i)
 				continue;
 
-			if (FIL_FileExists(va("%s-%s-last.lmp", gpath, skins[i]->name)))
-				G_AddGhost(va("%s-%s-last.lmp", gpath, skins[i]->name));
+			if (FIL_FileExists(va("%s-%s-last.lmp", gpath, skins[i].name)))
+				G_AddGhost(va("%s-%s-last.lmp", gpath, skins[i].name));
 		}
 	}
 

src/p_spec.c

@@ -1962,13 +1962,19 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
 					if (!dest)
 						return;
 
+					const angle_t ang = (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle;
+					const boolean dontstopmove = (line->flags & ML_EFFECT4) == ML_EFFECT4;
+
 					if (bot)
-						P_Teleport(bot, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, (line->flags & ML_BLOCKMONSTERS) == 0, (line->flags & ML_EFFECT4) == ML_EFFECT4);
+						P_Teleport(bot, dest->x, dest->y, dest->z, ang, (line->flags & ML_BLOCKMONSTERS) == 0, dontstopmove);
+
 					if (line->flags & ML_BLOCKMONSTERS)
-						P_Teleport(mo, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, false, (line->flags & ML_EFFECT4) == ML_EFFECT4);
+					{
+						P_Teleport(mo, dest->x, dest->y, dest->z, ang, false, dontstopmove);
+					}
 					else
 					{
-						P_Teleport(mo, dest->x, dest->y, dest->z, (line->flags & ML_NOCLIMB) ? mo->angle : dest->angle, true, (line->flags & ML_EFFECT4) == ML_EFFECT4);
+						P_Teleport(mo, dest->x, dest->y, dest->z, ang, true, dontstopmove);
 						// Play the 'bowrwoosh!' sound
 						S_StartSound(dest, sfx_mixup);
 					}

src/p_user.c

@@ -91,7 +91,7 @@ void P_InstaThrust(mobj_t *mo, angle_t angle, fixed_t move)
 	mo->momx = FixedMul(move, FINECOSINE(angle));
 
 	if (!twodmo(mo))
-		mo->momy = FixedMul(move,FINESINE(angle));
+		mo->momy = FixedMul(move, FINESINE(angle));
 }
 
 void P_InstaThrustEvenIn2D(mobj_t *mo, angle_t angle, fixed_t move)
@@ -498,7 +498,7 @@ void P_PlayRinglossSound(mobj_t *source, mobj_t *damager)
 
 			// I HATE LOCALSKINS! I HATE LOCALSKINS! :AAAAAAAAAA:
 			if (source->player)
-				sfx = R_GetPlayerSkin(source->player)->soundsid[SKSKPAN1 + key];
+				sfx = K_GetPlayerSkin(source->player)->soundsid[SKSKPAN1 + key];
 
 			S_StartSound(NULL, sfx);
 		}
@@ -1271,7 +1271,7 @@ void P_DoPlayerExit(player_t *player)
 
 			if (islocalplayer)
 			{
-				sfxenum_t sfx_id = R_GetMobjSkin(player->mo)->soundsid[S_sfx[soundid].skinsound];
+				sfxenum_t sfx_id = K_GetMobjSkin(player->mo)->soundsid[S_sfx[soundid].skinsound];
 				S_StartSound(NULL, sfx_id);
 			}
 			else

src/r_draw.cpp

@@ -94,18 +94,19 @@ spandrawfunc_t *spanfuncs[SPANDRAWFUNC_MAX] = {};
 //                   TRANSLATION COLORMAP CODE
 // =========================================================================
 
-#define DEFAULT_TT_CACHE_INDEX 0
-#define BOSS_TT_CACHE_INDEX 1
-#define METALSONIC_TT_CACHE_INDEX 2
-#define ALLWHITE_TT_CACHE_INDEX 3
-#define RAINBOW_TT_CACHE_INDEX 4
-#define BLINK_TT_CACHE_INDEX 5
-#define TT_CACHE_SIZE 6
+#define DEFAULT_TT_CACHE_INDEX MAXSKINS
+#define BOSS_TT_CACHE_INDEX (MAXSKINS + 1)
+#define METALSONIC_TT_CACHE_INDEX (MAXSKINS + 2)
+#define ALLWHITE_TT_CACHE_INDEX (MAXSKINS + 3)
+#define RAINBOW_TT_CACHE_INDEX (MAXSKINS + 4)
+#define BLINK_TT_CACHE_INDEX (MAXSKINS + 5)
+#define TT_CACHE_SIZE (MAXSKINS + 6)
 #define SKIN_RAMP_LENGTH 16
 #define DEFAULT_STARTTRANSCOLOR 160
 #define NUM_PALETTE_ENTRIES 256
 
-static UINT8 **specialtranslationtablecache[TT_CACHE_SIZE] = {};
+static UINT8 **translationtablecache[TT_CACHE_SIZE] = {};
+static UINT8 **localtranslationtablecache[MAXLOCALSKINS] = {};
 
 CV_PossibleValue_t Color_cons_t[MAXSKINCOLORS+1] = {};
 
@@ -377,60 +378,38 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
 {
 	UINT8 ***tt;
 	UINT8* ret;
+	INT32 skintableindex;
 
 	if (local)
 	{
-		I_Assert(skinnum >= 0 && skinnum < numlocalskins);
-		tt = &localskins[skinnum]->translationtablecache;
+		tt = localtranslationtablecache;
+		skintableindex = skinnum;
 	}
 	else
 	{
+		tt = translationtablecache;
+
 		// Adjust if we want the default colormap
-		if (skinnum < 0)
+		switch (skinnum)
 		{
-			INT32 skintableindex;
-
-			switch (skinnum)
-			{
-				case TC_DEFAULT:
-					skintableindex = DEFAULT_TT_CACHE_INDEX;
-					break;
-				case TC_BOSS:
-					skintableindex = BOSS_TT_CACHE_INDEX;
-					break;
-				case TC_METALSONIC:
-					skintableindex = METALSONIC_TT_CACHE_INDEX;
-					break;
-				case TC_ALLWHITE:
-					skintableindex = ALLWHITE_TT_CACHE_INDEX;
-					break;
-				case TC_RAINBOW:
-					skintableindex = RAINBOW_TT_CACHE_INDEX;
-					break;
-				case TC_BLINK:
-					skintableindex = BLINK_TT_CACHE_INDEX;
-					break;
-				default:
-					return NULL;
-			}
-
-			tt = &specialtranslationtablecache[skintableindex];
-		}
-		else
-		{
-			I_Assert(skinnum >= 0 && skinnum < numskins);
-			tt = &skins[skinnum]->translationtablecache;
+			case TC_DEFAULT:    skintableindex = DEFAULT_TT_CACHE_INDEX; break;
+			case TC_BOSS:       skintableindex = BOSS_TT_CACHE_INDEX; break;
+			case TC_METALSONIC: skintableindex = METALSONIC_TT_CACHE_INDEX; break;
+			case TC_ALLWHITE:   skintableindex = ALLWHITE_TT_CACHE_INDEX; break;
+			case TC_RAINBOW:    skintableindex = RAINBOW_TT_CACHE_INDEX; break;
+			case TC_BLINK:      skintableindex = BLINK_TT_CACHE_INDEX; break;
+			default:            skintableindex = skinnum; break;
 		}
 	}
 
 	if (flags & GTC_CACHE)
 	{
 		// Allocate table for skin if necessary
-		if (!*tt)
-			*tt = static_cast<UINT8**>(Z_Calloc(MAXTRANSLATIONS * sizeof(UINT8**), PU_STATIC, NULL));
+		if (!tt[skintableindex])
+			tt[skintableindex] = static_cast<UINT8**>(Z_Calloc(MAXTRANSLATIONS * sizeof(UINT8**), PU_STATIC, NULL));
 
 		// Get colormap
-		ret = (*tt)[color];
+		ret = tt[skintableindex][color];
 	}
 	else
 		ret = NULL;
@@ -439,11 +418,11 @@ static UINT8* RGetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 f
 	if (!ret)
 	{
 		ret = static_cast<UINT8*>(Z_Malloc(NUM_PALETTE_ENTRIES, PU_STATIC, NULL));
-		K_GenerateKartColormap(ret, skinnum, color, local); // R_GenerateTranslationColormap(ret, skinnum, color);		// SRB2kart
+		K_GenerateKartColormap(ret, skinnum, color, local); //R_GenerateTranslationColormap(ret, skinnum, color);		// SRB2kart
 
 		// Cache the colormap if desired
 		if (flags & GTC_CACHE)
-			(*tt)[color] = ret;
+			tt[skintableindex][color] = ret;
 	}
 
 	return ret;
@@ -456,26 +435,46 @@ UINT8* R_GetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 flags)
 
 UINT8* R_GetLocalTranslationColormap(skin_t *skin, skin_t *localskin, skincolors_t color, UINT8 flags, boolean local)
 {
-	const INT32 skinnum = (INT32)((localskin && local) ? localskin->skinnum : (skin != NULL ? skin->skinnum : 0));
-	return RGetTranslationColormap(skinnum, color, flags, (localskin && local));
+	return RGetTranslationColormap(K_GetMobjLocalSkinNum(skin, localskin, local), color, flags, (localskin && local));
 }
 
-patch_t* R_GetSkinFaceRank(player_t* player)
+patch_t* R_GetSkinFaceRank(player_t* ply)
 {
-	const skin_t *skin = R_GetPlayerSkin(player);
-	return skin->facerankprefix;
+	if (ply->localskin)
+	{
+		if (ply->skinlocal)
+			return localfacerankprefix[ply->localskin - 1];
+
+		return facerankprefix[ply->localskin - 1];
+	}
+
+	return facerankprefix[ply->skin];
 }
 
-patch_t* R_GetSkinFaceWant(player_t* player)
+patch_t* R_GetSkinFaceWant(player_t* ply)
 {
-	const skin_t *skin = R_GetPlayerSkin(player);
-	return skin->facewantprefix;
+	if (ply->localskin)
+	{
+		if (ply->skinlocal)
+			return localfacewantprefix[ply->localskin - 1];
+
+		return facewantprefix[ply->localskin - 1];
+	}
+
+	return facewantprefix[ply->skin];
 }
 
-patch_t* R_GetSkinFaceMini(player_t* player)
+patch_t* R_GetSkinFaceMini(player_t* ply)
 {
-	const skin_t *skin = R_GetPlayerSkin(player);
-	return skin->facemmapprefix;
+	if (ply->localskin)
+	{
+		if (ply->skinlocal)
+			return localfacemmapprefix[ply->localskin - 1];
+
+		return facemmapprefix[ply->localskin - 1];
+	}
+
+	return facemmapprefix[ply->skin];
 }
 
 /**	\brief	Flushes cache of translation colormaps.
@@ -494,20 +493,13 @@ void R_FlushTranslationColormapCache(void)
 {
 	INT32 i;
 
-	// skin cache
-	for (i = 0; i < (INT32)numskins; i++)
-		if (skins[i]->translationtablecache)
-			memset(skins[i]->translationtablecache, 0, MAXTRANSLATIONS * sizeof(UINT8**));
+	for (i = 0; i < (INT32)(sizeof(translationtablecache) / sizeof(translationtablecache[0])); i++)
+		if (translationtablecache[i])
+			memset(translationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**));
 
-	// localskin cache
-	for (i = 0; i < (INT32)numlocalskins; i++)
-		if (localskins[i]->translationtablecache)
-			memset(localskins[i]->translationtablecache, 0, MAXTRANSLATIONS * sizeof(UINT8**));
-
-	// special cache
-	for (i = 0; i < (INT32)(sizeof(specialtranslationtablecache) / sizeof(specialtranslationtablecache[0])); i++)
-		if (specialtranslationtablecache[i])
-			memset(specialtranslationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**));
+	for (i = 0; i < (INT32)(sizeof(localtranslationtablecache) / sizeof(localtranslationtablecache[0])); i++)
+		if (localtranslationtablecache[i])
+			memset(localtranslationtablecache[i], 0, MAXTRANSLATIONS * sizeof(UINT8**));
 }
 */
 

src/r_main.cpp

@@ -389,7 +389,7 @@ angle_t R_PlayerSliptideAngle(player_t *player)
 
 	if (mo->skin && mo->sprite == SPR_PLAY)
 	{
-		sprdef = &mo->skin->spritedef;
+		sprdef = &((skin_t *)mo->skin)->spritedef;
 
 		if (rot >= sprdef->numframes)
 			sprdef = &sprites[mo->sprite];

src/r_patch.cpp

@@ -129,8 +129,8 @@ static void R_ParseSpriteInfo(boolean spr2)
 	spritenum_t sprnum = NUMSPRITES;
 	//playersprite_t spr2num = NUMPLAYERSPRITES;
 	INT32 i;
+	INT32 skinnumbers[MAXSKINS]; // >variable 'skinnumbers' set but not used >compile error when commented out
 	INT32 foundskins = 0;
-	CLEANUP(pfree) INT32 *skinnumbers = (INT32 *)calloc(1, numallskins); // could realloc this for foundskins but this is simpler
 
 	// Sprite name
 	sprinfoToken = M_GetToken(NULL);
@@ -236,10 +236,10 @@ static void R_ParseSpriteInfo(boolean spr2)
 					{
 						size_t skinnum = skinnumbers[i];
 						skin_t *skin;
-						if (allskins[skinnum]->localskin)
-							skin = localskins[allskins[skinnum]->skinnum];
+						if (allskins[skinnum].localskin)
+							skin = &localskins[allskins[skinnum].localnum];
 						else
-							skin = skins[allskins[skinnum]->skinnum];
+							skin = &skins[allskins[skinnum].localnum];
 						memcpy(&skin->sprinfo, info, sizeof(spriteinfo_t));
 					}
 				}

src/r_skins.c

@@ -40,9 +40,7 @@ CV_PossibleValue_t Forceskin_cons_t[MAXSKINS+2] = {}; // huehuehuehuehue
 INT32 numskins = 0;
 INT32 numallskins = 0;
 INT32 numlocalskins = 0;
-skin_t **skins = NULL;
-skin_t **localskins = NULL;
-skin_t **allskins = NULL;
+skin_t skins[MAXSKINS];
 
 skinnum_t skinstats[9][9][MAXSKINS];
 skinnum_t skinstatscount[9][9] = {
@@ -58,8 +56,17 @@ skinnum_t skinstatscount[9][9] = {
 };
 
 skinnum_t skinsorted[MAXSKINS] = {};
+skin_t localskins[MAXLOCALSKINS] = {};
+skin_t allskins[MAXSKINS+MAXLOCALSKINS] = {};
 
-static void Sk_SetDefaultValue(skin_t *skin)
+// FIXTHIS: don't work because it must be inistilised before the config load
+//#define SKINVALUES
+#ifdef SKINVALUES
+CV_PossibleValue_t skin_cons_t[MAXSKINS+1] = {};
+CV_PossibleValue_t localskin_cons_t[MAXLOCALSKINS+1] = {};
+#endif
+
+static void Sk_SetDefaultValue(skin_t *skin, boolean local)
 {
 	INT32 i;
 	//
@@ -67,7 +74,7 @@ static void Sk_SetDefaultValue(skin_t *skin)
 	//
 	memset(skin, 0, sizeof(skin_t));
 
-	snprintf(skin->name, sizeof skin->name, "skin %u", skin->skinnum); // this will always be "skin 0" cause of the memset above lmao
+	snprintf(skin->name, sizeof skin->name, "skin %u", K_GetMobjSkinNum(skin, local));
 	skin->name[sizeof skin->name - 1] = '\0';
 
 	skin->wadnum = INT16_MAX;
@@ -105,22 +112,35 @@ static void Sk_SetDefaultValue(skin_t *skin)
 void R_InitSkins(void)
 {
 	skin_t *skin;
+#ifdef SKINVALUES
+	INT32 i;
 
-	skins = Z_Calloc(sizeof(skin_t *), PU_STATIC, NULL);
-	//localskins = Z_Calloc(sizeof(skin_t *), PU_STATIC, NULL);
-	allskins = Z_Calloc(sizeof(skin_t *), PU_STATIC, NULL);
+	for (i = 0; i <= MAXSKINS; i++)
+	{
+		skin_cons_t[i].value = 0;
+		skin_cons_t[i].strvalue = NULL;
+	}
+	for (i = 0; i <= MAXLOCALSKINS; i++)
+	{
+		localskin_cons_t[i].value = 0;
+		localskin_cons_t[i].strvalue = NULL;
+	}
+#endif
 
 	// skin[0] = Sonic skin
-	skin = skins[0] = Z_Calloc(sizeof(skin_t), PU_STATIC, NULL);
-
-	Sk_SetDefaultValue(skin);
-	skin->skinnum = 0;
+	skin = &skins[0];
+	numskins = 1;
+	Sk_SetDefaultValue(skin, false);
 
 	memset(skinstats, 0, sizeof(skinstats));
 	memset(skinsorted, 0, sizeof(skinsorted));
 
 	// Hardcoded S_SKIN customizations for Sonic.
 	strcpy(skin->name,       DEFAULTSKIN);
+#ifdef SKINVALUES
+	skin_cons_t[0].strvalue = skins[0].name;
+#endif
+
 	strcpy(skin->realname,   "Sonic");
 	strcpy(skin->hudname,    "SONIC");
 
@@ -133,6 +153,7 @@ void R_InitSkins(void)
 	skin->wadnum = 0; // god what have you brought to this world
 	skin->prefcolor = SKINCOLOR_BLUE;
 	skin->localskin = false;
+	skin->localnum = 0;
 
 	// SRB2kart
 	skin->kartspeed = 8;
@@ -142,7 +163,7 @@ void R_InitSkins(void)
 	skin->spritedef.numframes = sprites[SPR_PLAY].numframes;
 	skin->spritedef.spriteframes = sprites[SPR_PLAY].spriteframes;
 	skin->sprinfo = spriteinfo[SPR_PLAY];
-	ST_LoadFaceGraphics(skin);
+	ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, 0);
 
 	// Set values for Sonic skin
 	Forceskin_cons_t[1].value = 0;
@@ -156,8 +177,6 @@ void R_InitSkins(void)
 
 	// lets set it
 	allskins[0] = skins[0];
-
-	numskins = 1;
 	numallskins = 1;
 }
 
@@ -169,7 +188,7 @@ INT32 R_SkinAvailable(const char *name)
 
 	for (i = 0; i < numskins; i++)
 	{
-		if (fasticmp(skins[i]->name, name))
+		if (fasticmp(skins[i].name, name))
 			return i;
 	}
 
@@ -184,7 +203,7 @@ INT32 R_AnySkinAvailable(const char *name)
 
 	for (i = 0; i < numallskins; i++)
 	{
-		if (fasticmp(allskins[i]->name, name))
+		if (fasticmp(allskins[i].name, name))
 			return i;
 	}
 
@@ -199,7 +218,7 @@ INT32 R_LocalSkinAvailable(const char *name, boolean local)
 	{
 		for (i = 0; i < numlocalskins; i++)
 		{
-			if (fasticmp(localskins[i]->name, name))
+			if (fasticmp(localskins[i].name, name))
 				return i;
 		}
 
@@ -217,7 +236,7 @@ boolean SetPlayerSkin(INT32 playernum, const char *skinname)
 	for (i = 0; i < numskins; i++)
 	{
 		// search in the skin list
-		if (fasticmp(skins[i]->name, skinname))
+		if (fasticmp(skins[i].name, skinname))
 		{
 			SetPlayerSkinByNum(playernum, i);
 			return true;
@@ -243,14 +262,14 @@ void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
 		for (i = 0; i < numlocalskins; i++)
 		{
 			// search in the localskin list
-			if (fasticmp(localskins[i]->name, skinname))
+			if (fasticmp(localskins[i].name, skinname))
 			{
 				player->localskin = 1 + i;
 				player->skinlocal = true;
 
 				if (player->mo)
 				{
-					player->mo->localskin = localskins[i];
+					player->mo->localskin = &localskins[i];
 					player->mo->skinlocal = true;
 				}
 
@@ -261,14 +280,14 @@ void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
 		for (i = 0; i < numskins; i++)
 		{
 			// search in the skin list
-			if (fasticmp(skins[i]->name, skinname))
+			if (fasticmp(skins[i].name, skinname))
 			{
 				player->localskin = 1 + i;
 				player->skinlocal = false;
 
 				if (player->mo)
 				{
-					player->mo->localskin = skins[i];
+					player->mo->localskin = &skins[i];
 					player->mo->skinlocal = false;
 				}
 
@@ -293,9 +312,9 @@ setcvar:
 	{
 		if (player->localskin > 0)
 		{
-			skin_t *lskin = R_GetSkinArray(player->skinlocal)[player->localskin-1];
-			CV_StealthSet(&cv_fakelocalskin, lskin->name);
-			CV_StealthSet(cvar, lskin->name);
+			CV_StealthSet(&cv_fakelocalskin, K_GetSkinArray(player->skinlocal)[player->localskin-1].name);
+			CV_StealthSet(cvar, K_GetSkinArray(player->skinlocal)[player->localskin-1].name);
+
 		}
 		else
 		{
@@ -310,12 +329,10 @@ setcvar:
 void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum)
 {
 	player_t *player = &players[playernum];
-	skin_t *skin;
+	skin_t *skin = &skins[skinnum];
 
 	if (skinnum >= 0 && skinnum < numskins) // Make sure it exists!
 	{
-		skin = skins[skinnum];
-
 		player->skin = skinnum;
 
 		if (player->mo)
@@ -383,8 +400,8 @@ static int skinSortFunc(const void *a, const void *b) // tbh i have no clue what
 	int diff = 0;
 	const skinnum_t val_a = *(const skinnum_t *)a;
 	const skinnum_t val_b = *(const skinnum_t *)b;
-	const skin_t *in1 = skins[val_a];
-	const skin_t *in2 = skins[val_b];
+	const skin_t *in1 = &skins[val_a];
+	const skin_t *in2 = &skins[val_b];
 
 	// return (strcmp(in1->realname, in2->realname) < 0) || (strcmp(in1->realname, in2->realname) ==);
 
@@ -471,7 +488,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 	char *stoken;
 	char *value;
 	size_t size;
-	skin_t *skin = NULL;
+	skin_t *skin;
 	boolean hudname, realname;
 
 #define lnumskins (local ? numlocalskins : numskins)
@@ -485,18 +502,16 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 		// advance by default
 		lastlump = lump + 1;
 
-		// gotta keep this for vanilla compat reasons
 		if (!local && numskins >= MAXSKINS)
 		{
 			CONS_Alert(CONS_WARNING, M_GetText("Unable to add skin, too many characters are loaded (%d maximum)\n"), MAXSKINS);
 			continue; // so we know how many skins couldn't be added
 		}
-
-		/* if (local && numlocalskins >= MAXLOCALSKINS)
+		if (local && numlocalskins >= MAXLOCALSKINS)
 		{
 			CONS_Alert(CONS_WARNING, M_GetText("Unable to add localskin, too many localskins are loaded (%d maximum)\n"), MAXLOCALSKINS);
 			continue; // so we know how many skins couldn't be added
-		} */
+		}
 
 		buf = W_CacheLumpNumPwad(wadnum, lump, PU_CACHE);
 		size = W_LumpLengthPwad(wadnum, lump);
@@ -509,19 +524,8 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 		buf2[size] = '\0';
 
 		// set defaults
-		if (!local)
-		{
-			skins = Z_Realloc(skins, sizeof(skin_t *) * (numskins + 1), PU_STATIC, NULL);
-		}
-		else
-		{
-			localskins = Z_Realloc(localskins, sizeof(skin_t *) * (numlocalskins + 1), PU_STATIC, NULL);
-		}
-
-		skin = R_GetSkinArray(local)[lnumskins] = Z_Calloc(sizeof(skin_t), PU_STATIC, NULL);
-		Sk_SetDefaultValue(skin);
-		skin->skinnum = lnumskins;
-		skin->allskinnum = numallskins;
+		skin = &K_GetSkinArray(local)[lnumskins];
+		Sk_SetDefaultValue(skin, local);
 		skin->wadnum = wadnum;
 		hudname = realname = false;
 
@@ -773,19 +777,24 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 		//R_FlushTranslationColormapCache();
 
 		CONS_Printf(M_GetText("Added skin '%s'\n"), skin->name);
-
+#ifdef SKINVALUES
+		(local ? localskin_cons_t : skin_cons_t)[lnumskins].value = lnumskins;
+		(local ? localskin_cons_t : skin_cons_t)[lnumskins].strvalue = skin->name;
+#endif
 		if (!local)
 		{
 			// Update the forceskin possiblevalues
 			Forceskin_cons_t[numskins+1].value = numskins;
-			Forceskin_cons_t[numskins+1].strvalue = skins[numskins]->name;
+			Forceskin_cons_t[numskins+1].strvalue = skins[numskins].name;
 			skin->localskin = false;
-			ST_LoadFaceGraphics(skin);
+			skin->localnum = numskins;
+			ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numskins);
 		}
 		else
 		{
 			skin->localskin = true;
-			ST_LoadFaceGraphics(skin);
+			skin->localnum = numlocalskins;
+			ST_LoadLocalFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numlocalskins);
 		}
 
 #ifdef HWRENDER
@@ -801,8 +810,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 			skinsorted[numskins] = numskins;
 		}
 
-		allskins = Z_Realloc(allskins, sizeof(skin_t*) * (numallskins + 1), PU_STATIC, NULL);
-		allskins[numallskins] = R_GetSkinArray(local)[lnumskins];
+		allskins[numallskins] = K_GetSkinArray(local)[lnumskins];
 
 		local ? numlocalskins++ : numskins++;
 		numallskins++;
@@ -812,50 +820,3 @@ void R_AddSkins(UINT16 wadnum, boolean local)
 
 	return;
 }
-
-// Helper functions for skin stuff
-
-//
-// returns the skin array to use
-// accounts for localskins
-//
-skin_t **R_GetSkinArray(boolean local)
-{
-	return local ? localskins : skins;
-}
-
-//
-// returns the players skinnumber
-// accounts for localskins
-//
-INT32 R_GetPlayerSkinNum(player_t *player)
-{
-	return player->localskin ? (player->localskin - 1) : player->skin;
-}
-
-//
-// returns the players skin
-// accounts for localskins
-//
-skin_t *R_GetPlayerSkin(player_t *player)
-{
-	return R_GetSkinArray(player->skinlocal)[R_GetPlayerSkinNum(player)];
-}
-
-//
-// returns the mobj skinnumber
-// accounts for localskins
-//
-INT32 R_GetMobjSkinNum(const mobj_t *mobj)
-{
-	return mobj->localskin ? mobj->localskin->skinnum : mobj->skin->skinnum;
-}
-
-//
-// returns the mobjs skin
-// accounts for localskins
-//
-skin_t *R_GetMobjSkin(const mobj_t *mobj)
-{
-	return mobj->localskin ? mobj->localskin : mobj->skin;
-}

src/r_skins.h

@@ -16,7 +16,6 @@
 #ifndef __R_SKINS__
 #define __R_SKINS__
 
-#include "doomtype.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -25,10 +24,6 @@ extern "C" {
 #include "sounds.h"
 #include "r_patch.h"
 
-#ifdef HWRENDER
-#include "hardware/hw_md2.h"
-#endif
-
 // "Left" and "Right" character symbols for additional rotation functionality
 #define ROT_L ('L' - '0')
 #define ROT_R ('R' - '0')
@@ -40,7 +35,7 @@ extern "C" {
 #define DEFAULTSKIN3 "knuckles" // third player
 #define DEFAULTSKIN4 "eggman" // fourth player
 
-typedef struct skin_s
+typedef struct
 {
 	char name[SKINNAMESIZE+1]; // INT16 descriptive name of the skin
 	spritedef_t spritedef;
@@ -53,17 +48,12 @@ typedef struct skin_s
 	char hudname[SKINNAMESIZE+1]; // HUD name to display (officially exactly 5 characters long)
 	char facerank[9], facewant[9], facemmap[9]; // Arbitrarily named patch lumps
 
-	patch_t *facerankprefix; // ranking
-	patch_t *facewantprefix; // wanted
-	patch_t *facemmapprefix; // minimap
-
 	// SRB2kart
 	UINT8 kartspeed;
 	UINT8 kartweight;
 	//
 
 	// Definable color translation table
-	UINT8 **translationtablecache;
 	UINT8 starttranscolor;
 	UINT8 prefcolor;
 	fixed_t highresscale; // scale of highres, default is 0.5
@@ -71,13 +61,8 @@ typedef struct skin_s
 	// specific sounds per skin
 	sfxenum_t soundsid[NUMSKINSOUNDS]; // sound # in S_sfx table
 
-#ifdef HWRENDER
-	md2_t playermodel;
-#endif
-
 	boolean localskin;
-	skinnum_t skinnum;
-	UINT16 allskinnum;
+	INT32 localnum;
 } skin_t;
 
 extern CV_PossibleValue_t Forceskin_cons_t[];
@@ -85,14 +70,14 @@ extern CV_PossibleValue_t Forceskin_cons_t[];
 extern INT32 numskins;
 extern INT32 numlocalskins;
 extern INT32 numallskins;
-extern skin_t **skins;
-extern skin_t **localskins;
-extern skin_t **allskins;
-
+extern skin_t skins[MAXSKINS];
 extern skinnum_t skinstats[9][9][MAXSKINS];
 extern skinnum_t skinstatscount[9][9];
 extern skinnum_t skinsorted[MAXSKINS];
 
+extern skin_t localskins[MAXLOCALSKINS];
+extern skin_t allskins[MAXSKINS+MAXLOCALSKINS];
+
 //faB: find sprites in wadfile, replace existing, add new ones
 //     (only sprites from namelist are added or replaced)
 void R_AddSpriteDefs(UINT16 wadnum);
@@ -105,11 +90,13 @@ INT32 R_AnySkinAvailable(const char *name);
 INT32 R_LocalSkinAvailable(const char *name, boolean local);
 
 // had to move those here Zzz...
-skin_t **R_GetSkinArray(boolean local);
-skin_t *R_GetPlayerSkin(player_t *player);
-INT32 R_GetPlayerSkinNum(player_t *player);
-INT32 R_GetMobjSkinNum(const mobj_t *mobj);
-skin_t *R_GetMobjSkin(const mobj_t *mobj);
+INT32 K_GetSkinNum(player_t *player);
+INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local);
+INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local);
+skin_t *K_GetPlayerSkin(player_t *player);
+skin_t *K_GetMobjSkin(const mobj_t *mobj);
+patch_t *K_GetFacePrefix(player_t *player, INT32 skinnum);
+skin_t *K_GetSkinArray(boolean local);
 
 void sortSkinGrid(void);
 

src/r_things.cpp

@@ -1276,7 +1276,7 @@ static void R_ProjectSprite(mobj_t *thing)
 	const boolean shouldrotate = (interp.sloperoll || interp.slopepitch || interp.roll || interp.pitch || thing->rollangle || thing->temprollangle || sliprollrotate);
 #endif
 
-	sprskin = R_GetMobjSkin(thing);
+	sprskin = K_GetMobjSkin(thing);
 
 	//Fab : 02-08-98: 'skin' override spritedef currently used for skin
 	if (sprskin && thing->sprite == SPR_PLAY)

src/s_sound.c

@@ -529,7 +529,7 @@ void S_StartSoundAtVolume(const void *origin_p, sfxenum_t sfx_id, INT32 volume)
 	if (sfx->skinsound != -1 && origin && origin->skin)
 	{
 		// redirect player sound to the sound in the skin table
-		sfx_id = R_GetMobjSkin(origin)->soundsid[sfx->skinsound];
+		sfx_id = K_GetMobjSkin(origin)->soundsid[sfx->skinsound];
 		sfx = &S_sfx[sfx_id];
 	}
 

src/sdl/CMakeLists.txt

@@ -233,20 +233,25 @@ if(${SDL2_FOUND})
 		-DHAVE_THREADS
 	)
 
-	if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE)
+	if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE AND NOT SRB2_CONFIG_ASAN AND NOT SRB2_CONFIG_UBSAN AND NOT SRB2_CONFIG_TSAN)
 		set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
 	endif()
 
 	if(SRB2_CONFIG_ASAN)
-		target_compile_options(SRB2SDL2 PRIVATE -fsanitize=address)
+		target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=address -fno-omit-frame-pointer -fno-common)
 		target_link_options(SRB2SDL2 PRIVATE -fsanitize=address)
 	endif()
 
 	if(SRB2_CONFIG_UBSAN)
-		target_compile_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
+		target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=undefined -fno-omit-frame-pointer)
 		target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
 	endif()
 
+	if(SRB2_CONFIG_TSAN)
+		target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=thread -fno-omit-frame-pointer)
+		target_link_options(SRB2SDL2 PRIVATE -fsanitize=thread)
+	endif()
+
 	if(NOT SRB2_CONFIG_MUMBLE)
 		target_compile_options(SRB2SDL2 PRIVATE -DNOMUMBLE)
 	endif()

src/sdl/i_video.c

@@ -97,11 +97,9 @@ static char vidModeName[33][32]; // allow 33 different modes
 rendermode_t rendermode = render_none;
 
 #ifdef HWRENDER
-unsigned msaa = 0;
-
 // Eee probably the way i organize it isn't best ><
 // Just don't know where do i put declaration and "implementation"
-boolean a2c = false;
+unsigned msaa = 0;
 #endif
 
 static void KeyboardLayout_OnChange(void)
@@ -197,10 +195,6 @@ static INT32 custom_height = 0;
 static SDL_bool Impl_CreateWindow(SDL_bool fullscreen);
 static void Impl_SetWindowIcon(void);
 
-#ifdef USE_FBO_OGL
-boolean downsample = false;
-#endif
-
 static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
 {
 	if (code >= SDL_SCANCODE_A && code <= SDL_SCANCODE_Z)
@@ -522,7 +516,7 @@ static void Impl_HandleWindowEvent(SDL_WindowEvent evt)
 	{
 		I_CheckDesktopRes();
 #ifdef USE_FBO_OGL
-		I_DownSample();
+			I_CheckDownSampleState(false);
 #endif
 		windowmoved = SDL_FALSE;
 	}
@@ -1263,8 +1257,9 @@ static void I_CheckDesktopRes(void)
 	int currentDisplayIndex = -1;
 	SDL_DisplayMode curmode;
 
-	desktopwidth = 0;
-	desktopheight = 0;
+	// just fallback to game res ig?
+	desktopwidth = vid.width;
+	desktopheight = vid.height;
 
 	currentDisplayIndex = SDL_GetWindowDisplayIndex(window);
 
@@ -1274,7 +1269,7 @@ static void I_CheckDesktopRes(void)
 		return;
 	}
 
-	if (SDL_GetDesktopDisplayMode(currentDisplayIndex, &curmode) != 0)
+	if (SDL_GetCurrentDisplayMode(currentDisplayIndex, &curmode) < 0)
 	{
 		return;
 	}
@@ -1289,47 +1284,39 @@ boolean I_CheckNativeRes(void)
 	return (vid.width == desktopwidth && vid.height == desktopheight);
 }
 
-#ifdef USE_FBO_OGL
-
-void RefreshOGLSDLSurface(void)
+static boolean I_CheckAboveDesktopRes(INT32 width, INT32 height)
 {
-	if (rendermode == render_opengl)
-		OglSdlSurface(vid.width, vid.height);
+	return (width > desktopwidth || height > desktopheight);
 }
 
-void I_DownSample(void)
+#ifdef USE_FBO_OGL
+static boolean vid_downsampling = false;
+
+boolean I_IsDownsampling(void)
 {
-	boolean needrefresh = false;
+	return vid_downsampling;
+}
 
-	if (!cv_glframebuffer.value || !supportFBO || (cv_glscreentextures.value == 0)) // no sense to do this crap if we cant benefit from it
+void I_CheckDownSampleState(boolean forcerefresh)
+{
+	// no fbo support so we dont care
+	if (!supportFBO)
 	{
-		downsample = false;
+		vid_downsampling = false;
 		return;
 	}
 
-	if (I_CheckNativeRes() && (downsample == true))
+	// no sense to do this crap if we cant benefit from it
+	const boolean newdownsamplestate = cv_glframebuffer.value && (cv_glscreentextures.value == 2) && I_CheckAboveDesktopRes(vid.width, vid.height);
+
+	// state changed or fbo was toggled
+	if (vid_downsampling != newdownsamplestate || forcerefresh)
 	{
-		downsample = false;
-		RefreshOGLSDLSurface();
-		return;
+		//printf("downsample changed from %d to %d\n", vid_downsampling, curdownsamplestate);
+		OglSdlSurface(vid.width, vid.height);
 	}
 
-	if ((vid.width > desktopwidth) || (vid.height > desktopheight)) //check if current resolution is higher than current display resolution
-	{
-		downsample = true;
-		needrefresh = true;
-	}
-	else if (downsample == true)
-	{
-		downsample = false;
-		needrefresh = true;
-	}
-
-	if (needrefresh)
-	{
-		RefreshOGLSDLSurface();
-		needrefresh = false;
-	}
+	vid_downsampling = newdownsamplestate;
 }
 #endif
 
@@ -1359,10 +1346,11 @@ static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen)
 			}
 
 			// Reposition window only in windowed mode
+			const int windowpos = SDL_GetWindowDisplayIndex(window);
 			SDL_SetWindowSize(window, width, height);
 			SDL_SetWindowPosition(window,
-				SDL_WINDOWPOS_CENTERED_DISPLAY(SDL_GetWindowDisplayIndex(window)),
-				SDL_WINDOWPOS_CENTERED_DISPLAY(SDL_GetWindowDisplayIndex(window))
+				SDL_WINDOWPOS_CENTERED_DISPLAY(windowpos),
+				SDL_WINDOWPOS_CENTERED_DISPLAY(windowpos)
 			);
 		}
 	}
@@ -1384,7 +1372,7 @@ static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen)
 	{
 		I_CheckDesktopRes();
 #ifdef USE_FBO_OGL
-		I_DownSample();
+		I_CheckDownSampleState(false);
 #endif
 		OglSdlSurface(vid.width, vid.height);
 	}
@@ -1825,7 +1813,6 @@ void I_StartupGraphics(void)
 		rendermode = render_opengl;
 
 	msaa = 0; boolean msaa_set = false;
-	a2c = false; boolean a2c_set = false;
 
 	// MSAA antialiasing
 	if (M_CheckParm("-msaa") && M_IsNextParm())
@@ -1837,16 +1824,6 @@ void I_StartupGraphics(void)
 		}
 	}
 
-	if (M_CheckParm("-a2c"))
-	{
-		a2c = true;
-		a2c_set = true;
-	}
-	else if (M_CheckParm("-noa2c"))
-	{
-		a2c_set = true;
-	}
-
     {
 		char   line[16];
 		char * word;
@@ -1890,19 +1867,10 @@ void I_StartupGraphics(void)
 						}
 						else
 						{
-							CONS_Printf("Using last know MSAA value: %u\n", msaa);
+							CONS_Printf("Using last known MSAA value: %u\n", msaa);
 						}
 					}
 				}
-
-				if (!a2c_set)
-				{
-					if (fasticmp(word, "a2c"))
-					{
-						a2c = true;
-						CONS_Printf("Using a2c because it was specified to be used earlier\n");
-					}
-				}
 			}
 
 			fclose(file);
@@ -1937,9 +1905,6 @@ void I_StartupGraphics(void)
 
 #ifdef HWRENDER
 			fprintf(file, "msaa %u\n", msaa);
-
-			if (a2c)
-				fputs("a2c\n", file);
 #endif
 			fclose(file);
 		}

src/sdl/ogl_sdl.c

@@ -65,7 +65,7 @@ PFNglGetString pglGetString;
 #ifdef USE_FBO_OGL
 boolean UseScreenFBO(void)
 {
-	return (supportFBO && cv_glframebuffer.value && downsample);
+	return (supportFBO && cv_glframebuffer.value && I_IsDownsampling() && (cv_glscreentextures.value == 2));
 }
 #endif
 
@@ -203,9 +203,9 @@ boolean OglSdlSurface(INT32 w, INT32 h)
 
 #ifdef USE_FBO_OGL
 	if (UseScreenFBO())
-		GL_Framebuffer_Enable();
+		GL_FBO_Enable();
 	else
-		GL_Framebuffer_Disable();
+		GL_FBO_Disable();
 #endif
 
 	if (!first_init)
@@ -235,9 +235,7 @@ void OglSdlFinishUpdate(SDL_Window *window)
 
 #ifdef USE_FBO_OGL
 	if (usefbo)
-	{
-		GL_Framebuffer_Unbind();
-	}
+		GL_FBO_BindMainFrameBuffer();
 #endif
 
 	if (HWR_ShouldUsePaletteRendering())
@@ -255,9 +253,7 @@ void OglSdlFinishUpdate(SDL_Window *window)
 
 #ifdef USE_FBO_OGL
 	if (usefbo)
-	{
-		GL_Framebuffer_Enable();
-	}
+		GL_FBO_Enable();
 #endif
 
 	SDL_GL_SwapWindow(window);
@@ -268,7 +264,7 @@ void OglSdlFinishUpdate(SDL_Window *window)
 	//			effects that want to take the old screen can do so after this
 	// well we dont need it on native res it seems
 #ifdef USE_FBO_OGL
-	if ((!I_CheckNativeRes() && !usefbo) || WipeInAction)
+	if (!usefbo && (!I_CheckNativeRes() || WipeInAction))
 #else
 	if (!I_CheckNativeRes() || WipeInAction)
 #endif

src/st_stuff.c

@@ -60,6 +60,22 @@ tic_t directortoggletimer = 0;
 // STATUS BAR DATA
 //
 
+patch_t *facerankprefix[MAXSKINS] = {}; // ranking
+patch_t *facewantprefix[MAXSKINS] = {}; // wanted
+patch_t *facemmapprefix[MAXSKINS] = {}; // minimap
+
+patch_t *localfacerankprefix[MAXLOCALSKINS] = {}; // ranking
+patch_t *localfacewantprefix[MAXLOCALSKINS] = {}; // wanted
+patch_t *localfacemmapprefix[MAXLOCALSKINS] = {}; // minimap
+
+/*char *facerankprefix_name[MAXSKINS]; // ranking
+char *facewantprefix_name[MAXSKINS]; // wanted
+char *facemmapprefix_name[MAXSKINS]; // minimap
+
+char *localfacerankprefix_name[MAXLOCALSKINS]; // ranking
+char *localfacewantprefix_name[MAXLOCALSKINS]; // wanted
+char *localfacemmapprefix_name[MAXLOCALSKINS]; // minimap*/
+
 // ------------------------------------------
 //             status bar overlay
 // ------------------------------------------
@@ -227,11 +243,30 @@ void ST_LoadGraphics(void)
 }
 
 // made separate so that skins code can reload custom face graphics
-void ST_LoadFaceGraphics(skin_t *skin)
+void ST_LoadFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 skinnum)
 {
-	skin->facerankprefix = W_CachePatchName(skin->facerank, PU_HUDGFX);
-	skin->facewantprefix = W_CachePatchName(skin->facewant, PU_HUDGFX);
-	skin->facemmapprefix = W_CachePatchName(skin->facemmap, PU_HUDGFX);
+	facerankprefix[skinnum] = W_CachePatchName(rankstr, PU_HUDGFX);
+	facewantprefix[skinnum] = W_CachePatchName(wantstr, PU_HUDGFX);
+	facemmapprefix[skinnum] = W_CachePatchName(mmapstr, PU_HUDGFX);
+
+	/*facerankprefix_name[skinnum] = rankstr;
+	facewantprefix_name[skinnum] = wantstr;
+	facemmapprefix_name[skinnum] = mmapstr;*/
+}
+
+void ST_LoadLocalFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 skinnum)
+{
+	localfacerankprefix[skinnum] = W_CachePatchName(rankstr, PU_HUDGFX);
+	localfacewantprefix[skinnum] = W_CachePatchName(wantstr, PU_HUDGFX);
+	localfacemmapprefix[skinnum] = W_CachePatchName(mmapstr, PU_HUDGFX);
+
+	/*localfacerankprefix_name[skinnum] = rankstr;
+	localfacewantprefix_name[skinnum] = wantstr;
+	localfacemmapprefix_name[skinnum] = mmapstr;*/
+
+	//CONS_Printf("Added rank prefix %s\n", rankstr);
+	//CONS_Printf("Added want prefix %s\n", wantstr);
+	//CONS_Printf("Added mmap prefix %s\n", mmapstr);
 }
 
 void ST_ReloadSkinFaceGraphics(void)
@@ -239,10 +274,10 @@ void ST_ReloadSkinFaceGraphics(void)
 	INT32 i;
 
 	for (i = 0; i < numskins; i++)
-		ST_LoadFaceGraphics(skins[i]);
+		ST_LoadFaceGraphics(skins[i].facerank, skins[i].facewant, skins[i].facemmap, i);
 
 	for (i = 0; i < numlocalskins; i++)
-		ST_LoadFaceGraphics(localskins[i]);
+		ST_LoadLocalFaceGraphics(localskins[i].facerank, localskins[i].facewant, localskins[i].facemmap, i);
 }
 
 static inline void ST_InitData(void)

src/st_stuff.h

@@ -58,7 +58,8 @@ void ST_UnloadGraphics(void);
 void ST_LoadGraphics(void);
 
 // face load graphics, called when skin changes
-void ST_LoadFaceGraphics(skin_t *skin);
+void ST_LoadFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 playernum);
+void ST_LoadLocalFaceGraphics(char *rankstr, char *wantstr, char *mmapstr, INT32 playernum);
 void ST_ReloadSkinFaceGraphics(void);
 
 // return if player a is in the same team as player b
@@ -75,6 +76,14 @@ extern UINT8 stplyrnum;
 
 extern lumpnum_t st_borderpatchnum;
 
+// patches, also used in intermission
+extern patch_t *facerankprefix[MAXSKINS]; // ranking
+extern patch_t *facewantprefix[MAXSKINS]; // wanted
+extern patch_t *facemmapprefix[MAXSKINS]; // minimap
+extern patch_t *localfacerankprefix[MAXLOCALSKINS]; // ranking
+extern patch_t *localfacewantprefix[MAXLOCALSKINS]; // wanted
+extern patch_t *localfacemmapprefix[MAXLOCALSKINS]; // minimap
+
 /** HUD location information (don't move this comment)
   */
 typedef struct

src/v_video.c

@@ -1261,11 +1261,11 @@ void V_DrawCroppedPatch(fixed_t x, fixed_t y, fixed_t pscale, INT32 scrn, patch_
 //
 void V_DrawContinueIcon(INT32 x, INT32 y, INT32 flags, INT32 skinnum, UINT8 skincolor)
 {
-	if (skinnum < 0 || skinnum >= numskins || (skins[skinnum]->flags & SF_HIRES))
+	if (skinnum < 0 || skinnum >= numskins || (skins[skinnum].flags & SF_HIRES))
 		V_DrawScaledPatch(x - 10, y - 14, flags, W_CachePatchName("CONTINS", PU_PATCH)); // Draw a star
 	else
 	{ // Find front angle of the first waiting frame of the character's actual sprites
-		spriteframe_t *sprframe = &skins[skinnum]->spritedef.spriteframes[2 & FF_FRAMEMASK];
+		spriteframe_t *sprframe = &skins[skinnum].spritedef.spriteframes[2 & FF_FRAMEMASK];
 		patch_t *patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
 		const UINT8 *colormap = R_GetTranslationColormap(skinnum, skincolor, GTC_CACHE);
 

src/y_inter.c

@@ -1190,7 +1190,8 @@ void Y_VoteDrawer(void)
 			if (player->skincolor)
 			{
 				UINT8 *colormap = R_GetTranslationColormap(player->skin, player->skincolor, GTC_CACHE);
-				patch_t *faceprefix = K_GetFacePrefix(player, R_GetPlayerSkinNum(player));
+
+				patch_t *faceprefix = K_GetFacePrefix(player, K_GetSkinNum(player));
 
 				if (K_UseHighResPortraits())
 					V_DrawSmallMappedPatch(x+24, y+9, V_SNAPTOLEFT, faceprefix, colormap);