src/CMakeLists.txt

@@ -127,6 +127,7 @@ set(SRB2_CORE_RENDER_SOURCES
 	r_splats.c
 	r_things.c
 	r_patch.c
+	r_rotsprite.c
 	r_portal.c
 
 	r_bsp.h
@@ -143,6 +144,8 @@ set(SRB2_CORE_RENDER_SOURCES
 	r_state.h
 	r_things.h
 	r_patch.h
+	r_rotsprite.h
+	r_patchtrees.h
 	r_portal.h
 )
 

src/Makefile

@@ -470,6 +470,7 @@ OBJS:=$(i_main_o) \
 		$(OBJDIR)/r_splats.o \
 		$(OBJDIR)/r_things.o \
 		$(OBJDIR)/r_patch.o \
+		$(OBJDIR)/r_rotsprite.o \
 		$(OBJDIR)/r_portal.o \
 		$(OBJDIR)/screen.o   \
 		$(OBJDIR)/v_video.o  \

src/android/i_video.c

@@ -9,6 +9,7 @@
 #include "utils/Log.h"
 
 rendermode_t rendermode = render_soft;
+rendermode_t chosenrendermode = render_none;
 
 boolean highcolor = false;
 
@@ -40,8 +41,6 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h)
   return 0;
 }
 
-void VID_PrepareModeList(void){}
-
 INT32 VID_SetMode(INT32 modenum)
 {
   vid.modenum = 0;
@@ -52,7 +51,11 @@ INT32 VID_SetMode(INT32 modenum)
   return 0;
 }
 
-void VID_CheckRenderer(void) {}
+boolean VID_CheckRenderer(void)
+{
+	return false;
+}
+
 void VID_CheckGLLoaded(rendermode_t oldrender) {}
 
 const char *VID_GetModeName(INT32 modenum)

src/console.c

@@ -45,7 +45,8 @@
 #define MAXHUDLINES 20
 
 static boolean con_started = false; // console has been initialised
-       boolean con_startup = false; // true at game startup, screen need refreshing
+       boolean con_startup = false; // true at game startup
+       boolean con_refresh = false; // screen needs refreshing
 static boolean con_forcepic = true; // at startup toggle console translucency when first off
        boolean con_recalc;          // set true when screen size has changed
 
@@ -402,11 +403,11 @@ void CON_Init(void)
 	con_destlines = vid.height;
 	con_curlines = vid.height;
 
-
 	if (!dedicated)
 	{
 		con_started = true;
-		con_startup = true; // need explicit screen refresh until we are in Doom loop
+		con_startup = true;
+		con_refresh = true; // needs explicit screen refresh until we are in the main game loop
 		consoletoggle = false;
 		CV_RegisterVar(&cons_msgtimeout);
 		CV_RegisterVar(&cons_hudlines);
@@ -419,7 +420,8 @@ void CON_Init(void)
 	else
 	{
 		con_started = true;
-		con_startup = false; // need explicit screen refresh until we are in Doom loop
+		con_startup = false;
+		con_refresh = false; // disable explicit screen refresh
 		consoletoggle = true;
 	}
 }
@@ -1293,16 +1295,16 @@ void CONS_Printf(const char *fmt, ...)
 	con_scrollup = 0;
 
 	// if not in display loop, force screen update
-	if (con_startup && (!setrenderneeded))
+	if (con_refresh)
 	{
-#ifdef _WINDOWS
-		patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_PATCH);
-
-		// Jimita: CON_DrawBackpic just called V_DrawScaledPatch
-		V_DrawScaledPatch(0, 0, 0, con_backpic);
-
-		W_UnlockCachedPatch(con_backpic);
-		I_LoadingScreen(txt);				// Win32/OS2 only
+#if defined(_WINDOWS)
+		if (con_startup)
+		{
+			patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_PATCH);
+			V_DrawScaledPatch(0, 0, 0, con_backpic);
+			W_UnlockCachedPatch(con_backpic);
+			I_LoadingScreen(txt);
+		}
 #else
 		// here we display the console text
 		CON_Drawer();
@@ -1369,7 +1371,7 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
 //
 void CONS_Error(const char *msg)
 {
-#ifdef RPC_NO_WINDOWS_H
+#if defined(RPC_NO_WINDOWS_H) && defined(_WINDOWS)
 	if (!graphics_started)
 	{
 		MessageBoxA(vid.WndParent, msg, "SRB2 Warning", MB_OK);
@@ -1648,9 +1650,6 @@ void CON_Drawer(void)
 	if (!con_started || !graphics_started)
 		return;
 
-	if (needpatchrecache)
-		HU_LoadGraphics();
-
 	if (con_recalc)
 	{
 		CON_RecalcSize();

src/console.h

@@ -20,8 +20,12 @@ boolean CON_Responder(event_t *ev);
 // set true when screen size has changed, to adapt console
 extern boolean con_recalc;
 
+// console being displayed at game startup
 extern boolean con_startup;
 
+// needs explicit screen refresh until we are in the main game loop
+extern boolean con_refresh;
+
 // top clip value for view render: do not draw part of view hidden by console
 extern INT32 con_clipviewtop;
 

src/d_main.c

@@ -110,8 +110,6 @@ boolean devparm = false; // started game with -devparm
 boolean singletics = false; // timedemo
 boolean lastdraw = false;
 
-static void D_CheckRendererState(void);
-
 postimg_t postimgtype = postimg_none;
 INT32 postimgparam;
 postimg_t postimgtype2 = postimg_none;
@@ -222,7 +220,6 @@ INT16 wipetypepost = -1;
 
 static void D_Display(void)
 {
-	INT32 setrenderstillneeded = 0;
 	boolean forcerefresh = false;
 	static boolean wipe = false;
 	INT32 wipedefindex = 0;
@@ -233,60 +230,26 @@ static void D_Display(void)
 	if (nodrawers)
 		return; // for comparative timing/profiling
 
-	// Lactozilla: Switching renderers works by checking
-	// if the game has to do it right when the frame
-	// needs to render. If so, five things will happen:
-	// 1. Interface functions will be called so
-	//    that switching to OpenGL creates a
-	//    GL context, and switching to Software
-	//    allocates screen buffers.
-	// 2. Software will set drawer functions,
-	//    and OpenGL will load textures and
-	//    create plane polygons, if necessary.
-	// 3. Functions related to switching video
-	//    modes (resolution) are called.
-	// 4. Patch data is freed from memory,
-	//    and recached if necessary.
-	// 5. The frame is ready to be drawn!
-
-	// stop movie if needs to change renderer
-	if (setrenderneeded && (moviemode == MM_APNG))
-		M_StopMovie();
-
-	// check for change of renderer or screen size (video mode)
+	// Check for change of renderer or screen size (video mode)
 	if ((setrenderneeded || setmodeneeded) && !wipe)
-	{
-		if (setrenderneeded)
-		{
-			CONS_Debug(DBG_RENDER, "setrenderneeded set (%d)\n", setrenderneeded);
-			setrenderstillneeded = setrenderneeded;
-		}
 		SCR_SetMode(); // change video mode
-	}
 
-	if (vid.recalc || setrenderstillneeded)
-	{
+	// Recalc the screen
+	if (vid.recalc)
 		SCR_Recalc(); // NOTE! setsizeneeded is set by SCR_Recalc()
-#ifdef HWRENDER
-		// Shoot! The screen texture was flushed!
-		if ((rendermode == render_opengl) && (gamestate == GS_INTERMISSION))
-			usebuffer = false;
-#endif
-	}
 
+	// View morph
 	if (rendermode == render_soft && !splitscreen)
 		R_CheckViewMorph();
 
-	// change the view size if needed
-	if (setsizeneeded || setrenderstillneeded)
+	// Change the view size if needed
+	// Set by changing video mode or renderer
+	if (setsizeneeded)
 	{
-		R_ExecuteSetViewSize();
+		R_SetViewSize();
 		forcerefresh = true; // force background redraw
 	}
 
-	// Lactozilla: Renderer switching
-	D_CheckRendererState();
-
 	// draw buffered stuff to screen
 	// Used only by linux GGI version
 	I_UpdateNoBlit();
@@ -426,11 +389,11 @@ static void D_Display(void)
 				{
 					topleft = screens[0] + viewwindowy*vid.width + viewwindowx;
 					objectsdrawn = 0;
-	#ifdef HWRENDER
+#ifdef HWRENDER
 					if (rendermode != render_soft)
 						HWR_RenderPlayerView(0, &players[displayplayer]);
 					else
-	#endif
+#endif
 					if (rendermode != render_none)
 						R_RenderPlayerView(&players[displayplayer]);
 				}
@@ -438,11 +401,11 @@ static void D_Display(void)
 				// render the second screen
 				if (splitscreen && players[secondarydisplayplayer].mo)
 				{
-	#ifdef HWRENDER
+#ifdef HWRENDER
 					if (rendermode != render_soft)
 						HWR_RenderPlayerView(1, &players[secondarydisplayplayer]);
 					else
-	#endif
+#endif
 					if (rendermode != render_none)
 					{
 						viewwindowy = vid.height / 2;
@@ -595,13 +558,13 @@ static void D_Display(void)
 			s[sizeof s - 1] = '\0';
 
 			snprintf(s, sizeof s - 1, "get %d b/s", getbps);
-			V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-ST_HEIGHT-40, V_YELLOWMAP, s);
+			V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-32-40, V_YELLOWMAP, s);
 			snprintf(s, sizeof s - 1, "send %d b/s", sendbps);
-			V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-ST_HEIGHT-30, V_YELLOWMAP, s);
+			V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-32-30, V_YELLOWMAP, s);
 			snprintf(s, sizeof s - 1, "GameMiss %.2f%%", gamelostpercent);
-			V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-ST_HEIGHT-20, V_YELLOWMAP, s);
+			V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-32-20, V_YELLOWMAP, s);
 			snprintf(s, sizeof s - 1, "SysMiss %.2f%%", lostpercent);
-			V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-ST_HEIGHT-10, V_YELLOWMAP, s);
+			V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-32-10, V_YELLOWMAP, s);
 		}
 
 		if (cv_renderstats.value)
@@ -679,26 +642,6 @@ static void D_Display(void)
 		I_FinishUpdate(); // page flip or blit buffer
 		rs_swaptime = I_GetTimeMicros() - rs_swaptime;
 	}
-
-	needpatchflush = false;
-	needpatchrecache = false;
-}
-
-// Check the renderer's state
-// after a possible renderer switch.
-void D_CheckRendererState(void)
-{
-	// flush all patches from memory
-	if (needpatchflush)
-	{
-		Z_FlushCachedPatches();
-		needpatchflush = false;
-	}
-
-	// some patches have been freed,
-	// so cache them again
-	if (needpatchrecache)
-		R_ReloadHUDGraphics();
 }
 
 // =========================================================================
@@ -723,7 +666,8 @@ void D_SRB2Loop(void)
 
 	oldentertics = I_GetTime();
 
-	// end of loading screen: CONS_Printf() will no more call FinishUpdate()
+	// end of loading screen: CONS_Printf() will no more call I_FinishUpdate()
+	con_refresh = false;
 	con_startup = false;
 
 	// make sure to do a d_display to init mode _before_ load a level
@@ -1423,28 +1367,27 @@ void D_SRB2Main(void)
 	G_LoadGameData();
 
 #if (defined (__unix__) && !defined (MSDOS)) || defined (UNIXCOMMON) || defined (HAVE_SDL)
-	VID_PrepareModeList(); // Regenerate Modelist according to cv_fullscreen
+	// Under SDL2, we just use the windowed modes list, and scale in windowed fullscreen.
+	allow_fullscreen = true;
 #endif
 
 	// set user default mode or mode set at cmdline
 	SCR_CheckDefaultMode();
 
-	// Lactozilla: Does the render mode need to change?
-	if ((setrenderneeded != 0) && (setrenderneeded != rendermode))
+	// Check if the render mode needs to change.
+	if (setrenderneeded)
 	{
 		CONS_Printf(M_GetText("Switching the renderer...\n"));
-		Z_PreparePatchFlush();
 
-		// set needpatchflush / needpatchrecache true for D_CheckRendererState
-		needpatchflush = true;
-		needpatchrecache = true;
+		// Switch the renderer in the interface
+		if (VID_CheckRenderer())
+			con_refresh = true; // Allow explicit screen refresh again
 
 		// Set cv_renderer to the new render mode
-		VID_CheckRenderer();
-		SCR_ChangeRendererCVars(rendermode);
-
-		// check the renderer's state
-		D_CheckRendererState();
+		CV_StealthSetValue(&cv_renderer, rendermode);
+#ifdef HWRENDER
+		CV_StealthSetValue(&cv_newrenderer, rendermode);
+#endif
 	}
 
 	wipegamestate = gamestate;

src/dehacked.c

@@ -1041,11 +1041,6 @@ static void readspriteinfo(MYFILE *f, INT32 num, boolean sprite2)
 	spriteinfo_t *info = Z_Calloc(sizeof(spriteinfo_t), PU_STATIC, NULL);
 	info->available = true;
 
-#ifdef ROTSPRITE
-	if ((sprites != NULL) && (!sprite2))
-		R_FreeSingleRotSprite(&sprites[num]);
-#endif
-
 	do
 	{
 		lastline = f->curpos;
@@ -1164,19 +1159,18 @@ static void readspriteinfo(MYFILE *f, INT32 num, boolean sprite2)
 				if (sprite2)
 				{
 					INT32 i;
+
 					if (!foundskins)
 					{
 						deh_warning("Sprite2 %s: no skins specified", spr2names[num]);
 						break;
 					}
+
 					for (i = 0; i < foundskins; i++)
 					{
 						size_t skinnum = skinnumbers[i];
 						skin_t *skin = &skins[skinnum];
 						spriteinfo_t *sprinfo = skin->sprinfo;
-#ifdef ROTSPRITE
-						R_FreeSkinRotSprite(skinnum);
-#endif
 						M_Memcpy(&sprinfo[num], info, sizeof(spriteinfo_t));
 					}
 				}
@@ -9951,6 +9945,11 @@ struct {
 	{"ANGLE_337h",ANGLE_337h},
 	{"ANGLE_MAX",ANGLE_MAX},
 
+	// Sprite rotation
+	{"ROTANGLES",ROTANGLES},
+	{"ROTANGDIFF",ROTANGDIFF},
+	{"FEETADJUST",FEETADJUST},
+
 	// P_Chase directions (dirtype_t)
 	{"DI_NODIR",DI_NODIR},
 	{"DI_EAST",DI_EAST},
@@ -9963,7 +9962,7 @@ struct {
 	{"DI_SOUTHEAST",DI_SOUTHEAST},
 	{"NUMDIRS",NUMDIRS},
 
-	// Sprite rotation axis (rotaxis_t)
+	// Sprite rotation axes (rotaxis_t)
 	{"ROTAXIS_X",ROTAXIS_X},
 	{"ROTAXIS_Y",ROTAXIS_Y},
 	{"ROTAXIS_Z",ROTAXIS_Z},

src/djgppdos/vid_vesa.c

@@ -378,10 +378,12 @@ INT32 VID_SetMode (INT32 modenum)  //, UINT8 *palette)
 	return 1;
 }
 
-void VID_CheckRenderer(void) {}
-void VID_CheckGLLoaded(rendermode_t oldrender) {}
-
+boolean VID_CheckRenderer(void)
+{
+	return false;
+}
 
+void VID_CheckGLLoaded(rendermode_t oldrender) {}
 
 // converts a segm:offs 32bit pair to a 32bit flat ptr
 #if 0
@@ -739,7 +741,7 @@ static INT32 VGA_InitMode (viddef_t *lvid, vmode_t *currentmodep)
 	// here it is the standard VGA 64k window, not an LFB
 	// (you could have 320x200x256c with LFB in the vesa modes)
 	lvid->direct = (UINT8 *) real2ptr (0xa0000);
-	lvid->u.numpages = 1;
+	lvid->numpages = 1;
 	lvid->bpp = currentmodep->bytesperpixel;
 
 	return 1;
@@ -773,7 +775,7 @@ INT32 VID_VesaInitMode (viddef_t *lvid, vmode_t *currentmodep)
 #endif
 
 	//added:20-01-98:no page flipping now... TO DO!!!
-	lvid->u.numpages = 1;
+	lvid->numpages = 1;
 
 	// clean up any old vid buffer lying around, alloc new if needed
 	if (!VID_FreeAndAllocVidbuffer (lvid))

src/doomdef.h

@@ -629,13 +629,11 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
 /// \note   Required for proper collision with moving sloped surfaces that have sector specials on them.
 #define SECTORSPECIALSAFTERTHINK
 
-/// Cache patches in Lua in a way that renderer switching will work flawlessly.
-//#define LUA_PATCH_SAFETY
-
 /// Sprite rotation
 #define ROTSPRITE
 #define ROTANGLES 72 // Needs to be a divisor of 360 (45, 60, 90, 120...)
 #define ROTANGDIFF (360 / ROTANGLES)
+#define ROTSPRITE_RENDER_PATCHES
 
 /// PNG support
 #ifndef HAVE_PNG

src/dummy/i_video.c

@@ -3,6 +3,7 @@
 #include "../i_video.h"
 
 rendermode_t rendermode = render_none;
+rendermode_t chosenrendermode = render_none;
 
 boolean highcolor = false;
 
@@ -32,15 +33,17 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h)
 	return 0;
 }
 
-void VID_PrepareModeList(void){}
-
 INT32 VID_SetMode(INT32 modenum)
 {
 	(void)modenum;
 	return 0;
 }
 
-void VID_CheckRenderer(void) {}
+boolean VID_CheckRenderer(void)
+{
+	return false;
+}
+
 void VID_CheckGLLoaded(rendermode_t oldrender) {}
 
 const char *VID_GetModeName(INT32 modenum)

src/f_finale.c

@@ -100,21 +100,21 @@ INT16 curttloop;
 UINT16 curtttics;
 
 // ttmode old
-static patch_t *ttbanner; // white banner with "robo blast" and "2"
-static patch_t *ttwing; // wing background
-static patch_t *ttsonic; // "SONIC"
-static patch_t *ttswave1; // Title Sonics
-static patch_t *ttswave2;
-static patch_t *ttswip1;
-static patch_t *ttsprep1;
-static patch_t *ttsprep2;
-static patch_t *ttspop1;
-static patch_t *ttspop2;
-static patch_t *ttspop3;
-static patch_t *ttspop4;
-static patch_t *ttspop5;
-static patch_t *ttspop6;
-static patch_t *ttspop7;
+static patch_t **ttbanner; // white banner with "robo blast" and "2"
+static patch_t **ttwing; // wing background
+static patch_t **ttsonic; // "SONIC"
+static patch_t **ttswave1; // Title Sonics
+static patch_t **ttswave2;
+static patch_t **ttswip1;
+static patch_t **ttsprep1;
+static patch_t **ttsprep2;
+static patch_t **ttspop1;
+static patch_t **ttspop2;
+static patch_t **ttspop3;
+static patch_t **ttspop4;
+static patch_t **ttspop5;
+static patch_t **ttspop6;
+static patch_t **ttspop7;
 
 // ttmode alacroix
 static SINT8 testttscale = 0;
@@ -122,51 +122,51 @@ static SINT8 activettscale = 0;
 boolean ttavailable[6];
 boolean ttloaded[6];
 
-static patch_t *ttribb[6][TTMAX_ALACROIX];
-static patch_t *ttsont[6][TTMAX_ALACROIX];
-static patch_t *ttrobo[6][TTMAX_ALACROIX];
-static patch_t *tttwot[6][TTMAX_ALACROIX];
-static patch_t *ttembl[6][TTMAX_ALACROIX];
-static patch_t *ttrbtx[6][TTMAX_ALACROIX];
-static patch_t *ttsoib[6][TTMAX_ALACROIX];
-static patch_t *ttsoif[6][TTMAX_ALACROIX];
-static patch_t *ttsoba[6][TTMAX_ALACROIX];
-static patch_t *ttsobk[6][TTMAX_ALACROIX];
-static patch_t *ttsodh[6][TTMAX_ALACROIX];
-static patch_t *tttaib[6][TTMAX_ALACROIX];
-static patch_t *tttaif[6][TTMAX_ALACROIX];
-static patch_t *tttaba[6][TTMAX_ALACROIX];
-static patch_t *tttabk[6][TTMAX_ALACROIX];
-static patch_t *tttabt[6][TTMAX_ALACROIX];
-static patch_t *tttaft[6][TTMAX_ALACROIX];
-static patch_t *ttknib[6][TTMAX_ALACROIX];
-static patch_t *ttknif[6][TTMAX_ALACROIX];
-static patch_t *ttknba[6][TTMAX_ALACROIX];
-static patch_t *ttknbk[6][TTMAX_ALACROIX];
-static patch_t *ttkndh[6][TTMAX_ALACROIX];
-
-#define TTEMBL (ttembl[activettscale-1])
-#define TTRIBB (ttribb[activettscale-1])
-#define TTSONT (ttsont[activettscale-1])
-#define TTROBO (ttrobo[activettscale-1])
-#define TTTWOT (tttwot[activettscale-1])
-#define TTRBTX (ttrbtx[activettscale-1])
-#define TTSOIB (ttsoib[activettscale-1])
-#define TTSOIF (ttsoif[activettscale-1])
-#define TTSOBA (ttsoba[activettscale-1])
-#define TTSOBK (ttsobk[activettscale-1])
-#define TTSODH (ttsodh[activettscale-1])
-#define TTTAIB (tttaib[activettscale-1])
-#define TTTAIF (tttaif[activettscale-1])
-#define TTTABA (tttaba[activettscale-1])
-#define TTTABK (tttabk[activettscale-1])
-#define TTTABT (tttabt[activettscale-1])
-#define TTTAFT (tttaft[activettscale-1])
-#define TTKNIB (ttknib[activettscale-1])
-#define TTKNIF (ttknif[activettscale-1])
-#define TTKNBA (ttknba[activettscale-1])
-#define TTKNBK (ttknbk[activettscale-1])
-#define TTKNDH (ttkndh[activettscale-1])
+static patch_t **ttribb[6][TTMAX_ALACROIX];
+static patch_t **ttsont[6][TTMAX_ALACROIX];
+static patch_t **ttrobo[6][TTMAX_ALACROIX];
+static patch_t **tttwot[6][TTMAX_ALACROIX];
+static patch_t **ttembl[6][TTMAX_ALACROIX];
+static patch_t **ttrbtx[6][TTMAX_ALACROIX];
+static patch_t **ttsoib[6][TTMAX_ALACROIX];
+static patch_t **ttsoif[6][TTMAX_ALACROIX];
+static patch_t **ttsoba[6][TTMAX_ALACROIX];
+static patch_t **ttsobk[6][TTMAX_ALACROIX];
+static patch_t **ttsodh[6][TTMAX_ALACROIX];
+static patch_t **tttaib[6][TTMAX_ALACROIX];
+static patch_t **tttaif[6][TTMAX_ALACROIX];
+static patch_t **tttaba[6][TTMAX_ALACROIX];
+static patch_t **tttabk[6][TTMAX_ALACROIX];
+static patch_t **tttabt[6][TTMAX_ALACROIX];
+static patch_t **tttaft[6][TTMAX_ALACROIX];
+static patch_t **ttknib[6][TTMAX_ALACROIX];
+static patch_t **ttknif[6][TTMAX_ALACROIX];
+static patch_t **ttknba[6][TTMAX_ALACROIX];
+static patch_t **ttknbk[6][TTMAX_ALACROIX];
+static patch_t **ttkndh[6][TTMAX_ALACROIX];
+
+#define TTEMBL *(ttembl[activettscale-1])
+#define TTRIBB *(ttribb[activettscale-1])
+#define TTSONT *(ttsont[activettscale-1])
+#define TTROBO *(ttrobo[activettscale-1])
+#define TTTWOT *(tttwot[activettscale-1])
+#define TTRBTX *(ttrbtx[activettscale-1])
+#define TTSOIB *(ttsoib[activettscale-1])
+#define TTSOIF *(ttsoif[activettscale-1])
+#define TTSOBA *(ttsoba[activettscale-1])
+#define TTSOBK *(ttsobk[activettscale-1])
+#define TTSODH *(ttsodh[activettscale-1])
+#define TTTAIB *(tttaib[activettscale-1])
+#define TTTAIF *(tttaif[activettscale-1])
+#define TTTABA *(tttaba[activettscale-1])
+#define TTTABK *(tttabk[activettscale-1])
+#define TTTABT *(tttabt[activettscale-1])
+#define TTTAFT *(tttaft[activettscale-1])
+#define TTKNIB *(ttknib[activettscale-1])
+#define TTKNIF *(ttknif[activettscale-1])
+#define TTKNBA *(ttknba[activettscale-1])
+#define TTKNBK *(ttknbk[activettscale-1])
+#define TTKNDH *(ttkndh[activettscale-1])
 
 static boolean sonic_blink = false;
 static boolean sonic_blink_twice = false;
@@ -185,18 +185,18 @@ static INT32 knux_idle_start = 0;
 static INT32 knux_idle_end = 0;
 
 // ttmode user
-static patch_t *ttuser[TTMAX_USER];
+static patch_t **ttuser[TTMAX_USER];
 static INT32 ttuser_count = 0;
 
 static boolean goodending;
-static patch_t *endbrdr[2]; // border - blue, white, pink - where have i seen those colours before?
-static patch_t *endbgsp[3]; // nebula, sun, planet
-static patch_t *endegrk[2]; // eggrock - replaced midway through good ending
-static patch_t *endfwrk[3]; // firework - replaced with skin when good ending
-static patch_t *endspkl[3]; // sparkle
-static patch_t *endglow[2]; // glow aura - replaced with black rock's midway through good ending
-static patch_t *endxpld[4]; // mini explosion
-static patch_t *endescp[5]; // escape pod + flame
+static patch_t **endbrdr[2]; // border - blue, white, pink - where have i seen those colours before?
+static patch_t **endbgsp[3]; // nebula, sun, planet
+static patch_t **endegrk[2]; // eggrock - replaced midway through good ending
+static patch_t **endfwrk[3]; // firework - replaced with skin when good ending
+static patch_t **endspkl[3]; // sparkle
+static patch_t **endglow[2]; // glow aura - replaced with black rock's midway through good ending
+static patch_t **endxpld[4]; // mini explosion
+static patch_t **endescp[5]; // escape pod + flame
 static INT32 sparkloffs[3][2]; // eggrock explosions/blackrock sparkles
 static INT32 sparklloop;
 
@@ -1772,32 +1772,32 @@ void F_GameEvaluationTicker(void)
 
 static void F_CacheEnding(void)
 {
-	endbrdr[1] = W_CachePatchName("ENDBRDR1", PU_PATCH);
+	endbrdr[1] = (patch_t **)W_GetPatchPointerFromName("ENDBRDR1", PU_PATCH);
 
-	endegrk[0] = W_CachePatchName("ENDEGRK0", PU_PATCH);
-	endegrk[1] = W_CachePatchName("ENDEGRK1", PU_PATCH);
+	endegrk[0] = (patch_t **)W_GetPatchPointerFromName("ENDEGRK0", PU_PATCH);
+	endegrk[1] = (patch_t **)W_GetPatchPointerFromName("ENDEGRK1", PU_PATCH);
 
-	endglow[0] = W_CachePatchName("ENDGLOW0", PU_PATCH);
-	endglow[1] = W_CachePatchName("ENDGLOW1", PU_PATCH);
+	endglow[0] = (patch_t **)W_GetPatchPointerFromName("ENDGLOW0", PU_PATCH);
+	endglow[1] = (patch_t **)W_GetPatchPointerFromName("ENDGLOW1", PU_PATCH);
 
-	endbgsp[0] = W_CachePatchName("ENDBGSP0", PU_PATCH);
-	endbgsp[1] = W_CachePatchName("ENDBGSP1", PU_PATCH);
-	endbgsp[2] = W_CachePatchName("ENDBGSP2", PU_PATCH);
+	endbgsp[0] = (patch_t **)W_GetPatchPointerFromName("ENDBGSP0", PU_PATCH);
+	endbgsp[1] = (patch_t **)W_GetPatchPointerFromName("ENDBGSP1", PU_PATCH);
+	endbgsp[2] = (patch_t **)W_GetPatchPointerFromName("ENDBGSP2", PU_PATCH);
 
-	endspkl[0] = W_CachePatchName("ENDSPKL0", PU_PATCH);
-	endspkl[1] = W_CachePatchName("ENDSPKL1", PU_PATCH);
-	endspkl[2] = W_CachePatchName("ENDSPKL2", PU_PATCH);
+	endspkl[0] = (patch_t **)W_GetPatchPointerFromName("ENDSPKL0", PU_PATCH);
+	endspkl[1] = (patch_t **)W_GetPatchPointerFromName("ENDSPKL1", PU_PATCH);
+	endspkl[2] = (patch_t **)W_GetPatchPointerFromName("ENDSPKL2", PU_PATCH);
 
-	endxpld[0] = W_CachePatchName("ENDXPLD0", PU_PATCH);
-	endxpld[1] = W_CachePatchName("ENDXPLD1", PU_PATCH);
-	endxpld[2] = W_CachePatchName("ENDXPLD2", PU_PATCH);
-	endxpld[3] = W_CachePatchName("ENDXPLD3", PU_PATCH);
+	endxpld[0] = (patch_t **)W_GetPatchPointerFromName("ENDXPLD0", PU_PATCH);
+	endxpld[1] = (patch_t **)W_GetPatchPointerFromName("ENDXPLD1", PU_PATCH);
+	endxpld[2] = (patch_t **)W_GetPatchPointerFromName("ENDXPLD2", PU_PATCH);
+	endxpld[3] = (patch_t **)W_GetPatchPointerFromName("ENDXPLD3", PU_PATCH);
 
-	endescp[0] = W_CachePatchName("ENDESCP0", PU_PATCH);
-	endescp[1] = W_CachePatchName("ENDESCP1", PU_PATCH);
-	endescp[2] = W_CachePatchName("ENDESCP2", PU_PATCH);
-	endescp[3] = W_CachePatchName("ENDESCP3", PU_PATCH);
-	endescp[4] = W_CachePatchName("ENDESCP4", PU_PATCH);
+	endescp[0] = (patch_t **)W_GetPatchPointerFromName("ENDESCP0", PU_PATCH);
+	endescp[1] = (patch_t **)W_GetPatchPointerFromName("ENDESCP1", PU_PATCH);
+	endescp[2] = (patch_t **)W_GetPatchPointerFromName("ENDESCP2", PU_PATCH);
+	endescp[3] = (patch_t **)W_GetPatchPointerFromName("ENDESCP3", PU_PATCH);
+	endescp[4] = (patch_t **)W_GetPatchPointerFromName("ENDESCP4", PU_PATCH);
 
 	// so we only need to check once
 	if ((goodending = ALL7EMERALDS(emeralds)))
@@ -1810,41 +1810,41 @@ static void F_CacheEnding(void)
 			sprdef = &skins[skinnum].sprites[SPR2_XTRA];
 			// character head, skin specific
 			sprframe = &sprdef->spriteframes[XTRA_ENDING];
-			endfwrk[0] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
+			endfwrk[0] = (patch_t **)W_GetPatchPointer(sprframe->lumppat[0], PU_PATCH);
 			sprframe = &sprdef->spriteframes[XTRA_ENDING+1];
-			endfwrk[1] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
+			endfwrk[1] = (patch_t **)W_GetPatchPointer(sprframe->lumppat[0], PU_PATCH);
 			sprframe = &sprdef->spriteframes[XTRA_ENDING+2];
-			endfwrk[2] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
+			endfwrk[2] = (patch_t **)W_GetPatchPointer(sprframe->lumppat[0], PU_PATCH);
 		}
 		else // Show a star if your character doesn't have an ending firework display. (Basically the MISSINGs for this)
 		{
-			endfwrk[0] = W_CachePatchName("ENDFWRK3", PU_PATCH);
-			endfwrk[1] = W_CachePatchName("ENDFWRK4", PU_PATCH);
-			endfwrk[2] = W_CachePatchName("ENDFWRK5", PU_PATCH);
+			endfwrk[0] = (patch_t **)W_GetPatchPointerFromName("ENDFWRK3", PU_PATCH);
+			endfwrk[1] = (patch_t **)W_GetPatchPointerFromName("ENDFWRK4", PU_PATCH);
+			endfwrk[2] = (patch_t **)W_GetPatchPointerFromName("ENDFWRK5", PU_PATCH);
 		}
 
-		endbrdr[0] = W_CachePatchName("ENDBRDR2", PU_PATCH);
+		endbrdr[0] = (patch_t **)W_GetPatchPointerFromName("ENDBRDR2", PU_PATCH);
 	}
 	else
 	{
 		// eggman, skin nonspecific
-		endfwrk[0] = W_CachePatchName("ENDFWRK0", PU_PATCH);
-		endfwrk[1] = W_CachePatchName("ENDFWRK1", PU_PATCH);
-		endfwrk[2] = W_CachePatchName("ENDFWRK2", PU_PATCH);
+		endfwrk[0] = (patch_t **)W_GetPatchPointerFromName("ENDFWRK0", PU_PATCH);
+		endfwrk[1] = (patch_t **)W_GetPatchPointerFromName("ENDFWRK1", PU_PATCH);
+		endfwrk[2] = (patch_t **)W_GetPatchPointerFromName("ENDFWRK2", PU_PATCH);
 
-		endbrdr[0] = W_CachePatchName("ENDBRDR0", PU_LEVEL);
+		endbrdr[0] = (patch_t **)W_GetPatchPointerFromName("ENDBRDR0", PU_LEVEL);
 	}
 }
 
 static void F_CacheGoodEnding(void)
 {
-	endegrk[0] = W_CachePatchName("ENDEGRK2", PU_PATCH);
-	endegrk[1] = W_CachePatchName("ENDEGRK3", PU_PATCH);
+	endegrk[0] = (patch_t **)W_GetPatchPointerFromName("ENDEGRK2", PU_PATCH);
+	endegrk[1] = (patch_t **)W_GetPatchPointerFromName("ENDEGRK3", PU_PATCH);
 
-	endglow[0] = W_CachePatchName("ENDGLOW2", PU_PATCH);
-	endglow[1] = W_CachePatchName("ENDGLOW3", PU_PATCH);
+	endglow[0] = (patch_t **)W_GetPatchPointerFromName("ENDGLOW2", PU_PATCH);
+	endglow[1] = (patch_t **)W_GetPatchPointerFromName("ENDGLOW3", PU_PATCH);
 
-	endxpld[0] = W_CachePatchName("ENDEGRK4", PU_PATCH);
+	endxpld[0] = (patch_t **)W_GetPatchPointerFromName("ENDEGRK4", PU_PATCH);
 }
 
 void F_StartEnding(void)
@@ -1901,13 +1901,6 @@ void F_EndingDrawer(void)
 	INT32 x, y, i, j, parallaxticker;
 	patch_t *rockpat;
 
-	if (needpatchrecache)
-	{
-		F_CacheEnding();
-		if (goodending && finalecount >= INFLECTIONPOINT) // time to swap some assets
-			F_CacheGoodEnding();
-	}
-
 	if (!goodending || finalecount < INFLECTIONPOINT)
 		rockpat = W_CachePatchName("ROID0000", PU_PATCH);
 	else
@@ -1934,25 +1927,25 @@ void F_EndingDrawer(void)
 			if (trans < 0)
 			{
 				trans = -trans;
-				V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, 0, endbrdr[0]);
+				V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, 0, *endbrdr[0]);
 			}
-			V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, trans<<V_ALPHASHIFT, endbrdr[1]);
+			V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, trans<<V_ALPHASHIFT, *endbrdr[1]);
 		}
 		else if (finalecount == 20)
-			V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, 0, endbrdr[0]);
+			V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, 0, *endbrdr[0]);
 	}
 	else if (goodending && (parallaxticker == -2 || !parallaxticker))
 	{
 		V_DrawFill(24, 24, BASEVIDWIDTH-48, BASEVIDHEIGHT-48, 0);
-		V_DrawFixedPatch(x+i, y+j, FRACUNIT, 0, endegrk[0],
+		V_DrawFixedPatch(x+i, y+j, FRACUNIT, 0, *endegrk[0],
 			R_GetTranslationColormap(TC_BLINK, SKINCOLOR_BLACK, GTC_CACHE));
-		//V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, 0, endbrdr[1]);
+		//V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, 0, *endbrdr[1]);
 	}
 	else if (goodending && parallaxticker == -1)
 	{
 		V_DrawFixedPatch(x+i, y+j, FRACUNIT, 0, rockpat,
 			R_GetTranslationColormap(TC_ALLWHITE, 0, GTC_CACHE));
-		V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, 0, endbrdr[1]);
+		V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, 0, *endbrdr[1]);
 	}
 	else
 	{
@@ -1962,14 +1955,14 @@ void F_EndingDrawer(void)
 
 		if (parallaxticker < 75) // f background's supposed to be visible
 		{
-			V_DrawFixedPatch(-(x/10), -(y/10), FRACUNIT, 0, endbgsp[0], NULL); // nebula
-			V_DrawFixedPatch(-(x/5),  -(y/5),  FRACUNIT, 0, endbgsp[1], NULL); // sun
-			V_DrawFixedPatch(     0,  -(y/2),  FRACUNIT, 0, endbgsp[2], NULL); // planet
+			V_DrawFixedPatch(-(x/10), -(y/10), FRACUNIT, 0, *endbgsp[0], NULL); // nebula
+			V_DrawFixedPatch(-(x/5),  -(y/5),  FRACUNIT, 0, *endbgsp[1], NULL); // sun
+			V_DrawFixedPatch(     0,  -(y/2),  FRACUNIT, 0, *endbgsp[2], NULL); // planet
 
 			// player's escape pod
 			V_DrawFixedPatch((200<<FRACBITS)+(finalecount<<(FRACBITS-2)),
 				(100<<FRACBITS)+(finalecount<<(FRACBITS-2)),
-				FRACUNIT, 0, endescp[4], NULL);
+				FRACUNIT, 0, *endescp[4], NULL);
 			if (parallaxticker > -19)
 			{
 				INT32 trans = (-parallaxticker)>>1;
@@ -1977,7 +1970,7 @@ void F_EndingDrawer(void)
 					trans = 0;
 				V_DrawFixedPatch((200<<FRACBITS)+(finalecount<<(FRACBITS-2)),
 					(100<<FRACBITS)+(finalecount<<(FRACBITS-2)),
-					FRACUNIT, trans<<V_ALPHASHIFT, endescp[(finalecount/2)&3], NULL);
+					FRACUNIT, trans<<V_ALPHASHIFT, *endescp[(finalecount/2)&3], NULL);
 			}
 
 			if (goodending && parallaxticker > 0) // gunchedrock
@@ -2003,21 +1996,21 @@ void F_EndingDrawer(void)
 				y <<= 1;
 
 				// center detritrus
-				V_DrawFixedPatch(i-x, j-y, FRACUNIT, 0, endegrk[0], colormap);
+				V_DrawFixedPatch(i-x, j-y, FRACUNIT, 0, *endegrk[0], colormap);
 				if (trans < 10)
-					V_DrawFixedPatch(i-x, j-y, FRACUNIT, trans<<V_ALPHASHIFT, endegrk[0], NULL);
+					V_DrawFixedPatch(i-x, j-y, FRACUNIT, trans<<V_ALPHASHIFT, *endegrk[0], NULL);
 
 				 // ring detritrus
-				V_DrawFixedPatch((30*(FRACUNIT-scale))+i-(2*x), (30*(FRACUNIT-scale))+j-(2*y) - ((7<<FRACBITS)/2), scale, 0, endegrk[1], colormap);
+				V_DrawFixedPatch((30*(FRACUNIT-scale))+i-(2*x), (30*(FRACUNIT-scale))+j-(2*y) - ((7<<FRACBITS)/2), scale, 0, *endegrk[1], colormap);
 				if (trans < 10)
-					V_DrawFixedPatch((30*(FRACUNIT-scale))+i-(2*x), (30*(FRACUNIT-scale))+j-(2*y), scale, trans<<V_ALPHASHIFT, endegrk[1], NULL);
+					V_DrawFixedPatch((30*(FRACUNIT-scale))+i-(2*x), (30*(FRACUNIT-scale))+j-(2*y), scale, trans<<V_ALPHASHIFT, *endegrk[1], NULL);
 
 				scale += ((parallaxticker-10)<<7);
 
 				 // shard detritrus
-				V_DrawFixedPatch((30*(FRACUNIT-scale))+i-(x/2), (30*(FRACUNIT-scale))+j-(y/2) - ((7<<FRACBITS)/2), scale, 0, endxpld[0], colormap);
+				V_DrawFixedPatch((30*(FRACUNIT-scale))+i-(x/2), (30*(FRACUNIT-scale))+j-(y/2) - ((7<<FRACBITS)/2), scale, 0, *endxpld[0], colormap);
 				if (trans < 10)
-					V_DrawFixedPatch((30*(FRACUNIT-scale))+i-(x/2), (30*(FRACUNIT-scale))+j-(y/2), scale, trans<<V_ALPHASHIFT, endxpld[0], NULL);
+					V_DrawFixedPatch((30*(FRACUNIT-scale))+i-(x/2), (30*(FRACUNIT-scale))+j-(y/2), scale, trans<<V_ALPHASHIFT, *endxpld[0], NULL);
 			}
 		}
 		else if (goodending)
@@ -2071,7 +2064,7 @@ void F_EndingDrawer(void)
 				trans = (-parallaxticker/4) + 5;
 				if (trans < 0)
 					trans = 0;
-				V_DrawFixedPatch(x, y, scale, trans<<V_ALPHASHIFT, endglow[(finalecount & 1) ? 0 : 1], NULL);
+				V_DrawFixedPatch(x, y, scale, trans<<V_ALPHASHIFT, *endglow[(finalecount & 1) ? 0 : 1], NULL);
 			}
 
 			if (goodending && finalecount > INFLECTIONPOINT)
@@ -2105,7 +2098,7 @@ void F_EndingDrawer(void)
 				if ((-parallaxticker/2) < -5)
 					colormap[1] = R_GetTranslationColormap(TC_ALLWHITE, 0, GTC_CACHE);
 
-				V_DrawFixedPatch(x, y, scale, 0, endegrk[0], colormap[1]);
+				V_DrawFixedPatch(x, y, scale, 0, *endegrk[0], colormap[1]);
 
 				if ((-parallaxticker/2) < 5)
 				{
@@ -2113,7 +2106,7 @@ void F_EndingDrawer(void)
 					if (trans < 0)
 						trans = -trans;
 					if (trans < 10)
-						V_DrawFixedPatch(x, y, scale, trans<<V_ALPHASHIFT, endegrk[1], NULL);
+						V_DrawFixedPatch(x, y, scale, trans<<V_ALPHASHIFT, *endegrk[1], NULL);
 				}
 			}
 		}
@@ -2139,7 +2132,7 @@ void F_EndingDrawer(void)
 				colormap = R_GetTranslationColormap(players[consoleplayer].skin, players[consoleplayer].skincolor, GTC_CACHE);
 
 			if ((frame = ((parallaxticker & 1) ? 1 : 0) + (parallaxticker/TICRATE)) < 3)
-				V_DrawFixedPatch(x, y, scale, 0, endfwrk[frame], colormap);
+				V_DrawFixedPatch(x, y, scale, 0, *endfwrk[frame], colormap);
 		}
 
 		// explosions
@@ -2151,7 +2144,7 @@ void F_EndingDrawer(void)
 			y = ((((BASEVIDHEIGHT-82)/2)+12)<<FRACBITS) + ((boomtime*7)<<FRACBITS)/INFLECTIONPOINT;
 
 			V_DrawFixedPatch(x + sparkloffs[0][0], y + sparkloffs[0][1],
-				FRACUNIT, 0, endxpld[sparklloop/4], NULL);
+				FRACUNIT, 0, *endxpld[sparklloop/4], NULL);
 		}
 
 		// initial fade
@@ -2164,11 +2157,11 @@ void F_EndingDrawer(void)
 			if (borderstuff)
 				trans = (10*parallaxticker)/(3*TICRATE);
 			if (trans < 10)
-				V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, trans<<V_ALPHASHIFT, endbrdr[0]);
+				V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, trans<<V_ALPHASHIFT, *endbrdr[0]);
 			if (borderstuff && parallaxticker < 11)
-				V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, (parallaxticker-1)<<V_ALPHASHIFT, endbrdr[1]);
+				V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, (parallaxticker-1)<<V_ALPHASHIFT, *endbrdr[1]);
 			else if (goodending && finalecount > INFLECTIONPOINT && finalecount < INFLECTIONPOINT+10)
-				V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, (finalecount-INFLECTIONPOINT)<<V_ALPHASHIFT, endbrdr[1]);
+				V_DrawScaledPatch(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, (finalecount-INFLECTIONPOINT)<<V_ALPHASHIFT, *endbrdr[1]);
 		}
 
 		// emeralds and emerald accessories
@@ -2233,7 +2226,7 @@ void F_EndingDrawer(void)
 					// if j == 0 - alternate between 0 and 1
 					//         1 -                   1 and 2
 					//         2 -                   2 and not rendered
-					V_DrawFixedPatch(x, y, FRACUNIT, 0, endspkl[(j - ((sparklloop & 1) ? 0 : 1))], colormap);
+					V_DrawFixedPatch(x, y, FRACUNIT, 0, *endspkl[(j - ((sparklloop & 1) ? 0 : 1))], colormap);
 
 					j--;
 				}
@@ -2438,7 +2431,7 @@ void F_SkyScroll(INT32 scrollxspeed, INT32 scrollyspeed, const char *patchname)
 lumpnum = W_CheckNumForName(name); \
 if (lumpnum != LUMPERROR) \
 { \
-	arr[0] = W_CachePatchName(name, PU_LEVEL); \
+	arr[0] = (patch_t **)W_GetPatchPointerFromName(name, PU_LEVEL); \
 	arr[min(1, maxf-1)] = 0; \
 } \
 else if (strlen(name) <= 6) \
@@ -2451,7 +2444,7 @@ else if (strlen(name) <= 6) \
 		lumpname[8] = 0; \
 		lumpnum = W_CheckNumForName(lumpname); \
 		if (lumpnum != LUMPERROR) \
-			arr[i] = W_CachePatchName(lumpname, PU_LEVEL); \
+			arr[i] = (patch_t **)W_GetPatchPointerFromName(lumpname, PU_LEVEL); \
 		else \
 			break; \
 	} \
@@ -2466,21 +2459,21 @@ static void F_CacheTitleScreen(void)
 	{
 		case TTMODE_OLD:
 		case TTMODE_NONE:
-			ttbanner = W_CachePatchName("TTBANNER", PU_LEVEL);
-			ttwing = W_CachePatchName("TTWING", PU_LEVEL);
-			ttsonic = W_CachePatchName("TTSONIC", PU_LEVEL);
-			ttswave1 = W_CachePatchName("TTSWAVE1", PU_LEVEL);
-			ttswave2 = W_CachePatchName("TTSWAVE2", PU_LEVEL);
-			ttswip1 = W_CachePatchName("TTSWIP1", PU_LEVEL);
-			ttsprep1 = W_CachePatchName("TTSPREP1", PU_LEVEL);
-			ttsprep2 = W_CachePatchName("TTSPREP2", PU_LEVEL);
-			ttspop1 = W_CachePatchName("TTSPOP1", PU_LEVEL);
-			ttspop2 = W_CachePatchName("TTSPOP2", PU_LEVEL);
-			ttspop3 = W_CachePatchName("TTSPOP3", PU_LEVEL);
-			ttspop4 = W_CachePatchName("TTSPOP4", PU_LEVEL);
-			ttspop5 = W_CachePatchName("TTSPOP5", PU_LEVEL);
-			ttspop6 = W_CachePatchName("TTSPOP6", PU_LEVEL);
-			ttspop7 = W_CachePatchName("TTSPOP7", PU_LEVEL);
+			ttbanner = (patch_t **)W_GetPatchPointerFromName("TTBANNER", PU_LEVEL);
+			ttwing = (patch_t **)W_GetPatchPointerFromName("TTWING", PU_LEVEL);
+			ttsonic = (patch_t **)W_GetPatchPointerFromName("TTSONIC", PU_LEVEL);
+			ttswave1 = (patch_t **)W_GetPatchPointerFromName("TTSWAVE1", PU_LEVEL);
+			ttswave2 = (patch_t **)W_GetPatchPointerFromName("TTSWAVE2", PU_LEVEL);
+			ttswip1 = (patch_t **)W_GetPatchPointerFromName("TTSWIP1", PU_LEVEL);
+			ttsprep1 = (patch_t **)W_GetPatchPointerFromName("TTSPREP1", PU_LEVEL);
+			ttsprep2 = (patch_t **)W_GetPatchPointerFromName("TTSPREP2", PU_LEVEL);
+			ttspop1 = (patch_t **)W_GetPatchPointerFromName("TTSPOP1", PU_LEVEL);
+			ttspop2 = (patch_t **)W_GetPatchPointerFromName("TTSPOP2", PU_LEVEL);
+			ttspop3 = (patch_t **)W_GetPatchPointerFromName("TTSPOP3", PU_LEVEL);
+			ttspop4 = (patch_t **)W_GetPatchPointerFromName("TTSPOP4", PU_LEVEL);
+			ttspop5 = (patch_t **)W_GetPatchPointerFromName("TTSPOP5", PU_LEVEL);
+			ttspop6 = (patch_t **)W_GetPatchPointerFromName("TTSPOP6", PU_LEVEL);
+			ttspop7 = (patch_t **)W_GetPatchPointerFromName("TTSPOP7", PU_LEVEL);
 			break;
 
 		// don't load alacroix gfx yet; we do that upon first draw.
@@ -2608,28 +2601,28 @@ static void F_UnloadAlacroixGraphics(SINT8 oldttscale)
 	oldttscale--; // zero-based index
 	for (i = 0; i < TTMAX_ALACROIX; i++)
 	{
-		if(ttembl[oldttscale][i]) { Z_Free(ttembl[oldttscale][i]); ttembl[oldttscale][i] = 0; }
-		if(ttribb[oldttscale][i]) { Z_Free(ttribb[oldttscale][i]); ttribb[oldttscale][i] = 0; }
-		if(ttsont[oldttscale][i]) { Z_Free(ttsont[oldttscale][i]); ttsont[oldttscale][i] = 0; }
-		if(ttrobo[oldttscale][i]) { Z_Free(ttrobo[oldttscale][i]); ttrobo[oldttscale][i] = 0; }
-		if(tttwot[oldttscale][i]) { Z_Free(tttwot[oldttscale][i]); tttwot[oldttscale][i] = 0; }
-		if(ttrbtx[oldttscale][i]) { Z_Free(ttrbtx[oldttscale][i]); ttrbtx[oldttscale][i] = 0; }
-		if(ttsoib[oldttscale][i]) { Z_Free(ttsoib[oldttscale][i]); ttsoib[oldttscale][i] = 0; }
-		if(ttsoif[oldttscale][i]) { Z_Free(ttsoif[oldttscale][i]); ttsoif[oldttscale][i] = 0; }
-		if(ttsoba[oldttscale][i]) { Z_Free(ttsoba[oldttscale][i]); ttsoba[oldttscale][i] = 0; }
-		if(ttsobk[oldttscale][i]) { Z_Free(ttsobk[oldttscale][i]); ttsobk[oldttscale][i] = 0; }
-		if(ttsodh[oldttscale][i]) { Z_Free(ttsodh[oldttscale][i]); ttsodh[oldttscale][i] = 0; }
-		if(tttaib[oldttscale][i]) { Z_Free(tttaib[oldttscale][i]); tttaib[oldttscale][i] = 0; }
-		if(tttaif[oldttscale][i]) { Z_Free(tttaif[oldttscale][i]); tttaif[oldttscale][i] = 0; }
-		if(tttaba[oldttscale][i]) { Z_Free(tttaba[oldttscale][i]); tttaba[oldttscale][i] = 0; }
-		if(tttabk[oldttscale][i]) { Z_Free(tttabk[oldttscale][i]); tttabk[oldttscale][i] = 0; }
-		if(tttabt[oldttscale][i]) { Z_Free(tttabt[oldttscale][i]); tttabt[oldttscale][i] = 0; }
-		if(tttaft[oldttscale][i]) { Z_Free(tttaft[oldttscale][i]); tttaft[oldttscale][i] = 0; }
-		if(ttknib[oldttscale][i]) { Z_Free(ttknib[oldttscale][i]); ttknib[oldttscale][i] = 0; }
-		if(ttknif[oldttscale][i]) { Z_Free(ttknif[oldttscale][i]); ttknif[oldttscale][i] = 0; }
-		if(ttknba[oldttscale][i]) { Z_Free(ttknba[oldttscale][i]); ttknba[oldttscale][i] = 0; }
-		if(ttknbk[oldttscale][i]) { Z_Free(ttknbk[oldttscale][i]); ttknbk[oldttscale][i] = 0; }
-		if(ttkndh[oldttscale][i]) { Z_Free(ttkndh[oldttscale][i]); ttkndh[oldttscale][i] = 0; }
+		if(ttembl[oldttscale][i]) { Z_Free(*ttembl[oldttscale][i]); ttembl[oldttscale][i] = 0; }
+		if(ttribb[oldttscale][i]) { Z_Free(*ttribb[oldttscale][i]); ttribb[oldttscale][i] = 0; }
+		if(ttsont[oldttscale][i]) { Z_Free(*ttsont[oldttscale][i]); ttsont[oldttscale][i] = 0; }
+		if(ttrobo[oldttscale][i]) { Z_Free(*ttrobo[oldttscale][i]); ttrobo[oldttscale][i] = 0; }
+		if(tttwot[oldttscale][i]) { Z_Free(*tttwot[oldttscale][i]); tttwot[oldttscale][i] = 0; }
+		if(ttrbtx[oldttscale][i]) { Z_Free(*ttrbtx[oldttscale][i]); ttrbtx[oldttscale][i] = 0; }
+		if(ttsoib[oldttscale][i]) { Z_Free(*ttsoib[oldttscale][i]); ttsoib[oldttscale][i] = 0; }
+		if(ttsoif[oldttscale][i]) { Z_Free(*ttsoif[oldttscale][i]); ttsoif[oldttscale][i] = 0; }
+		if(ttsoba[oldttscale][i]) { Z_Free(*ttsoba[oldttscale][i]); ttsoba[oldttscale][i] = 0; }
+		if(ttsobk[oldttscale][i]) { Z_Free(*ttsobk[oldttscale][i]); ttsobk[oldttscale][i] = 0; }
+		if(ttsodh[oldttscale][i]) { Z_Free(*ttsodh[oldttscale][i]); ttsodh[oldttscale][i] = 0; }
+		if(tttaib[oldttscale][i]) { Z_Free(*tttaib[oldttscale][i]); tttaib[oldttscale][i] = 0; }
+		if(tttaif[oldttscale][i]) { Z_Free(*tttaif[oldttscale][i]); tttaif[oldttscale][i] = 0; }
+		if(tttaba[oldttscale][i]) { Z_Free(*tttaba[oldttscale][i]); tttaba[oldttscale][i] = 0; }
+		if(tttabk[oldttscale][i]) { Z_Free(*tttabk[oldttscale][i]); tttabk[oldttscale][i] = 0; }
+		if(tttabt[oldttscale][i]) { Z_Free(*tttabt[oldttscale][i]); tttabt[oldttscale][i] = 0; }
+		if(tttaft[oldttscale][i]) { Z_Free(*tttaft[oldttscale][i]); tttaft[oldttscale][i] = 0; }
+		if(ttknib[oldttscale][i]) { Z_Free(*ttknib[oldttscale][i]); ttknib[oldttscale][i] = 0; }
+		if(ttknif[oldttscale][i]) { Z_Free(*ttknif[oldttscale][i]); ttknif[oldttscale][i] = 0; }
+		if(ttknba[oldttscale][i]) { Z_Free(*ttknba[oldttscale][i]); ttknba[oldttscale][i] = 0; }
+		if(ttknbk[oldttscale][i]) { Z_Free(*ttknbk[oldttscale][i]); ttknbk[oldttscale][i] = 0; }
+		if(ttkndh[oldttscale][i]) { Z_Free(*ttkndh[oldttscale][i]); ttkndh[oldttscale][i] = 0; }
 	}
 	ttloaded[oldttscale] = false;
 }
@@ -2706,17 +2699,12 @@ static void F_FigureActiveTtScale(void)
 	SINT8 newttscale = max(1, min(6, vid.dupx));
 	SINT8 oldttscale = activettscale;
 
-	if (needpatchrecache)
-		ttloaded[0] = ttloaded[1] = ttloaded[2] = ttloaded[3] = ttloaded[4] = ttloaded[5] = 0;
-	else
-	{
-		if (newttscale == testttscale)
-			return;
+	if (newttscale == testttscale)
+		return;
 
-		// We have a new ttscale, so load gfx
-		if(oldttscale > 0)
-			F_UnloadAlacroixGraphics(oldttscale);
-	}
+	// We have a new ttscale, so load gfx
+	if(oldttscale > 0)
+		F_UnloadAlacroixGraphics(oldttscale);
 
 	testttscale = newttscale;
 
@@ -2750,9 +2738,6 @@ void F_TitleScreenDrawer(void)
 	if (modeattacking)
 		return; // We likely came here from retrying. Don't do a damn thing.
 
-	if (needpatchrecache && (curttmode != TTMODE_ALACROIX))
-		F_CacheTitleScreen();
-
 	// Draw that sky!
 	if (curbgcolor >= 0)
 		V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
@@ -2776,42 +2761,42 @@ void F_TitleScreenDrawer(void)
 	{
 		case TTMODE_OLD:
 		case TTMODE_NONE:
-			V_DrawSciencePatch(30<<FRACBITS, 14<<FRACBITS, 0, ttwing, sc);
+			V_DrawSciencePatch(30<<FRACBITS, 14<<FRACBITS, 0, *ttwing, sc);
 
 			if (finalecount < 57)
 			{
 				if (finalecount == 35)
-					V_DrawSciencePatch(115<<FRACBITS, 15<<FRACBITS, 0, ttspop1, sc);
+					V_DrawSciencePatch(115<<FRACBITS, 15<<FRACBITS, 0, *ttspop1, sc);
 				else if (finalecount == 36)
-					V_DrawSciencePatch(114<<FRACBITS, 15<<FRACBITS, 0,ttspop2, sc);
+					V_DrawSciencePatch(114<<FRACBITS, 15<<FRACBITS, 0,*ttspop2, sc);
 				else if (finalecount == 37)
-					V_DrawSciencePatch(113<<FRACBITS, 15<<FRACBITS, 0,ttspop3, sc);
+					V_DrawSciencePatch(113<<FRACBITS, 15<<FRACBITS, 0,*ttspop3, sc);
 				else if (finalecount == 38)
-					V_DrawSciencePatch(112<<FRACBITS, 15<<FRACBITS, 0,ttspop4, sc);
+					V_DrawSciencePatch(112<<FRACBITS, 15<<FRACBITS, 0,*ttspop4, sc);
 				else if (finalecount == 39)
-					V_DrawSciencePatch(111<<FRACBITS, 15<<FRACBITS, 0,ttspop5, sc);
+					V_DrawSciencePatch(111<<FRACBITS, 15<<FRACBITS, 0,*ttspop5, sc);
 				else if (finalecount == 40)
-					V_DrawSciencePatch(110<<FRACBITS, 15<<FRACBITS, 0, ttspop6, sc);
+					V_DrawSciencePatch(110<<FRACBITS, 15<<FRACBITS, 0, *ttspop6, sc);
 				else if (finalecount >= 41 && finalecount <= 44)
-					V_DrawSciencePatch(109<<FRACBITS, 15<<FRACBITS, 0, ttspop7, sc);
+					V_DrawSciencePatch(109<<FRACBITS, 15<<FRACBITS, 0, *ttspop7, sc);
 				else if (finalecount >= 45 && finalecount <= 48)
-					V_DrawSciencePatch(108<<FRACBITS, 12<<FRACBITS, 0, ttsprep1, sc);
+					V_DrawSciencePatch(108<<FRACBITS, 12<<FRACBITS, 0, *ttsprep1, sc);
 				else if (finalecount >= 49 && finalecount <= 52)
-					V_DrawSciencePatch(107<<FRACBITS, 9<<FRACBITS, 0, ttsprep2, sc);
+					V_DrawSciencePatch(107<<FRACBITS, 9<<FRACBITS, 0, *ttsprep2, sc);
 				else if (finalecount >= 53 && finalecount <= 56)
-					V_DrawSciencePatch(106<<FRACBITS, 6<<FRACBITS, 0, ttswip1, sc);
-				V_DrawSciencePatch(93<<FRACBITS, 106<<FRACBITS, 0, ttsonic, sc);
+					V_DrawSciencePatch(106<<FRACBITS, 6<<FRACBITS, 0, *ttswip1, sc);
+				V_DrawSciencePatch(93<<FRACBITS, 106<<FRACBITS, 0, *ttsonic, sc);
 			}
 			else
 			{
-				V_DrawSciencePatch(93<<FRACBITS, 106<<FRACBITS, 0,ttsonic, sc);
+				V_DrawSciencePatch(93<<FRACBITS, 106<<FRACBITS, 0,*ttsonic, sc);
 				if (finalecount/5 & 1)
-					V_DrawSciencePatch(100<<FRACBITS, 3<<FRACBITS, 0,ttswave1, sc);
+					V_DrawSciencePatch(100<<FRACBITS, 3<<FRACBITS, 0,*ttswave1, sc);
 				else
-					V_DrawSciencePatch(100<<FRACBITS, 3<<FRACBITS, 0,ttswave2, sc);
+					V_DrawSciencePatch(100<<FRACBITS, 3<<FRACBITS, 0,*ttswave2, sc);
 			}
 
-			V_DrawSciencePatch(48<<FRACBITS, 142<<FRACBITS, 0,ttbanner, sc);
+			V_DrawSciencePatch(48<<FRACBITS, 142<<FRACBITS, 0,*ttbanner, sc);
 			break;
 
 		case TTMODE_ALACROIX:
@@ -3485,7 +3470,7 @@ void F_TitleScreenDrawer(void)
 					break; // draw nothing
 			}
 
-			V_DrawSciencePatch(curttx<<FRACBITS, curtty<<FRACBITS, 0, ttuser[ttuser_count], sc);
+			V_DrawSciencePatch(curttx<<FRACBITS, curtty<<FRACBITS, 0, *ttuser[ttuser_count], sc);
 
 			if (!(finalecount % max(1, curtttics)))
 				ttuser_count++;

src/g_game.c

@@ -4462,7 +4462,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 
 //	G_DeferedInitNew(sk_medium, G_BuildMapName(1), 0, 0, 1);
 	if (setsizeneeded)
-		R_ExecuteSetViewSize();
+		R_SetViewSize();
 
 	M_ClearMenus(true);
 	CON_ToggleOff();

src/hardware/hw_cache.c

@@ -502,7 +502,6 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex)
 	// Composite the columns together.
 	for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
 	{
-		boolean dealloc = true;
 		size_t lumplength = W_LumpLengthPwad(patch->wad, patch->lump);
 		pdata = W_CacheLumpNumPwad(patch->wad, patch->lump, PU_CACHE);
 		realpatch = (patch_t *)pdata;
@@ -517,15 +516,9 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex)
 			realpatch = R_FlatToPatch(pdata, texture->width, texture->height, 0, 0, NULL, false);
 		else
 #endif
-		{
 			(void)lumplength;
-			dealloc = false;
-		}
 
 		HWR_DrawTexturePatchInCache(&grtex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
-
-		if (dealloc)
-			Z_Unlock(realpatch);
 	}
 	//Hurdler: not efficient at all but I don't remember exactly how HWR_DrawPatchInCache works :(
 	if (format2bpp(grtex->mipmap.format)==4)
@@ -601,6 +594,7 @@ void HWR_MakePatch (const patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipm
 static size_t gl_numtextures = 0; // Texture count
 static GLMapTexture_t *gl_textures; // For all textures
 static GLMapTexture_t *gl_flats; // For all (texture) flats, as normal flats don't need to be cached
+boolean gl_leveltexturesloaded = false;
 
 void HWR_InitTextureCache(void)
 {
@@ -663,7 +657,17 @@ void HWR_FreeMipmapCache(void)
 	// Alam: free the Z_Blocks before freeing it's users
 	// free all patch colormaps after each level: must be done after ClearMipMapCache!
 	for (i = 0; i < numwadfiles; i++)
-		M_AATreeIterate(wadfiles[i]->hwrcache, FreeMipmapColormap);
+	{
+		M_AATreeIterate(Patch_GetRendererBaseSubTree(i, render_opengl), FreeMipmapColormap);
+
+#ifdef ROTSPRITE
+		// free non-flipped rotated subtree
+		M_AATreeIterate(Patch_GetRendererRotatedSubTree(i, render_opengl, false), FreeMipmapColormap);
+
+		// free flipped rotated subtree
+		M_AATreeIterate(Patch_GetRendererRotatedSubTree(i, render_opengl, true), FreeMipmapColormap);
+#endif
+	}
 }
 
 void HWR_FreeTextureCache(void)
@@ -680,6 +684,7 @@ void HWR_FreeTextureCache(void)
 	gl_textures = NULL;
 	gl_flats = NULL;
 	gl_numtextures = 0;
+	gl_leveltexturesloaded = false;
 }
 
 void HWR_LoadTextures(size_t pnumtextures)
@@ -696,6 +701,8 @@ void HWR_LoadTextures(size_t pnumtextures)
 	// should never ever happen (right?!)
 	if ((gl_textures == NULL) || (gl_flats == NULL))
 		I_Error("HWR_LoadTextures: ran out of memory for OpenGL textures. Sad!");
+
+	gl_leveltexturesloaded = true;
 }
 
 void HWR_SetPalette(RGBA_t *palette)
@@ -872,15 +879,18 @@ static void HWR_LoadMappedPatch(GLMipmap_t *grmip, GLPatch_t *gpatch)
 {
 	if (!grmip->downloaded && !grmip->data)
 	{
-		patch_t *patch = gpatch->rawpatch;
-		if (!patch)
-			patch = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
-		HWR_MakePatch(patch, gpatch, grmip, true);
-
-		// You can't free rawpatch for some reason?
-		// (Obviously I can't, sprite rotation needs that...)
-		if (!gpatch->rawpatch)
-			Z_Free(patch);
+		patch_t *lumppatch = NULL;
+
+		if (gpatch->patch)
+			HWR_MakePatch(gpatch->patch, gpatch, grmip, true);
+		else
+		{
+			lumppatch = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
+			HWR_MakePatch(lumppatch, gpatch, grmip, true);
+		}
+
+		if (lumppatch)
+			Z_Free(lumppatch);
 	}
 
 	// If hardware does not have the texture, then call pfnSetTexture to upload it
@@ -898,20 +908,25 @@ static void HWR_LoadMappedPatch(GLMipmap_t *grmip, GLPatch_t *gpatch)
 // -----------------+
 void HWR_GetPatch(GLPatch_t *gpatch)
 {
-	// is it in hardware cache
+	// is it in hardware cache?
 	if (!gpatch->mipmap->downloaded && !gpatch->mipmap->data)
 	{
 		// load the software patch, PU_STATIC or the Z_Malloc for hardware patch will
 		// flush the software patch before the conversion! oh yeah I suffered
-		patch_t *ptr = gpatch->rawpatch;
-		if (!ptr)
-			ptr = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
-		HWR_MakePatch(ptr, gpatch, gpatch->mipmap, true);
+		patch_t *lumppatch = NULL;
+
+		if (gpatch->patch)
+			HWR_MakePatch(gpatch->patch, gpatch, gpatch->mipmap, true);
+		else
+		{
+			lumppatch = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
+			HWR_MakePatch(lumppatch, gpatch, gpatch->mipmap, true);
+		}
 
 		// this is inefficient.. but the hardware patch in heap is purgeable so it should
 		// not fragment memory, and besides the REAL cache here is the hardware memory
-		if (!gpatch->rawpatch)
-			Z_Free(ptr);
+		if (lumppatch)
+			Z_Free(lumppatch);
 	}
 
 	// If hardware does not have the texture, then call pfnSetTexture to upload it
@@ -1096,7 +1111,6 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum)
 			                   pic,
 			                   format2bpp(grpatch->mipmap->format));
 
-		Z_Unlock(pic);
 		Z_ChangeTag(block, PU_HWRCACHE_UNLOCKED);
 
 		grpatch->mipmap->flags = 0;
@@ -1108,18 +1122,17 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum)
 	return grpatch;
 }
 
-GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
+GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum, void *hwrcache)
 {
-	aatree_t *hwrcache = wadfiles[wadnum]->hwrcache;
 	GLPatch_t *grpatch;
 
-	if (!(grpatch = M_AATreeGet(hwrcache, lumpnum)))
+	if (!(grpatch = M_AATreeGet((aatree_t *)hwrcache, lumpnum)))
 	{
 		grpatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
 		grpatch->wadnum = wadnum;
 		grpatch->lumpnum = lumpnum;
 		grpatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
-		M_AATreeSet(hwrcache, lumpnum, grpatch);
+		M_AATreeSet((aatree_t *)hwrcache, lumpnum, grpatch);
 	}
 
 	return grpatch;
@@ -1127,7 +1140,8 @@ GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
 
 GLPatch_t *HWR_GetCachedGLPatch(lumpnum_t lumpnum)
 {
-	return HWR_GetCachedGLPatchPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum));
+	UINT16 wad = WADFILENUM(lumpnum);
+	return HWR_GetCachedGLPatchPwad(wad, LUMPNUM(lumpnum), Patch_GetRendererBaseSubTree(wad, render_opengl));
 }
 
 // Need to do this because they aren't powers of 2

src/hardware/hw_data.h

@@ -89,7 +89,7 @@ struct GLPatch_s
 	float               max_s,max_t;
 	UINT16              wadnum;      // the software patch lump num for when the hardware patch
 	UINT16              lumpnum;     // was flushed, and we need to re-create it
-	void                *rawpatch;   // :^)
+	void                *patch;
 	GLMipmap_t          *mipmap;
 } ATTRPACK;
 typedef struct GLPatch_s GLPatch_t;

src/hardware/hw_glob.h

@@ -62,7 +62,10 @@ typedef struct
 typedef struct gl_vissprite_s
 {
 	float x1, x2;
+	float z1, z2;
 	float tz, ty;
+	float originx, originy, originz;
+	angle_t angle;
 	float tracertz; // for MF2_LINKDRAW sprites, this contains tracer's tz for use in sorting
 	//lumpnum_t patchlumpnum;
 	GLPatch_t *gpatch;
@@ -74,7 +77,10 @@ typedef struct gl_vissprite_s
    //Hurdler: 25/04/2000: now support colormap in hardware mode
 	UINT8 *colormap;
 	INT32 dispoffset; // copy of info->dispoffset, affects ordering but not drawing
-	float z1, z2;
+#ifdef ROTSPRITE
+	angle_t rollangle;
+	float pivotx, pivoty;
+#endif
 } gl_vissprite_t;
 
 // --------
@@ -102,10 +108,12 @@ void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap);
 void HWR_UnlockCachedPatch(GLPatch_t *gpatch);
 GLPatch_t *HWR_GetPic(lumpnum_t lumpnum);
 void HWR_SetPalette(RGBA_t *palette);
-GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wad, UINT16 lump);
+GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum, void *hwrcache);
 GLPatch_t *HWR_GetCachedGLPatch(lumpnum_t lumpnum);
 void HWR_GetFadeMask(lumpnum_t fademasklumpnum);
 
+extern boolean gl_leveltexturesloaded;
+
 // --------
 // hw_draw.c
 // --------

src/hardware/hw_main.c

@@ -26,6 +26,7 @@
 #include "../p_setup.h"
 #include "../r_local.h"
 #include "../r_patch.h"
+#include "../r_rotsprite.h"
 #include "../r_bsp.h"
 #include "../d_clisrv.h"
 #include "../w_wad.h"
@@ -3701,6 +3702,87 @@ static void HWR_RotateSpritePolyToAim(gl_vissprite_t *spr, FOutVector *wallVerts
 	}
 }
 
+#if defined(ROTSPRITE) && !defined(ROTSPRITE_RENDER_PATCHES)
+static void HWR_ApplyPitchRollYawToSprite(FOutVector *wallVerts, float pitch, float roll, float yaw)
+{
+	size_t i;
+
+	float yawcos = cos(yaw);
+	float yawsin = sin(yaw);
+	float pitchcos = cos(pitch);
+	float pitchsin = sin(pitch);
+	float rollcos = cos(roll);
+	float rollsin = sin(roll);
+
+	float xx = yawcos * pitchcos;
+	float xy = (yawcos * pitchsin * rollsin) - (yawsin * rollcos);
+	float xz = (yawcos * pitchsin * rollcos) + (yawsin * rollsin);
+
+	float yx = yawsin * pitchcos;
+	float yy = (yawsin * pitchsin * rollsin) + (yawcos * rollcos);
+	float yz = (yawsin * pitchsin * rollcos) - (yawcos * rollsin);
+
+	float zx = -pitchsin;
+	float zy = pitchcos * rollsin;
+	float zz = pitchcos * rollcos;
+
+	for (i = 0; i < 4; i++)
+	{
+		float x = wallVerts[i].x;
+		float y = wallVerts[i].y;
+		float z = wallVerts[i].z;
+		wallVerts[i].x = xx*x + xy*y + xz*z;
+		wallVerts[i].y = yx*x + yy*y + yz*z;
+		wallVerts[i].z = zx*x + zy*y + zz*z;
+	}
+}
+
+static void HWR_RotateSpritePolyToRollAngle(gr_vissprite_t *spr, FOutVector *wallVerts)
+{
+	INT32 i;
+	float radians = (M_PIl / 180.0f);
+
+	float cx = (spr->gpatch->leftoffset - spr->pivotx);
+	float cy = spr->pivoty;
+
+	fixed_t fa = AngleFixed(spr->rollangle);
+	float rotate = FIXED_TO_FLOAT(fa) * radians;
+
+	// Translate sprite by its pivot
+	for (i = 0; i < 4; i++)
+	{
+		wallVerts[i].x -= cx;
+		wallVerts[i].y -= cy;
+	}
+
+	// Apply sprite roll
+	HWR_ApplyPitchRollYawToSprite(wallVerts, 0.0f, 0.0f, rotate);
+
+	// Translate sprite back
+	for (i = 0; i < 4; i++)
+	{
+		wallVerts[i].x += cx;
+		wallVerts[i].y += cy;
+	}
+
+	// Apply sprite angle
+	fa = AngleFixed(spr->angle - ANGLE_180);
+	rotate = FIXED_TO_FLOAT(fa) * radians;
+	HWR_ApplyPitchRollYawToSprite(wallVerts, -rotate, 0.0f, 0.0f);
+
+	// Translate the sprite to its intended position
+	for (i = 0; i < 4; i++)
+	{
+		wallVerts[i].x += spr->originx;
+		wallVerts[i].z += spr->originy;
+	}
+
+	// Translate the sprite vertically
+	for (i = 0; i < 4; i++)
+		wallVerts[i].y += spr->originz;
+}
+#endif
+
 static void HWR_SplitSprite(gl_vissprite_t *spr)
 {
 	float this_scale = 1.0f;
@@ -3793,6 +3875,12 @@ static void HWR_SplitSprite(gl_vissprite_t *spr)
 	// Let dispoffset work first since this adjust each vertex
 	HWR_RotateSpritePolyToAim(spr, baseWallVerts, false);
 
+#if defined(ROTSPRITE) && !defined(ROTSPRITE_RENDER_PATCHES)
+	// Rotate the sprite polygon, then translate it
+	if (spr->rollangle)
+		HWR_RotateSpritePolyToRollAngle(spr, baseWallVerts);
+#endif
+
 	realtop = top = baseWallVerts[3].y;
 	realbot = bot = baseWallVerts[0].y;
 	ttop = baseWallVerts[3].t;
@@ -4075,6 +4163,12 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 	// Let dispoffset work first since this adjust each vertex
 	HWR_RotateSpritePolyToAim(spr, wallVerts, false);
 
+#if defined(ROTSPRITE) && !defined(ROTSPRITE_RENDER_PATCHES)
+	// Rotate the sprite polygon, then translate it
+	if (spr->rollangle)
+		HWR_RotateSpritePolyToRollAngle(spr, wallVerts);
+#endif
+
 	// This needs to be AFTER the shadows so that the regular sprites aren't drawn completely black.
 	// sprite lighting by modulating the RGB components
 	/// \todo coloured
@@ -4760,9 +4854,15 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	float rightsin, rightcos;
 	float this_scale;
 	float gz, gzt;
+	float topz, bottomz, originz;
 	spritedef_t *sprdef;
 	spriteframe_t *sprframe;
+#ifdef ROTSPRITE
 	spriteinfo_t *sprinfo;
+#ifdef ROTSPRITE_RENDER_PATCHES
+	INT32 rollangle;
+#endif
+#endif
 	md2_t *md2;
 	size_t lumpoff;
 	unsigned rot;
@@ -4776,14 +4876,12 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	INT32 heightsec, phs;
 	const boolean papersprite = (thing->frame & FF_PAPERSPRITE);
 	angle_t mobjangle = (thing->player ? thing->player->drawangle : thing->angle);
+	angle_t spriteangle;
 	float z1, z2;
 
+	GLPatch_t *spr_patch;
 	fixed_t spr_width, spr_height;
 	fixed_t spr_offset, spr_topoffset;
-#ifdef ROTSPRITE
-	patch_t *rotsprite = NULL;
-	INT32 rollangle = 0;
-#endif
 
 	if (!thing)
 		return;
@@ -4832,12 +4930,16 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	if (thing->skin && thing->sprite == SPR_PLAY)
 	{
 		sprdef = &((skin_t *)thing->skin)->sprites[thing->sprite2];
+#ifdef ROTSPRITE
 		sprinfo = &((skin_t *)thing->skin)->sprinfo[thing->sprite2];
+#endif
 	}
 	else
 	{
 		sprdef = &sprites[thing->sprite];
-		sprinfo = NULL;
+#ifdef ROTSPRITE
+		sprinfo = &spriteinfo[thing->sprite];
+#endif
 	}
 
 	if (rot >= sprdef->numframes)
@@ -4847,7 +4949,9 @@ static void HWR_ProjectSprite(mobj_t *thing)
 		thing->sprite = states[S_UNKNOWN].sprite;
 		thing->frame = states[S_UNKNOWN].frame;
 		sprdef = &sprites[thing->sprite];
-		sprinfo = NULL;
+#ifdef ROTSPRITE
+		sprinfo = &spriteinfo[thing->sprite];
+#endif
 		rot = thing->frame&FF_FRAMEMASK;
 		thing->state->sprite = thing->sprite;
 		thing->state->frame = thing->frame;
@@ -4900,40 +5004,44 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	if (thing->skin && ((skin_t *)thing->skin)->flags & SF_HIRES)
 		this_scale = this_scale * FIXED_TO_FLOAT(((skin_t *)thing->skin)->highresscale);
 
+	spr_patch = (GLPatch_t *)W_CachePatchNum(sprframe->lumppat[rot], PU_CACHE);
 	spr_width = spritecachedinfo[lumpoff].width;
 	spr_height = spritecachedinfo[lumpoff].height;
 	spr_offset = spritecachedinfo[lumpoff].offset;
 	spr_topoffset = spritecachedinfo[lumpoff].topoffset;
 
-#ifdef ROTSPRITE
-	if (thing->rollangle)
+#if defined(ROTSPRITE) && defined(ROTSPRITE_RENDER_PATCHES)
+	rollangle = R_GetRollAngle(thing->rollangle);
+	if (rollangle)
 	{
-		rollangle = R_GetRollAngle(thing->rollangle);
-		if (!(sprframe->rotsprite.cached & (1<<rot)))
-			R_CacheRotSprite(thing->sprite, (thing->frame & FF_FRAMEMASK), sprinfo, sprframe, rot, flip);
-		rotsprite = sprframe->rotsprite.patch[rot][rollangle];
-		if (rotsprite != NULL)
-		{
-			spr_width = SHORT(rotsprite->width) << FRACBITS;
-			spr_height = SHORT(rotsprite->height) << FRACBITS;
-			spr_offset = SHORT(rotsprite->leftoffset) << FRACBITS;
-			spr_topoffset = SHORT(rotsprite->topoffset) << FRACBITS;
-			// flip -> rotate, not rotate -> flip
-			flip = 0;
-		}
+		spriteframepivot_t *pivot = (sprinfo->available) ? &sprinfo->pivot[(thing->frame & FF_FRAMEMASK)] : NULL;
+		static rotsprite_vars_t rsvars;
+		patch_t *rotpatch;
+
+		rsvars.rollangle = rollangle;
+		rsvars.sprite = true;
+		rsvars.pivot = pivot;
+		rsvars.flip = (flip != 0);
+
+		rotpatch = Patch_CacheRotatedForSprite(sprframe->lumppat[rot], PU_LEVEL, rsvars, false);
+		spr_patch = (GLPatch_t *)rotpatch;
+		spr_width = SHORT(rotpatch->width) << FRACBITS;
+		spr_height = SHORT(rotpatch->height) << FRACBITS;
+		spr_offset = SHORT(rotpatch->leftoffset) << FRACBITS;
+		spr_topoffset = SHORT(rotpatch->topoffset) << FRACBITS;
+
+		// flip -> rotate, not rotate -> flip
+		flip = 0;
 	}
 #endif
 
 	if (papersprite)
-	{
-		rightsin = FIXED_TO_FLOAT(FINESINE((mobjangle)>>ANGLETOFINESHIFT));
-		rightcos = FIXED_TO_FLOAT(FINECOSINE((mobjangle)>>ANGLETOFINESHIFT));
-	}
+		spriteangle = mobjangle;
 	else
-	{
-		rightsin = FIXED_TO_FLOAT(FINESINE((viewangle + ANGLE_90)>>ANGLETOFINESHIFT));
-		rightcos = FIXED_TO_FLOAT(FINECOSINE((viewangle + ANGLE_90)>>ANGLETOFINESHIFT));
-	}
+		spriteangle = (viewangle + ANGLE_90);
+
+	rightsin = FIXED_TO_FLOAT(FINESINE((spriteangle)>>ANGLETOFINESHIFT));
+	rightcos = FIXED_TO_FLOAT(FINECOSINE((spriteangle)>>ANGLETOFINESHIFT));
 
 	flip = !flip != !hflip;
 
@@ -4948,31 +5056,35 @@ static void HWR_ProjectSprite(mobj_t *thing)
 		x2 = (FIXED_TO_FLOAT(spr_width - spr_offset) * this_scale);
 	}
 
-	// test if too close
-/*
-	if (papersprite)
-	{
-		z1 = tz - x1 * angle_scalez;
-		z2 = tz + x2 * angle_scalez;
+	originz = FIXED_TO_FLOAT(thing->z);
 
-		if (max(z1, z2) < ZCLIP_PLANE)
-			return;
+#if defined(ROTSPRITE) && !defined(ROTSPRITE_RENDER_PATCHES)
+	// Don't transform the sprite if it has a roll angle.
+	if (thing->rollangle)
+	{
+		z1 = z2 = 0.0f;
+		x1 = -x1;
+		topz = bottomz = 0.0;
+	}
+	else
+#endif
+	{
+		z1 = tr_y + x1 * rightsin;
+		z2 = tr_y - x2 * rightsin;
+		x1 = tr_x + x1 * rightcos;
+		x2 = tr_x - x2 * rightcos;
+		topz = originz + FIXED_TO_FLOAT(thing->height);
+		bottomz = originz;
 	}
-*/
-
-	z1 = tr_y + x1 * rightsin;
-	z2 = tr_y - x2 * rightsin;
-	x1 = tr_x + x1 * rightcos;
-	x2 = tr_x - x2 * rightcos;
 
 	if (vflip)
 	{
-		gz = FIXED_TO_FLOAT(thing->z+thing->height) - FIXED_TO_FLOAT(spr_topoffset) * this_scale;
+		gz = topz - FIXED_TO_FLOAT(spr_topoffset) * this_scale;
 		gzt = gz + FIXED_TO_FLOAT(spr_height) * this_scale;
 	}
 	else
 	{
-		gzt = FIXED_TO_FLOAT(thing->z) + FIXED_TO_FLOAT(spr_topoffset) * this_scale;
+		gzt = bottomz + FIXED_TO_FLOAT(spr_topoffset) * this_scale;
 		gz = gzt - FIXED_TO_FLOAT(spr_height) * this_scale;
 	}
 
@@ -5031,19 +5143,35 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	vis->x1 = x1;
 	vis->x2 = x2;
 	vis->tz = tz; // Keep tz for the simple sprite sorting that happens
+	vis->gpatch = spr_patch;
 	vis->tracertz = tracertz;
 	vis->dispoffset = dispoffset; // Monster Iestyn: 23/11/15: HARDWARE SUPPORT AT LAST
-	//vis->patchlumpnum = sprframe->lumppat[rot];
-#ifdef ROTSPRITE
-	if (rotsprite)
-		vis->gpatch = (GLPatch_t *)rotsprite;
-	else
-#endif
-		vis->gpatch = (GLPatch_t *)W_CachePatchNum(sprframe->lumppat[rot], PU_CACHE);
 	vis->flip = flip;
 	vis->mobj = thing;
 	vis->z1 = z1;
 	vis->z2 = z2;
+	vis->angle = spriteangle;
+	vis->originx = tr_x;
+	vis->originy = tr_y;
+	vis->originz = originz;
+
+#if defined(ROTSPRITE) && !defined(ROTSPRITE_RENDER_PATCHES)
+	if (thing->rollangle)
+	{
+		if (sprinfo->available)
+		{
+			spriteframepivot_t *pivot = &sprinfo->pivot[thing->frame & FF_FRAMEMASK];
+			vis->pivotx = (float)(pivot->x) * this_scale;
+			vis->pivoty = (float)(pivot->y) * this_scale;
+		}
+		else
+		{
+			vis->pivotx = (float)(spr_patch->leftoffset) * this_scale;
+			vis->pivoty = (float)(spr_patch->height / 2) * this_scale;
+		}
+	}
+	vis->rollangle = thing->rollangle;
+#endif
 
 	//Hurdler: 25/04/2000: now support colormap in hardware mode
 	if ((vis->mobj->flags & (MF_ENEMY|MF_BOSS)) && (vis->mobj->flags2 & MF2_FRET) && !(vis->mobj->flags & MF_GRENADEBOUNCE) && (leveltime & 1)) // Bosses "flash"
@@ -5173,8 +5301,11 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing)
 	vis->z1 = z1;
 	vis->z2 = z2;
 	vis->tz = tz;
+	vis->angle = 0;
+	vis->originx = tr_x;
+	vis->originy = tr_y;
+	vis->originz = FIXED_TO_FLOAT(thing->z);
 	vis->dispoffset = 0; // Monster Iestyn: 23/11/15: HARDWARE SUPPORT AT LAST
-	//vis->patchlumpnum = sprframe->lumppat[rot];
 	vis->gpatch = (GLPatch_t *)W_CachePatchNum(sprframe->lumppat[rot], PU_CACHE);
 	vis->flip = flip;
 	vis->mobj = (mobj_t *)thing;
@@ -5182,10 +5313,16 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing)
 	vis->colormap = colormaps;
 
 	// set top/bottom coords
-	vis->ty = FIXED_TO_FLOAT(thing->z + spritecachedinfo[lumpoff].topoffset);
+	vis->ty = vis->originz + FIXED_TO_FLOAT(spritecachedinfo[lumpoff].topoffset);
 
 	vis->precip = true;
 
+#ifdef ROTSPRITE
+	vis->rollangle = 0;
+	vis->pivotx = 0.0f;
+	vis->pivoty = 0.0f;
+#endif
+
 	// okay... this is a hack, but weather isn't networked, so it should be ok
 	if (!(thing->precipflags & PCF_THUNK))
 	{
@@ -5975,9 +6112,20 @@ void HWR_Startup(void)
 // --------------------------------------------------------------------------
 void HWR_Switch(void)
 {
+	// Add session commands
+	HWR_AddSessionCommands();
+
 	// Set special states from CVARs
 	HWD.pfnSetSpecialState(HWD_SET_TEXTUREFILTERMODE, cv_glfiltermode.value);
 	HWD.pfnSetSpecialState(HWD_SET_TEXTUREANISOTROPICMODE, cv_glanisotropicmode.value);
+
+	// Load textures
+	if (!gl_leveltexturesloaded)
+		HWR_LoadTextures(numtextures);
+
+	// Create plane polygons
+	if (gamestate == GS_LEVEL || (gamestate == GS_TITLESCREEN && titlemapinaction))
+		HWR_LoadLevel();
 }
 
 // --------------------------------------------------------------------------

src/hardware/r_opengl/ogl_win.c

@@ -240,7 +240,7 @@ int SetupPixelFormat(INT32 WantColorBits, INT32 WantStencilBits, INT32 WantDepth
 static INT32 WINAPI SetRes(viddef_t *lvid, vmode_t *pcurrentmode)
 {
 	LPCSTR renderer;
-	BOOL WantFullScreen = !(lvid->u.windowed);  //(lvid->u.windowed ? 0 : CDS_FULLSCREEN);
+	BOOL WantFullScreen = !(lvid->windowed);  //(lvid->windowed ? 0 : CDS_FULLSCREEN);
 
 	UNREFERENCED_PARAMETER(pcurrentmode);
 	GL_DBG_Printf ("SetMode(): %dx%d %d bits (%s)\n",

src/hu_stuff.c

@@ -27,7 +27,7 @@
 #include "i_video.h"
 #include "i_system.h"
 
-#include "st_stuff.h" // ST_HEIGHT
+#include "st_stuff.h"
 #include "r_local.h"
 
 #include "keys.h"
@@ -82,10 +82,10 @@ static boolean headsupactive = false;
 boolean hu_showscores; // draw rankings
 static char hu_tick;
 
-patch_t *rflagico;
-patch_t *bflagico;
-patch_t *rmatcico;
-patch_t *bmatcico;
+patch_t **rflagico;
+patch_t **bflagico;
+patch_t **rmatcico;
+patch_t **bmatcico;
 patch_t *tagico;
 patch_t *tallminus;
 patch_t *tallinfin;
@@ -2038,9 +2038,6 @@ static void HU_DrawDemoInfo(void)
 //
 void HU_Drawer(void)
 {
-	if (needpatchrecache)
-		R_ReloadHUDGraphics();
-
 #ifndef NONET
 	// draw chat string plus cursor
 	if (chat_on)
@@ -2468,9 +2465,9 @@ static void HU_Draw32TeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 		if (gametyperules & GTR_TEAMFLAGS)
 		{
 			if (players[tab[i].num].gotflag & GF_REDFLAG) // Red
-				V_DrawFixedPatch((x-10)*FRACUNIT, (y)*FRACUNIT, FRACUNIT/4, 0, rflagico, 0);
+				V_DrawFixedPatch((x-10)*FRACUNIT, (y)*FRACUNIT, FRACUNIT/4, 0, *rflagico, 0);
 			else if (players[tab[i].num].gotflag & GF_BLUEFLAG) // Blue
-				V_DrawFixedPatch((x-10)*FRACUNIT, (y)*FRACUNIT, FRACUNIT/4, 0, bflagico, 0);
+				V_DrawFixedPatch((x-10)*FRACUNIT, (y)*FRACUNIT, FRACUNIT/4, 0, *bflagico, 0);
 		}
 
 		// Draw emeralds
@@ -2596,9 +2593,9 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 		if (gametyperules & GTR_TEAMFLAGS)
 		{
 			if (players[tab[i].num].gotflag & GF_REDFLAG) // Red
-				V_DrawSmallScaledPatch(x-28, y-4, 0, rflagico);
+				V_DrawSmallScaledPatch(x-28, y-4, 0, *rflagico);
 			else if (players[tab[i].num].gotflag & GF_BLUEFLAG) // Blue
-				V_DrawSmallScaledPatch(x-28, y-4, 0, bflagico);
+				V_DrawSmallScaledPatch(x-28, y-4, 0, *bflagico);
 		}
 
 		// Draw emeralds

src/hu_stuff.h

@@ -87,10 +87,10 @@ extern patch_t *ntb_font[NT_FONTSIZE];
 extern patch_t *nto_font[NT_FONTSIZE];
 extern patch_t *ttlnum[10];
 extern patch_t *emeraldpics[3][8];
-extern patch_t *rflagico;
-extern patch_t *bflagico;
-extern patch_t *rmatcico;
-extern patch_t *bmatcico;
+extern patch_t **rflagico;
+extern patch_t **bflagico;
+extern patch_t **rmatcico;
+extern patch_t **bmatcico;
 extern patch_t *tagico;
 extern patch_t *tallminus;
 extern patch_t *tallinfin;

src/i_video.h

@@ -20,26 +20,33 @@
 #pragma interface
 #endif
 
-typedef enum
+typedef enum rendermode_e
 {
-	/// Software
-	render_soft = 1,
+	// No renderer chosen. Used on dedicated mode.
+	render_none = 0,
 
-	/// OpenGL
-	render_opengl = 2,
+	// First renderer choice.
+	// Must start from 1.
+	render_first = 1,
 
-	/// Dedicated
-	render_none = 3  // for dedicated server
+	// Main renderer choices.
+	render_soft = render_first,
+	render_opengl,
+
+	// Last renderer choice.
+	render_last,
+
+	// Renderer count.
+	num_renderers = (render_last - 1),
 } rendermode_t;
 
 /**	\brief current render mode
 */
 extern rendermode_t rendermode;
 
-/**	\brief OpenGL state
-	0 = never loaded, 1 = loaded successfully, -1 = failed loading
+/**	\brief render mode set by command line arguments
 */
-extern INT32 vid_opengl_state;
+extern rendermode_t chosenrendermode;
 
 /**	\brief use highcolor modes if true
 */
@@ -89,9 +96,19 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h);
 */
 INT32 VID_SetMode(INT32 modenum);
 
+/**	\brief	The VID_GetModeName function
+
+	\param	modenum	video mode number
+
+	\return	name of video mode
+*/
+const char *VID_GetModeName(INT32 modenum);
+
 /**	\brief Checks the render state
+
+	\return	true if the renderer changed
 */
-void VID_CheckRenderer(void);
+boolean VID_CheckRenderer(void);
 
 /**	\brief Load OpenGL mode
 */
@@ -101,16 +118,6 @@ void VID_StartupOpenGL(void);
 */
 void VID_CheckGLLoaded(rendermode_t oldrender);
 
-/**	\brief	The VID_GetModeName function
-
-	\param	modenum	video mode number
-
-	\return	name of video mode
-*/
-const char *VID_GetModeName(INT32 modenum);
-void VID_PrepareModeList(void); /// note hack for SDL
-
-
 /**	\brief can video system do fullscreen
 */
 extern boolean allow_fullscreen;