Compare revisions

df1111c3 · df1111c3 · df1111c3 · df1111c3 · df1111c3 · df1111c3
--- a/src/screen.c
+++ b/src/screen.c
@@ -28,6 +28,7 @@
 #include "d_main.h"
 #include "d_clisrv.h"
 #include "f_finale.h"
+#include "y_inter.h" // usebuffer
 #include "i_sound.h" // closed captions
 #include "s_sound.h" // ditto
 #include "g_game.h" // ditto
@@ -63,7 +64,6 @@ consvar_t cv_scr_height = {"scr_height", "800", CV_SAVE, CV_Unsigned, NULL, 0, N
 consvar_t cv_scr_depth = {"scr_depth", "16 bits", CV_SAVE, scr_depth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_renderview = {"renderview", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
-static void SCR_ActuallyChangeRenderer(void);
 CV_PossibleValue_t cv_renderer_t[] = {
 	{1, "Software"},
 #ifdef HWRENDER
@@ -71,7 +71,7 @@ CV_PossibleValue_t cv_renderer_t[] = {
 #endif
 	{0, NULL}
 };
-consvar_t cv_renderer = {"renderer", "Software", CV_SAVE|CV_NOLUA|CV_CALL, cv_renderer_t, SCR_ChangeRenderer, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_renderer = {"renderer", "Software", CV_SAVE|CV_NOLUA|CV_CALL, cv_renderer_t, SCR_SetTargetRenderer, 0, NULL, NULL, 0, 0, NULL};
 static void SCR_ChangeFullscreen(void);
@@ -81,7 +81,6 @@ consvar_t cv_fullscreen = {"fullscreen", "Yes", CV_SAVE|CV_CALL, CV_YesNo, SCR_C
 //                           SCREEN VARIABLES
 // =========================================================================
-INT32 scr_bpp; // current video mode bytes per pixel
 UINT8 *scr_borderpatch; // flat used to fill the reduced view borders set at ST_Init()
 // =========================================================================
@@ -202,14 +201,15 @@ void SCR_SetMode(void)
 	// Lactozilla: Renderer switching
 	if (setrenderneeded)
 	{
-		Z_PreparePatchFlush();
+		// stop recording movies (APNG only)
-		needpatchflush = true;
+		if (setrenderneeded && (moviemode == MM_APNG))
-		needpatchrecache = true;
+			M_StopMovie();
 		VID_CheckRenderer();
-		if (!setmodeneeded)
+		vid.recalc = 1;
-			VID_SetMode(vid.modenum);
 	}
+	// Set the video mode in the video interface.
 	if (setmodeneeded)
 		VID_SetMode(--setmodeneeded);
@@ -279,34 +279,9 @@ void SCR_Startup(void)
 	vid.modenum = 0;
-	vid.dupx = vid.width / BASEVIDWIDTH;
-	vid.dupy = vid.height / BASEVIDHEIGHT;
-	vid.dupx = vid.dupy = (vid.dupx < vid.dupy ? vid.dupx : vid.dupy);
-	vid.fdupx = FixedDiv(vid.width*FRACUNIT, BASEVIDWIDTH*FRACUNIT);
-	vid.fdupy = FixedDiv(vid.height*FRACUNIT, BASEVIDHEIGHT*FRACUNIT);
-#ifdef HWRENDER
-	if (rendermode != render_opengl && rendermode != render_none) // This was just placing it incorrectly at non aspect correct resolutions in opengl
-#endif
-		vid.fdupx = vid.fdupy = (vid.fdupx < vid.fdupy ? vid.fdupx : vid.fdupy);
-	vid.meddupx = (UINT8)(vid.dupx >> 1) + 1;
-	vid.meddupy = (UINT8)(vid.dupy >> 1) + 1;
-#ifdef HWRENDER
-	vid.fmeddupx = vid.meddupx*FRACUNIT;
-	vid.fmeddupy = vid.meddupy*FRACUNIT;
-#endif
-	vid.smalldupx = (UINT8)(vid.dupx / 3) + 1;
-	vid.smalldupy = (UINT8)(vid.dupy / 3) + 1;
-#ifdef HWRENDER
-	vid.fsmalldupx = vid.smalldupx*FRACUNIT;
-	vid.fsmalldupy = vid.smalldupy*FRACUNIT;
-#endif
-	vid.baseratio = FRACUNIT;
 	V_Init();
+	V_Recalc();
 	CV_RegisterVar(&cv_ticrate);
 	CV_RegisterVar(&cv_constextsize);
@@ -320,41 +295,7 @@ void SCR_Recalc(void)
 	if (dedicated)
 		return;
-	// bytes per pixel quick access
+	V_Recalc();
-	scr_bpp = vid.bpp;
-	// scale 1,2,3 times in x and y the patches for the menus and overlays...
-	// calculated once and for all, used by routines in v_video.c
-	vid.dupx = vid.width / BASEVIDWIDTH;
-	vid.dupy = vid.height / BASEVIDHEIGHT;
-	vid.dupx = vid.dupy = (vid.dupx < vid.dupy ? vid.dupx : vid.dupy);
-	vid.fdupx = FixedDiv(vid.width*FRACUNIT, BASEVIDWIDTH*FRACUNIT);
-	vid.fdupy = FixedDiv(vid.height*FRACUNIT, BASEVIDHEIGHT*FRACUNIT);
-#ifdef HWRENDER
-	//if (rendermode != render_opengl && rendermode != render_none) // This was just placing it incorrectly at non aspect correct resolutions in opengl
-	// 13/11/18:
-	// The above is no longer necessary, since we want OpenGL to be just like software now
-	// -- Monster Iestyn
-#endif
-		vid.fdupx = vid.fdupy = (vid.fdupx < vid.fdupy ? vid.fdupx : vid.fdupy);
-	//vid.baseratio = FixedDiv(vid.height << FRACBITS, BASEVIDHEIGHT << FRACBITS);
-	vid.baseratio = FRACUNIT;
-	vid.meddupx = (UINT8)(vid.dupx >> 1) + 1;
-	vid.meddupy = (UINT8)(vid.dupy >> 1) + 1;
-#ifdef HWRENDER
-	vid.fmeddupx = vid.meddupx*FRACUNIT;
-	vid.fmeddupy = vid.meddupy*FRACUNIT;
-#endif
-	vid.smalldupx = (UINT8)(vid.dupx / 3) + 1;
-	vid.smalldupy = (UINT8)(vid.dupy / 3) + 1;
-#ifdef HWRENDER
-	vid.fsmalldupx = vid.smalldupx*FRACUNIT;
-	vid.fsmalldupy = vid.smalldupy*FRACUNIT;
-#endif
 	// toggle off (then back on) the automap because some screensize-dependent values will
 	// be calculated next time the automap is activated.
@@ -369,11 +310,17 @@ void SCR_Recalc(void)
 	// scr_viewsize doesn't change, neither detailLevel, but the pixels
 	// per screenblock is different now, since we've changed resolution.
-	R_SetViewSize(); //just set setsizeneeded true now ..
+	R_ViewSizeChanged(); //just set setsizeneeded true now ..
 	// vid.recalc lasts only for the next refresh...
 	con_recalc = true;
 	am_recalc = true;
+#ifdef HWRENDER
+	// Shoot! The screen texture was flushed!
+	if ((rendermode == render_opengl) && (gamestate == GS_INTERMISSION))
+		usebuffer = false;
+#endif
 }
 // Check for screen cmd-line parms: to force a resolution.
@@ -411,7 +358,19 @@ void SCR_CheckDefaultMode(void)
 		setmodeneeded = VID_GetModeForSize(cv_scr_width.value, cv_scr_height.value) + 1;
 	}
-	SCR_ActuallyChangeRenderer();
+	if (cv_renderer.value != (signed)rendermode)
+	{
+		if (chosenrendermode == render_none) // nothing set at command line
+			SCR_ChangeRenderer();
+		else
+		{
+			// Set cv_renderer to the current render mode
+			CV_StealthSetValue(&cv_renderer, rendermode);
+#ifdef HWRENDER
+			CV_StealthSetValue(&cv_newrenderer, rendermode);
+#endif
+		}
+	}
 }
 // sets the modenum as the new default video mode to be saved in the config file
@@ -427,81 +386,42 @@ void SCR_SetDefaultMode(void)
 void SCR_ChangeFullscreen(void)
 {
 #ifdef DIRECTFULLSCREEN
-	// allow_fullscreen is set by VID_PrepareModeList
+	// allow_fullscreen is used to prevent switching to fullscreen during startup
-	// it is used to prevent switching to fullscreen during startup
 	if (!allow_fullscreen)
 		return;
 	if (graphics_started)
-	{
-		VID_PrepareModeList();
 		setmodeneeded = VID_GetModeForSize(vid.width, vid.height) + 1;
-	}
-	return;
 #endif
 }
-static int target_renderer = 0;
+void SCR_SetTargetRenderer(void)
+{
+	if (!con_refresh)
+		SCR_ChangeRenderer();
+}
-void SCR_ActuallyChangeRenderer(void)
+void SCR_ChangeRenderer(void)
 {
-	setrenderneeded = target_renderer;
+	if ((signed)rendermode == cv_renderer.value)
+		return;
 #ifdef HWRENDER
-	// Well, it didn't even load anyway.
+	// Check if OpenGL loaded successfully (or wasn't disabled) before switching to it.
-	if ((vid_opengl_state == -1) && (setrenderneeded == render_opengl))
+	if ((vid.glstate == VID_GL_LIBRARY_ERROR)
+	&& (cv_renderer.value == render_opengl))
 	{
 		if (M_CheckParm("-nogl"))
 			CONS_Alert(CONS_ERROR, "OpenGL rendering was disabled!\n");
 		else
 			CONS_Alert(CONS_ERROR, "OpenGL never loaded\n");
-		setrenderneeded = 0;
 		return;
 	}
 #endif
-	// setting the same renderer twice WILL crash your game, so let's not, please
+	// Set the new render mode
-	if (rendermode == setrenderneeded)
+	setrenderneeded = cv_renderer.value;
-		setrenderneeded = 0;
+	con_refresh = false;
-}
-// Lactozilla: Renderer switching
-void SCR_ChangeRenderer(void)
-{
-	setrenderneeded = 0;
-	if (con_startup)
-	{
-		target_renderer = cv_renderer.value;
-#ifdef HWRENDER
-		if (M_CheckParm("-opengl") && (vid_opengl_state == 1))
-			target_renderer = rendermode = render_opengl;
-		else
-#endif
-		if (M_CheckParm("-software"))
-			target_renderer = rendermode = render_soft;
-		// set cv_renderer back
-		SCR_ChangeRendererCVars(rendermode);
-		return;
-	}
-	if (cv_renderer.value == 1)
-		target_renderer = render_soft;
-	else if (cv_renderer.value == 2)
-		target_renderer = render_opengl;
-	SCR_ActuallyChangeRenderer();
-}
-void SCR_ChangeRendererCVars(INT32 mode)
-{
-	// set cv_renderer back
-	if (mode == render_soft)
-		CV_StealthSetValue(&cv_renderer, 1);
-	else if (mode == render_opengl)
-		CV_StealthSetValue(&cv_renderer, 2);
-#ifdef HWRENDER
-	CV_StealthSetValue(&cv_newrenderer, cv_renderer.value);
-#endif
 }
 boolean SCR_IsAspectCorrect(INT32 width, INT32 height)

--- a/src/screen.h
+++ b/src/screen.h
@@ -30,10 +30,6 @@
 #define NUMSCREENS 5
 #endif
-// Size of statusbar.
-#define ST_HEIGHT 32
-#define ST_WIDTH 320
 // used now as a maximum video mode size for extra vesa modes.
 // we try to re-allocate a minimum of buffers for stability of the memory,
@@ -48,34 +44,40 @@
 typedef struct viddef_s
 {
 	INT32 modenum; // vidmode num indexes videomodes list
+	UINT8 *buffer; // screen buffers
+	UINT8 *direct; // direct screen buffer (DOS VGA)
-	UINT8 *buffer; // invisible screens buffer
+	INT32 width, height; // screen dimensions
 	size_t rowbytes; // bytes per scanline of the VIDEO mode
-	INT32 width; // PIXELS per scanline
-	INT32 height;
-	union { // don't need numpages for OpenGL, so we can use it for fullscreen/windowed mode
-		INT32 numpages; // always 1, page flipping todo
-		INT32 windowed; // windowed or fullscren mode?
-	} u;
-	INT32 recalc; // if true, recalc vid-based stuff
-	UINT8 *direct; // linear frame buffer, or vga base mem.
-	INT32 dupx, dupy; // scale 1, 2, 3 value for menus & overlays
-	INT32/*fixed_t*/ fdupx, fdupy; // same as dupx, dupy, but exact value when aspect ratio isn't 320/200
 	INT32 bpp; // BYTES per pixel: 1 = 256color, 2 = highcolor
-	INT32 baseratio; // Used to get the correct value for lighting walls
+	INT32 recalc; // if true, recalc vid-based stuff
+	INT32 numpages; // page flipping
+	INT32 windowed; // windowed or fullscreen mode? (DirectDraw)
-	// for Win32 version
+	INT32 dupx, dupy; // scale 1, 2, 3 value for menus & overlays
-	DNWH WndParent; // handle of the application's window
+	INT32/*fixed_t*/ fdupx, fdupy; // same as dupx, dupy, but exact value when aspect ratio isn't 320/200
 	UINT8 smalldupx, smalldupy; // factor for a little bit of scaling
 	UINT8 meddupx, meddupy; // factor for moderate, but not full, scaling
 #ifdef HWRENDER
 	INT32/*fixed_t*/ fsmalldupx, fsmalldupy;
 	INT32/*fixed_t*/ fmeddupx, fmeddupy;
+	INT32 glstate;
+#endif
+	// for Win32 version
+#if defined(_WINDOWS)
+	DNWH WndParent; // handle of the application's window
 #endif
 } viddef_t;
-#define VIDWIDTH vid.width
-#define VIDHEIGHT vid.height
+enum
+{
+	VID_GL_LIBRARY_NOTLOADED  = 0,
+	VID_GL_LIBRARY_LOADED     = 1,
+	VID_GL_LIBRARY_ERROR      = -1,
+};
 // internal additional info for vesa modes only
 typedef struct
@@ -83,6 +85,7 @@ typedef struct
 	INT32 vesamode; // vesa mode number plus LINEAR_MODE bit
 	void *plinearmem; // linear address of start of frame buffer
 } vesa_extra_t;
 // a video modes from the video modes list,
 // note: video mode 0 is always standard VGA320x200.
 typedef struct vmode_s
@@ -171,12 +174,11 @@ extern boolean R_SSE2;
 extern viddef_t vid;
 extern INT32 setmodeneeded; // mode number to set if needed, or 0
+extern UINT8 setrenderneeded;
 void SCR_ChangeRenderer(void);
-void SCR_ChangeRendererCVars(INT32 mode);
+void SCR_SetTargetRenderer(void);
-extern UINT8 setrenderneeded;
-extern INT32 scr_bpp;
 extern UINT8 *scr_borderpatch; // patch used to fill the view borders
 extern CV_PossibleValue_t cv_renderer_t[];
@@ -185,20 +187,25 @@ extern consvar_t cv_scr_width, cv_scr_height, cv_scr_depth, cv_renderview, cv_re
 #ifdef HWRENDER
 extern consvar_t cv_newrenderer;
 #endif
-// wait for page flipping to end or not
+extern consvar_t cv_vidwait; // wait for page flipping to end or not
-extern consvar_t cv_vidwait;
+// Initialize the screen
+void SCR_Startup(void);
 // Change video mode, only at the start of a refresh.
 void SCR_SetMode(void);
+// Set drawer functions for Software
 void SCR_SetDrawFuncs(void);
 // Recalc screen size dependent stuff
 void SCR_Recalc(void);
 // Check parms once at startup
 void SCR_CheckDefaultMode(void);
-// Set the mode number which is saved in the config
-void SCR_SetDefaultMode (void);
-void SCR_Startup (void);
+// Set the mode number which is saved in the config
+void SCR_SetDefaultMode(void);
 FUNCMATH boolean SCR_IsAspectCorrect(INT32 width, INT32 height);

--- a/src/sdl/Srb2SDL-vc10.vcxproj
+++ b/src/sdl/Srb2SDL-vc10.vcxproj
@@ -283,6 +283,8 @@
    <ClInclude Include="..\r_main.h" />
    <ClInclude Include="..\r_plane.h" />
    <ClInclude Include="..\r_patch.h" />
+    <ClInclude Include="..\r_rotsprite.h" />
+    <ClInclude Include="..\r_patchtrees.h" />
    <ClInclude Include="..\r_portal.h" />
    <ClInclude Include="..\r_segs.h" />
    <ClInclude Include="..\r_skins.h" />
@@ -447,7 +449,8 @@
    </ClCompile>
    <ClCompile Include="..\r_main.c" />
    <ClCompile Include="..\r_plane.c" />
-	<ClCompile Include="..\r_patch.c" />
+    <ClCompile Include="..\r_patch.c" />
+    <ClCompile Include="..\r_rotsprite.c" />
    <ClCompile Include="..\r_portal.c" />
    <ClCompile Include="..\r_segs.c" />
    <ClCompile Include="..\r_skins.c" />

--- a/src/sdl/Srb2SDL-vc10.vcxproj.filters
+++ b/src/sdl/Srb2SDL-vc10.vcxproj.filters
@@ -474,6 +474,12 @@
    <ClInclude Include="..\r_patch.h">
      <Filter>R_Rend</Filter>
    </ClInclude>
+    <ClInclude Include="..\r_rotsprite.h">
+      <Filter>R_Rend</Filter>
+    </ClInclude>
+    <ClInclude Include="..\r_patchtrees.h">
+      <Filter>R_Rend</Filter>
+    </ClInclude>
    <ClInclude Include="..\r_portal.h">
      <Filter>R_Rend</Filter>
    </ClInclude>
@@ -946,6 +952,9 @@
    <ClCompile Include="..\r_patch.c">
      <Filter>R_Rend</Filter>
    </ClCompile>
+    <ClCompile Include="..\r_rotsprite.c">
+      <Filter>R_Rend</Filter>
+    </ClCompile>
    <ClCompile Include="..\r_portal.c">
      <Filter>R_Rend</Filter>
    </ClCompile>

--- a/src/sdl/i_video.c
+++ b/src/sdl/i_video.c
@@ -73,6 +73,7 @@
 #include "../console.h"
 #include "../command.h"
 #include "../r_main.h"
+#include "../r_patch.h" // Patch_UpdateReferences
 #include "../lua_hook.h"
 #include "sdlmain.h"
 #ifdef HWRENDER
@@ -95,7 +96,7 @@ static INT32 numVidModes = -1;
 static char vidModeName[33][32]; // allow 33 different modes
 rendermode_t rendermode = render_soft;
-static rendermode_t chosenrendermode = render_soft; // set by command line arguments
+rendermode_t chosenrendermode = render_none; // set by command line arguments
 boolean highcolor = false;
@@ -105,9 +106,8 @@ static consvar_t cv_stretch = {"stretch", "Off", CV_SAVE|CV_NOSHOWHELP, CV_OnOff
 static consvar_t cv_alwaysgrabmouse = {"alwaysgrabmouse", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 UINT8 graphics_started = 0; // Is used in console.c and screen.c
-INT32 vid_opengl_state = 0;
-// To disable fullscreen at startup; is set in VID_PrepareModeList
+// To disable fullscreen at startup; is set in I_PrepareVideoModeList
 boolean allow_fullscreen = false;
 static SDL_bool disable_fullscreen = SDL_FALSE;
 #define USE_FULLSCREEN (disable_fullscreen||!allow_fullscreen)?0:cv_fullscreen.value
@@ -1340,110 +1340,14 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h)
 		}
 	}
 	return -1;
-#if 0
-	INT32 matchMode = -1, i;
-	VID_PrepareModeList();
-	if (USE_FULLSCREEN && numVidModes != -1)
-	{
-		for (i=firstEntry; i<numVidModes; i++)
-		{
-			if (modeList[i]->w == w &&
-			    modeList[i]->h == h)
-			{
-				matchMode = i;
-				break;
-			}
-		}
-		if (-1 == matchMode) // use smaller mode
-		{
-			w -= w%BASEVIDWIDTH;
-			h -= h%BASEVIDHEIGHT;
-			for (i=firstEntry; i<numVidModes; i++)
-			{
-				if (modeList[i]->w == w &&
-				    modeList[i]->h == h)
-				{
-					matchMode = i;
-					break;
-				}
-			}
-			if (-1 == matchMode) // use smallest mode
-				matchMode = numVidModes-1;
-		}
-		matchMode -= firstEntry;
-	}
-	else
-	{
-		for (i=0; i<MAXWINMODES; i++)
-		{
-			if (windowedModes[i][0] == w &&
-			    windowedModes[i][1] == h)
-			{
-				matchMode = i;
-				break;
-			}
-		}
-		if (-1 == matchMode) // use smaller mode
-		{
-			w -= w%BASEVIDWIDTH;
-			h -= h%BASEVIDHEIGHT;
-			for (i=0; i<MAXWINMODES; i++)
-			{
-				if (windowedModes[i][0] == w &&
-				    windowedModes[i][1] == h)
-				{
-					matchMode = i;
-					break;
-				}
-			}
-			if (-1 == matchMode) // use smallest mode
-				matchMode = MAXWINMODES-1;
-		}
-	}
-	return matchMode;
-#endif
-}
-void VID_PrepareModeList(void)
-{
-	// Under SDL2, we just use the windowed modes list, and scale in windowed fullscreen.
-	allow_fullscreen = true;
-#if 0
-	INT32 i;
-	firstEntry = 0;
-#ifdef HWRENDER
-	if (rendermode == render_opengl)
-		modeList = SDL_ListModes(NULL, SDL_OPENGL|SDL_FULLSCREEN);
-	else
-#endif
-	modeList = SDL_ListModes(NULL, surfaceFlagsF|SDL_HWSURFACE); //Alam: At least hardware surface
-	if (disable_fullscreen?0:cv_fullscreen.value) // only fullscreen needs preparation
-	{
-		if (-1 != numVidModes)
-		{
-			for (i=0; i<numVidModes; i++)
-			{
-				if (modeList[i]->w <= MAXVIDWIDTH &&
-					modeList[i]->h <= MAXVIDHEIGHT)
-				{
-					firstEntry = i;
-					break;
-				}
-			}
-		}
-	}
-	allow_fullscreen = true;
-#endif
 }
 static SDL_bool Impl_CreateContext(void)
 {
 	// Renderer-specific stuff
 #ifdef HWRENDER
-	if ((rendermode == render_opengl) && (vid_opengl_state != -1))
+	if ((rendermode == render_opengl)
+	&& (vid.glstate != VID_GL_LIBRARY_ERROR))
 	{
 		if (!sdlglcontext)
 			sdlglcontext = SDL_GL_CreateContext(window);
@@ -1479,30 +1383,29 @@ static SDL_bool Impl_CreateContext(void)
 void VID_CheckGLLoaded(rendermode_t oldrender)
 {
 #ifdef HWRENDER
-	if (vid_opengl_state == -1) // Well, it didn't work the first time anyway.
+	if (vid.glstate == VID_GL_LIBRARY_ERROR) // Well, it didn't work the first time anyway.
 	{
 		CONS_Alert(CONS_ERROR, "OpenGL never loaded\n");
 		rendermode = oldrender;
 		if (chosenrendermode == render_opengl) // fallback to software
 			rendermode = render_soft;
-		if (setrenderneeded)
-		{
+		CV_StealthSetValue(&cv_renderer, oldrender);
-			CV_StealthSetValue(&cv_renderer, oldrender);
+		CV_StealthSetValue(&cv_newrenderer, oldrender);
-			CV_StealthSetValue(&cv_newrenderer, oldrender);
-			setrenderneeded = 0;
-		}
 	}
 #endif
 }
-void VID_CheckRenderer(void)
+boolean VID_CheckRenderer(void)
 {
 	boolean rendererchanged = false;
 	boolean contextcreated = false;
+#ifdef HWRENDER
 	rendermode_t oldrenderer = rendermode;
+#endif
 	if (dedicated)
-		return;
+		return false;
 	if (setrenderneeded)
 	{
@@ -1516,11 +1419,12 @@ void VID_CheckRenderer(void)
 			// Initialise OpenGL before calling SDLSetMode!!!
 			// This is because SDLSetMode calls OglSdlSurface.
-			if (vid_opengl_state == 0)
+			if (vid.glstate == VID_GL_LIBRARY_NOTLOADED)
 			{
 				VID_StartupOpenGL();
 				// Loaded successfully!
-				if (vid_opengl_state == 1)
+				if (vid.glstate == VID_GL_LIBRARY_LOADED)
 				{
 					// Destroy the current window, if it exists.
 					if (window)
@@ -1543,11 +1447,17 @@ void VID_CheckRenderer(void)
 					contextcreated = true;
 				}
 			}
-			else if (vid_opengl_state == -1)
+			else if (vid.glstate == VID_GL_LIBRARY_ERROR)
 				rendererchanged = false;
 		}
 #endif
+		if (rendererchanged)
+		{
+			Patch_UpdateReferences();
+			V_ReloadHUDGraphics();
+		}
 		if (!contextcreated)
 			Impl_CreateContext();
@@ -1565,27 +1475,22 @@ void VID_CheckRenderer(void)
 			bufSurface = NULL;
 		}
-		if (rendererchanged)
-		{
 #ifdef HWRENDER
-			if (vid_opengl_state == 1) // Only if OpenGL ever loaded!
+		if (rendererchanged && vid.glstate == VID_GL_LIBRARY_LOADED) // Only if OpenGL ever loaded!
-				HWR_FreeTextureCache();
+			HWR_FreeTextureCache();
 #endif
-			SCR_SetDrawFuncs();
-		}
+		SCR_SetDrawFuncs();
 	}
 #ifdef HWRENDER
-	else if (rendermode == render_opengl)
+	else if (rendermode == render_opengl && rendererchanged)
 	{
-		if (rendererchanged)
+		HWR_Switch();
-		{
+		V_SetPalette(0);
-			R_InitHardwareMode();
-			V_SetPalette(0);
-		}
 	}
-#else
-	(void)oldrenderer;
 #endif
+	return rendererchanged;
 }
 INT32 VID_SetMode(INT32 modeNum)
@@ -1626,7 +1531,7 @@ static SDL_bool Impl_CreateWindow(SDL_bool fullscreen)
 		flags |= SDL_WINDOW_BORDERLESS;
 #ifdef HWRENDER
-	if (vid_opengl_state == 1)
+	if (vid.glstate == VID_GL_LIBRARY_LOADED)
 		flags |= SDL_WINDOW_OPENGL;
 #endif
@@ -1660,7 +1565,7 @@ static void Impl_SetWindowName(const char *title)
 static void Impl_SetWindowIcon(void)
 {
 	if (window && icoSurface)
-		SDL_SetWindowIcon(window, icoSurface);	
+		SDL_SetWindowIcon(window, icoSurface);
 }
 static void Impl_VideoSetupSDLBuffer(void)
@@ -1747,12 +1652,44 @@ void I_StartupGraphics(void)
 			framebuffer = SDL_TRUE;
 	}
-#ifdef HWRENDER
+	// Renderer choices
-	if (M_CheckParm("-opengl"))
+	// Takes priority over the config.
-		chosenrendermode = rendermode = render_opengl;
+	if (M_CheckParm("-renderer"))
+	{
+		INT32 i = 0;
+		CV_PossibleValue_t *renderer_list = cv_renderer_t;
+		const char *modeparm = M_GetNextParm();
+		while (renderer_list[i].strvalue)
+		{
+			if (!stricmp(modeparm, renderer_list[i].strvalue))
+			{
+				chosenrendermode = renderer_list[i].value;
+				break;
+			}
+			i++;
+		}
+	}
+	// Choose Software renderer
 	else if (M_CheckParm("-software"))
+		chosenrendermode = render_soft;
+#ifdef HWRENDER
+	// Choose OpenGL renderer
+	else if (M_CheckParm("-opengl"))
+		chosenrendermode = render_opengl;
+	// Don't startup OpenGL
+	if (M_CheckParm("-nogl"))
+	{
+		vid.glstate = VID_GL_LIBRARY_ERROR;
+		if (chosenrendermode == render_opengl)
+			chosenrendermode = render_none;
+	}
 #endif
-		chosenrendermode = rendermode = render_soft;
+	if (chosenrendermode != render_none)
+		rendermode = chosenrendermode;
 	usesdl2soft = M_CheckParm("-softblit");
 	borderlesswindow = M_CheckParm("-borderless");
@@ -1761,16 +1698,14 @@ void I_StartupGraphics(void)
 	VID_Command_ModeList_f();
 #ifdef HWRENDER
-	if (M_CheckParm("-nogl"))
+	if (rendermode == render_opengl)
-		vid_opengl_state = -1; // Don't startup OpenGL
-	else if (chosenrendermode == render_opengl)
 		VID_StartupOpenGL();
 #endif
 	// Window icon
 #ifdef HAVE_IMAGE
 	icoSurface = IMG_ReadXPMFromArray(SDL_icon_xpm);
-#endif	
+#endif
 	// Fury: we do window initialization after GL setup to allow
 	// SDL_GL_LoadLibrary to work well on Windows
@@ -1782,10 +1717,9 @@ void I_StartupGraphics(void)
 	vid.width = BASEVIDWIDTH; // Default size for startup
 	vid.height = BASEVIDHEIGHT; // BitsPerPixel is the SDL interface's
-	vid.recalc = true; // Set up the console stufff
+	vid.recalc = true; // Set up the console stuff
 	vid.direct = NULL; // Maybe direct access?
 	vid.bpp = 1; // This is the game engine's Bpp
-	vid.WndParent = NULL; //For the window?
 #ifdef HAVE_TTF
 	I_ShutdownTTF();
@@ -1854,19 +1788,17 @@ void VID_StartupOpenGL(void)
 		HWD.pfnMakeScreenTexture= hwSym("MakeScreenTexture",NULL);
 		HWD.pfnMakeScreenFinalTexture=hwSym("MakeScreenFinalTexture",NULL);
 		HWD.pfnDrawScreenFinalTexture=hwSym("DrawScreenFinalTexture",NULL);
 		HWD.pfnLoadShaders      = hwSym("LoadShaders",NULL);
 		HWD.pfnKillShaders      = hwSym("KillShaders",NULL);
 		HWD.pfnSetShader        = hwSym("SetShader",NULL);
 		HWD.pfnUnSetShader      = hwSym("UnSetShader",NULL);
 		HWD.pfnSetShaderInfo    = hwSym("SetShaderInfo",NULL);
 		HWD.pfnLoadCustomShader = hwSym("LoadCustomShader",NULL);
 		HWD.pfnInitCustomShaders= hwSym("InitCustomShaders",NULL);
-		vid_opengl_state = HWD.pfnInit() ? 1 : -1; // let load the OpenGL library
+		vid.glstate = HWD.pfnInit() ? VID_GL_LIBRARY_LOADED : VID_GL_LIBRARY_ERROR; // let load the OpenGL library
-		if (vid_opengl_state == -1)
+		if (vid.glstate == VID_GL_LIBRARY_ERROR)
 		{
 			rendermode = render_soft;
 			setrenderneeded = 0;

--- a/src/st_stuff.c
+++ b/src/st_stuff.c
@@ -302,13 +302,13 @@ void ST_LoadGraphics(void)
 	sneakers = W_CachePatchName("TVSSICON", PU_HUDGFX);
 	gravboots = W_CachePatchName("TVGVICON", PU_HUDGFX);
-	tagico = W_CachePatchName("TAGICO", PU_HUDGFX);
+	rflagico = (patch_t **)W_GetPatchPointerFromName("RFLAGICO", PU_HUDGFX);
-	rflagico = W_CachePatchName("RFLAGICO", PU_HUDGFX);
+	bflagico = (patch_t **)W_GetPatchPointerFromName("BFLAGICO", PU_HUDGFX);
-	bflagico = W_CachePatchName("BFLAGICO", PU_HUDGFX);
+	rmatcico = (patch_t **)W_GetPatchPointerFromName("RMATCICO", PU_HUDGFX);
-	rmatcico = W_CachePatchName("RMATCICO", PU_HUDGFX);
+	bmatcico = (patch_t **)W_GetPatchPointerFromName("BMATCICO", PU_HUDGFX);
-	bmatcico = W_CachePatchName("BMATCICO", PU_HUDGFX);
 	gotrflag = W_CachePatchName("GOTRFLAG", PU_HUDGFX);
 	gotbflag = W_CachePatchName("GOTBFLAG", PU_HUDGFX);
+	tagico = W_CachePatchName("TAGICO", PU_HUDGFX);
 	fnshico = W_CachePatchName("FNSHICO", PU_HUDGFX);
 	nonicon = W_CachePatchName("NONICON", PU_HUDGFX);
 	nonicon2 = W_CachePatchName("NONICON2", PU_HUDGFX);
@@ -2374,17 +2374,17 @@ static void ST_drawTeamHUD(void)
 		return;
 	if (gametyperules & GTR_TEAMFLAGS)
-		p = bflagico;
+		p = *bflagico;
 	else
-		p = bmatcico;
+		p = *bmatcico;
 	if (LUA_HudEnabled(hud_teamscores))
 		V_DrawSmallScaledPatch(BASEVIDWIDTH/2 - SEP - SHORT(p->width)/4, 4, V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, p);
 	if (gametyperules & GTR_TEAMFLAGS)
-		p = rflagico;
+		p = *rflagico;
 	else
-		p = rmatcico;
+		p = *rmatcico;
 	if (LUA_HudEnabled(hud_teamscores))
 		V_DrawSmallScaledPatch(BASEVIDWIDTH/2 + SEP - SHORT(p->width)/4, 4, V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, p);
@@ -2755,9 +2755,6 @@ static void ST_overlayDrawer(void)
 void ST_Drawer(void)
 {
-	if (needpatchrecache)
-		R_ReloadHUDGraphics();
 #ifdef SEENAMES
 	if (cv_seenames.value && cv_allowseenames.value && displayplayer == consoleplayer && seenplayer && seenplayer->mo)
 	{

--- a/src/v_video.c
+++ b/src/v_video.c
@@ -3719,3 +3719,43 @@ void V_Init(void)
 		CONS_Debug(DBG_RENDER, " screens[%d] = %x\n", i, screens[i]);
 #endif
 }
+void V_Recalc(void)
+{
+	// scale 1,2,3 times in x and y the patches for the menus and overlays...
+	// calculated once and for all, used by routines in v_video.c and v_draw.c
+	vid.dupx = vid.width / BASEVIDWIDTH;
+	vid.dupy = vid.height / BASEVIDHEIGHT;
+	vid.dupx = vid.dupy = (vid.dupx < vid.dupy ? vid.dupx : vid.dupy);
+	vid.fdupx = FixedDiv(vid.width*FRACUNIT, BASEVIDWIDTH*FRACUNIT);
+	vid.fdupy = FixedDiv(vid.height*FRACUNIT, BASEVIDHEIGHT*FRACUNIT);
+#ifdef HWRENDER
+	//if (rendermode != render_opengl && rendermode != render_none) // This was just placing it incorrectly at non aspect correct resolutions in opengl
+	// 13/11/18:
+	// The above is no longer necessary, since we want OpenGL to be just like software now
+	// -- Monster Iestyn
+#endif
+		vid.fdupx = vid.fdupy = (vid.fdupx < vid.fdupy ? vid.fdupx : vid.fdupy);
+	vid.meddupx = (UINT8)(vid.dupx >> 1) + 1;
+	vid.meddupy = (UINT8)(vid.dupy >> 1) + 1;
+#ifdef HWRENDER
+	vid.fmeddupx = vid.meddupx*FRACUNIT;
+	vid.fmeddupy = vid.meddupy*FRACUNIT;
+#endif
+	vid.smalldupx = (UINT8)(vid.dupx / 3) + 1;
+	vid.smalldupy = (UINT8)(vid.dupy / 3) + 1;
+#ifdef HWRENDER
+	vid.fsmalldupx = vid.smalldupx*FRACUNIT;
+	vid.fsmalldupy = vid.smalldupy*FRACUNIT;
+#endif
+}
+void V_ReloadHUDGraphics(void)
+{
+	ST_LoadGraphics();
+	HU_LoadGraphics();
+	ST_ReloadSkinFaceGraphics();
+}
--- a/src/v_video.h
+++ b/src/v_video.h
@@ -37,6 +37,9 @@ cv_allcaps;
 // Allocates buffer screens, call before R_Init.
 void V_Init(void);
+// Recalculates the viddef (dupx, dupy, etc.) according to the current screen resolution.
+void V_Recalc(void);
 // Color look-up table
 #define COLORBITS 6
 #define SHIFTCOLORBITS (8-COLORBITS)
@@ -264,6 +267,8 @@ INT32 V_SmallThinStringWidth(const char *string, INT32 option);
 void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param);
+void V_ReloadHUDGraphics(void);
 void V_DrawPatchFill(patch_t *pat);
 void VID_BlitLinearScreen(const UINT8 *srcptr, UINT8 *destptr, INT32 width, INT32 height, size_t srcrowbytes,

--- a/src/w_wad.c
+++ b/src/w_wad.c
@@ -56,6 +56,8 @@
 #include "d_clisrv.h"
 #include "r_defs.h"
 #include "r_data.h"
+#include "r_patch.h"
+#include "r_rotsprite.h"
 #include "i_system.h"
 #include "md5.h"
 #include "lua_script.h"
@@ -834,12 +836,7 @@ UINT16 W_InitFile(const char *filename, boolean mainfile, boolean startup)
 	// set up caching
 	//
 	Z_Calloc(numlumps * sizeof (*wadfile->lumpcache), PU_STATIC, &wadfile->lumpcache);
-	Z_Calloc(numlumps * sizeof (*wadfile->patchcache), PU_STATIC, &wadfile->patchcache);
+	Patch_InitInfo(wadfile);
-#ifdef HWRENDER
-	// allocates GLPatch info structures and store them in a tree
-	wadfile->hwrcache = M_AATreeAlloc(AATREE_ZUSER);
-#endif
 	//
 	// add the wadfile
@@ -850,7 +847,7 @@ UINT16 W_InitFile(const char *filename, boolean mainfile, boolean startup)
 #ifdef HWRENDER
 	// Read shaders from file
-	if (rendermode == render_opengl && (vid_opengl_state == 1))
+	if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
 	{
 		HWR_ReadShaders(numwadfiles - 1, (type == RET_PK3));
 		HWR_LoadShaders();
@@ -1609,157 +1606,149 @@ boolean W_IsLumpCached(lumpnum_t lumpnum, void *ptr)
 	return W_IsLumpCachedPWAD(WADFILENUM(lumpnum),LUMPNUM(lumpnum), ptr);
 }
-//
+// ==========================================================================
-// W_IsPatchCached
+// W_CacheLumpName
-//
+// ==========================================================================
-// If a patch is already cached return true, otherwise
+void *W_CacheLumpName(const char *name, INT32 tag)
-// return false.
-//
-// no outside code uses the PWAD form, for now
-static inline boolean W_IsPatchCachedPWAD(UINT16 wad, UINT16 lump, void *ptr)
 {
-	void *lcache;
+	return W_CacheLumpNum(W_GetNumForName(name), tag);
+}
+void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
+{
 	if (!TestValidLump(wad, lump))
-		return false;
+		return NULL;
-	lcache = wadfiles[wad]->patchcache[lump];
-	if (ptr)
-	{
-		if (ptr == lcache)
-			return true;
-	}
-	else if (lcache)
-		return true;
-	return false;
+	return Patch_CacheSoftware(wad, lump, tag, false);
 }
-boolean W_IsPatchCached(lumpnum_t lumpnum, void *ptr)
+void *W_CacheSoftwarePatchNum(lumpnum_t lumpnum, INT32 tag)
 {
-	return W_IsPatchCachedPWAD(WADFILENUM(lumpnum),LUMPNUM(lumpnum), ptr);
+	return W_CacheSoftwarePatchNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum),tag);
 }
-// ==========================================================================
+void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
-// W_CacheLumpName
-// ==========================================================================
-void *W_CacheLumpName(const char *name, INT32 tag)
 {
-	return W_CacheLumpNum(W_GetNumForName(name), tag);
+	if (!TestValidLump(wad, lump))
-}
+		return NULL;
-// ==========================================================================
+#ifdef HWRENDER
-//                                         CACHING OF GRAPHIC PATCH RESOURCES
+	if (rendermode == render_opengl)
-// ==========================================================================
+		return (void *)Patch_CacheGL(wad, lump, tag, false);
+	else
+#endif
+		return Patch_CacheSoftware(wad, lump, tag, false);
+}
-// Graphic 'patches' are loaded, and if necessary, converted into the format
+void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag)
-// the most useful for the current rendermode. For software renderer, the
+{
-// graphic patches are kept as is. For the hardware renderer, graphic patches
+	return W_CachePatchNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum),tag);
-// are 'unpacked', and are kept into the cache in that unpacked format, and
+}
-// the heap memory cache then acts as a 'level 2' cache just after the
-// graphics card memory.
-//
+void *W_CachePatchName(const char *name, INT32 tag)
-// Cache a patch into heap memory, convert the patch format as necessary
+{
-//
+	lumpnum_t num = W_CheckNumForName(name);
+	if (num == LUMPERROR)
+		return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
+	return W_CachePatchNum(num, tag);
+}
-void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
+void *W_CachePatchLongName(const char *name, INT32 tag)
 {
-	lumpcache_t *lumpcache = NULL;
+	lumpnum_t num = W_CheckNumForLongName(name);
+	if (num == LUMPERROR)
+		return W_CachePatchNum(W_GetNumForLongName("MISSING"), tag);
+	return W_CachePatchNum(num, tag);
+}
+void **W_GetPatchPointerPwad(UINT16 wad, UINT16 lump, INT32 tag)
+{
+	void **pp;
 	if (!TestValidLump(wad, lump))
 		return NULL;
-	lumpcache = wadfiles[wad]->patchcache;
+	pp = (void **)(&(wadfiles[wad]->patchinfo.current[lump]));
+	if (*pp) // Already cached
+		return pp;
-	if (!lumpcache[lump])
+#ifdef HWRENDER
-	{
+	if (rendermode == render_opengl)
-		size_t len = W_LumpLengthPwad(wad, lump);
+		Patch_CacheGL(wad, lump, tag, true);
-		void *ptr, *lumpdata;
+	else
-#ifndef NO_PNG_LUMPS
-		void *srcdata = NULL;
 #endif
+		Patch_CacheSoftware(wad, lump, tag, true);
-		ptr = Z_Malloc(len, tag, &lumpcache[lump]);
+	return pp;
-		lumpdata = Z_Malloc(len, tag, NULL);
+}
-		// read the lump in full
-		W_ReadLumpHeaderPwad(wad, lump, lumpdata, 0, 0);
-#ifndef NO_PNG_LUMPS
+void **W_GetPatchPointer(lumpnum_t lumpnum, INT32 tag)
-		// lump is a png so convert it
+{
-		if (R_IsLumpPNG((UINT8 *)lumpdata, len))
+	return W_GetPatchPointerPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum),tag);
-		{
+}
-			size_t newlen;
-			srcdata = R_PNGToPatch((UINT8 *)lumpdata, len, &newlen);
-			ptr = Z_Realloc(ptr, newlen, tag, &lumpcache[lump]);
-			M_Memcpy(ptr, srcdata, newlen);
-			Z_Free(srcdata);
-		}
-		else // just copy it into the patch cache
-#endif
-			M_Memcpy(ptr, lumpdata, len);
-	}
-	else
-		Z_ChangeTag(lumpcache[lump], tag);
-	return lumpcache[lump];
+void **W_GetPatchPointerFromName(const char *name, INT32 tag)
+{
+	lumpnum_t num = W_CheckNumForName(name);
+	if (num == LUMPERROR)
+		return W_GetPatchPointer(W_GetNumForName("MISSING"), tag);
+	return W_GetPatchPointer(num, tag);
 }
-void *W_CacheSoftwarePatchNum(lumpnum_t lumpnum, INT32 tag)
+void **W_GetPatchPointerFromLongName(const char *name, INT32 tag)
 {
-	return W_CacheSoftwarePatchNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum),tag);
+	lumpnum_t num = W_CheckNumForLongName(name);
+	if (num == LUMPERROR)
+		return W_GetPatchPointer(W_CheckNumForLongName("MISSING"), tag);
+	return W_GetPatchPointer(num, tag);
 }
-void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
+#ifdef ROTSPRITE
+void **W_GetRotatedPatchPointerPwad(UINT16 wad, UINT16 lump, INT32 tag, INT32 rollangle, boolean sprite, void *pivot, boolean flip)
 {
-#ifdef HWRENDER
+	static rotsprite_vars_t rsvars;
-	GLPatch_t *grPatch;
+	patchinfo_t *patchinfo = NULL;
-#endif
 	if (!TestValidLump(wad, lump))
 		return NULL;
-#ifdef HWRENDER
+	patchinfo = &wadfiles[wad]->patchinfo;
-	// Software-only compile cache the data without conversion
+	if (!patchinfo->rotated[lump])
-	if (rendermode == render_soft || rendermode == render_none)
+		RotSprite_AllocCurrentPatchInfo(patchinfo, lump);
-#endif
-	{
-		return W_CacheSoftwarePatchNumPwad(wad, lump, tag);
-	}
-#ifdef HWRENDER
-	grPatch = HWR_GetCachedGLPatchPwad(wad, lump);
+	rsvars.rollangle = rollangle;
+	rsvars.sprite = sprite;
+	rsvars.pivot = pivot;
+	rsvars.flip = flip;
-	if (grPatch->mipmap->data)
+	if (sprite)
-	{
+		Patch_CacheRotatedForSpritePwad(wad, lump, tag, rsvars, true);
-		if (tag == PU_CACHE)
-			tag = PU_HWRCACHE;
-		Z_ChangeTag(grPatch->mipmap->data, tag);
-	}
 	else
-	{
+		Patch_CacheRotatedPwad(wad, lump, tag, rsvars, true);
-		patch_t *ptr = NULL;
-		// Only load the patch if we haven't initialised the grPatch yet
+	return (void **)(&(patchinfo->rotated[lump][RotSprite_GetCurrentPatchInfoIdx(rollangle, flip)]));
-		if (grPatch->mipmap->width == 0)
+}
-			ptr = W_CacheLumpNumPwad(grPatch->wadnum, grPatch->lumpnum, PU_STATIC);
-		// Run HWR_MakePatch in all cases, to recalculate some things
+void **W_GetRotatedPatchPointer(lumpnum_t lumpnum, INT32 tag, INT32 rollangle, boolean sprite, void *pivot, boolean flip)
-		HWR_MakePatch(ptr, grPatch, grPatch->mipmap, false);
+{
-		Z_Free(ptr);
+	return W_GetRotatedPatchPointerPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum),tag,rollangle,sprite,pivot,flip);
-	}
+}
-	// return GLPatch_t, which can be casted to (patch_t) with valid patch header info
+void **W_GetRotatedPatchPointerFromName(const char *name, INT32 tag, INT32 rollangle, boolean sprite, void *pivot, boolean flip)
-	return (void *)grPatch;
+{
-#endif
+	lumpnum_t num = W_CheckNumForName(name);
+	if (num == LUMPERROR)
+		return W_GetRotatedPatchPointer(W_GetNumForName("MISSING"), tag, rollangle, sprite, pivot, flip);
+	return W_GetRotatedPatchPointer(num, tag, rollangle, sprite, pivot, flip);
 }
-void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag)
+void **W_GetRotatedPatchPointerFromLongName(const char *name, INT32 tag, INT32 rollangle, boolean sprite, void *pivot, boolean flip)
 {
-	return W_CachePatchNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum),tag);
+	lumpnum_t num = W_CheckNumForLongName(name);
+	if (num == LUMPERROR)
+		return W_GetRotatedPatchPointer(W_CheckNumForLongName("MISSING"), tag, rollangle, sprite, pivot, flip);
+	return W_GetRotatedPatchPointer(num, tag, rollangle, sprite, pivot, flip);
 }
+#endif
 void W_UnlockCachedPatch(void *patch)
 {
@@ -1768,32 +1757,9 @@ void W_UnlockCachedPatch(void *patch)
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
 		HWR_UnlockCachedPatch((GLPatch_t*)patch);
-	else
 #endif
-		Z_Unlock(patch);
 }
-void *W_CachePatchName(const char *name, INT32 tag)
-{
-	lumpnum_t num;
-	num = W_CheckNumForName(name);
-	if (num == LUMPERROR)
-		return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
-	return W_CachePatchNum(num, tag);
-}
-void *W_CachePatchLongName(const char *name, INT32 tag)
-{
-	lumpnum_t num;
-	num = W_CheckNumForLongName(name);
-	if (num == LUMPERROR)
-		return W_CachePatchNum(W_GetNumForLongName("MISSING"), tag);
-	return W_CachePatchNum(num, tag);
-}
 #ifndef NOMD5
 #define MD5_LEN 16

--- a/src/w_wad.h
+++ b/src/w_wad.h
@@ -22,6 +22,8 @@
 #pragma interface
 #endif
+#define lumpcache_t void *
 // a raw entry of the wad directory
 // NOTE: This sits here and not in w_wad.c because p_setup.c makes use of it to load map WADs inside PK3s.
 #if defined(_MSC_VER)
@@ -37,7 +39,6 @@ typedef struct
 #pragma pack()
 #endif
 // ==============================================================
 //               WAD FILE STRUCTURE DEFINITIONS
 // ==============================================================
@@ -92,6 +93,22 @@ virtres_t* vres_GetMap(lumpnum_t);
 void vres_Free(virtres_t*);
 virtlump_t* vres_Find(const virtres_t*, const char*);
+// =========================================================================
+//                                PATCH INFO
+// =========================================================================
+#include "r_patchtrees.h"
+typedef struct patchinfo_s
+{
+	patchtree_t renderer[num_patchtrees];
+	lumpcache_t *current;
+#ifdef ROTSPRITE
+	lumpcache_t **rotated;
+#endif
+} patchinfo_t;
 // =========================================================================
 //                         DYNAMIC WAD LOADING
 // =========================================================================
@@ -100,12 +117,6 @@ virtlump_t* vres_Find(const virtres_t*, const char*);
 #define MAX_WADFILES 48 // maximum of wad files used at the same time
 // (there is a max of simultaneous open files anyway, and this should be plenty)
-#define lumpcache_t void *
-#ifdef HWRENDER
-#include "m_aatree.h"
-#endif
 // Resource type of the WAD. Yeah, I know this sounds dumb, but I'll leave it like this until I clean up the code further.
 typedef enum restype
 {
@@ -122,10 +133,7 @@ typedef struct wadfile_s
 	restype_t type;
 	lumpinfo_t *lumpinfo;
 	lumpcache_t *lumpcache;
-	lumpcache_t *patchcache;
+	patchinfo_t patchinfo;
-#ifdef HWRENDER
-	aatree_t *hwrcache; // patches are cached in renderer's native format
-#endif
 	UINT16 numlumps; // this wad's number of resources
 	FILE *handle;
 	UINT32 filesize; // for network
@@ -134,8 +142,9 @@ typedef struct wadfile_s
 	boolean important; // also network - !W_VerifyNMUSlumps
 } wadfile_t;
-#define WADFILENUM(lumpnum) (UINT16)((lumpnum)>>16) // wad flumpnum>>16) // wad file number in upper word
+#define WADFILENUM(lumpnum) (UINT16)((lumpnum)>>16) // wad file number in upper word
 #define LUMPNUM(lumpnum) (UINT16)((lumpnum)&0xFFFF) // lump number for this pwad
+#define WADANDLUMP(wad, lump) (UINT32)(((wad)<<16)|((lump)&0xFFFF)) // wad and lump number
 extern UINT16 numwadfiles;
 extern wadfile_t *wadfiles[MAX_WADFILES];
@@ -193,7 +202,6 @@ void *W_CacheLumpNum(lumpnum_t lump, INT32 tag);
 void *W_CacheLumpNumForce(lumpnum_t lumpnum, INT32 tag);
 boolean W_IsLumpCached(lumpnum_t lump, void *ptr);
-boolean W_IsPatchCached(lumpnum_t lump, void *ptr);
 void *W_CacheLumpName(const char *name, INT32 tag);
 void *W_CachePatchName(const char *name, INT32 tag);
@@ -209,6 +217,20 @@ void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag);
 void *W_CacheSoftwarePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag);
 void *W_CacheSoftwarePatchNum(lumpnum_t lumpnum, INT32 tag);
+// Returns patch pointers.
+void **W_GetPatchPointerPwad(UINT16 wad, UINT16 lump, INT32 tag);
+void **W_GetPatchPointer(lumpnum_t lumpnum, INT32 tag);
+void **W_GetPatchPointerFromName(const char *name, INT32 tag);
+void **W_GetPatchPointerFromLongName(const char *name, INT32 tag);
+#ifdef ROTSPRITE
+// Returns rotated patch pointers.
+void **W_GetRotatedPatchPointerPwad(UINT16 wad, UINT16 lump, INT32 tag, INT32 rollangle, boolean sprite, void *pivot, boolean flip);
+void **W_GetRotatedPatchPointer(lumpnum_t lumpnum, INT32 tag, INT32 rollangle, boolean sprite, void *pivot, boolean flip);
+void **W_GetRotatedPatchPointerFromName(const char *name, INT32 tag, INT32 rollangle, boolean sprite, void *pivot, boolean flip);
+void **W_GetRotatedPatchPointerFromLongName(const char *name, INT32 tag, INT32 rollangle, boolean sprite, void *pivot, boolean flip);
+#endif
 void W_UnlockCachedPatch(void *patch);
 void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5);

--- a/src/win32/Srb2win-vc10.vcxproj
+++ b/src/win32/Srb2win-vc10.vcxproj
@@ -300,6 +300,7 @@
    <ClCompile Include="..\r_main.c" />
    <ClCompile Include="..\r_plane.c" />
    <ClCompile Include="..\r_patch.c" />
+    <ClCompile Include="..\r_rotsprite.c" />
    <ClCompile Include="..\r_portal.c" />
    <ClCompile Include="..\r_segs.c" />
    <ClCompile Include="..\r_sky.c" />
@@ -454,7 +455,9 @@
    <ClInclude Include="..\r_local.h" />
    <ClInclude Include="..\r_main.h" />
    <ClInclude Include="..\r_plane.h" />
-	<ClInclude Include="..\r_patch.h" />
+    <ClInclude Include="..\r_patch.h" />
+    <ClInclude Include="..\r_rotsprite.h" />
+    <ClInclude Include="..\r_patchtrees.h" />
    <ClInclude Include="..\r_portal.h" />
    <ClInclude Include="..\r_segs.h" />
    <ClInclude Include="..\r_sky.h" />

--- a/src/win32/Srb2win-vc10.vcxproj.filters
+++ b/src/win32/Srb2win-vc10.vcxproj.filters
@@ -472,6 +472,9 @@
    <ClCompile Include="..\r_patch.c">
      <Filter>R_Rend</Filter>
    </ClCompile>
+    <ClCompile Include="..\r_rotsprite.c">
+      <Filter>R_Rend</Filter>
+    </ClCompile>
    <ClCompile Include="..\r_portal.c">
      <Filter>R_Rend</Filter>
    </ClCompile>
@@ -889,6 +892,12 @@
    <ClInclude Include="..\r_patch.h">
      <Filter>R_Rend</Filter>
    </ClInclude>
+    <ClInclude Include="..\r_rotsprite.h">
+      <Filter>R_Rend</Filter>
+    </ClInclude>
+    <ClInclude Include="..\r_patchtrees.h">
+      <Filter>R_Rend</Filter>
+    </ClInclude>
    <ClInclude Include="..\r_portal.h">
      <Filter>R_Rend</Filter>
    </ClInclude>

--- a/src/win32/win_vid.c
+++ b/src/win32/win_vid.c
@@ -48,6 +48,7 @@
 // this is the CURRENT rendermode!! very important: used by w_wad, and much other code
 rendermode_t rendermode = render_soft;
+rendermode_t chosenrendermode = render_none; // set by command line arguments
 static void OnTop_OnChange(void);
 // synchronize page flipping with screen refresh
 static CV_PossibleValue_t CV_NeverOnOff[] = {{-1, "Never"}, {0, "Off"}, {1, "On"}, {0, NULL}};
@@ -56,7 +57,6 @@ static consvar_t cv_stretch = {"stretch", "On", CV_SAVE|CV_NOSHOWHELP, CV_OnOff,
 static consvar_t cv_ontop = {"ontop", "Never", 0, CV_NeverOnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 boolean highcolor;
-int vid_opengl_state = 0;
 static BOOL bDIBMode; // means we are using DIB instead of DirectDraw surfaces
 static LPBITMAPINFO bmiMain = NULL;
@@ -778,7 +778,7 @@ static INT32 WINAPI VID_SetWindowedDisplayMode(viddef_t *lvid, vmode_t *currentm
 	I_OutputMsg("VID_SetWindowedDisplayMode()\n");
-	lvid->u.numpages = 1; // not used
+	lvid->numpages = 1; // not used
 	lvid->direct = NULL; // DOS remains
 	lvid->buffer = NULL;
@@ -903,9 +903,9 @@ INT32 VID_SetMode(INT32 modenum)
 			if (cv_scr_depth.value < 16)
 				CV_SetValue(&cv_scr_depth,  16);
 			vid.bpp = cv_scr_depth.value/8;
-			vid.u.windowed = (bWinParm || !cv_fullscreen.value);
+			vid.windowed = (bWinParm || !cv_fullscreen.value);
 			pcurrentmode->bytesperpixel = vid.bpp;
-			pcurrentmode->windowed = vid.u.windowed;
+			pcurrentmode->windowed = vid.windowed;
 		}
 	}
@@ -952,7 +952,11 @@ INT32 VID_SetMode(INT32 modenum)
 	return 1;
 }
-void VID_CheckRenderer(void) {}
+boolean VID_CheckRenderer(void)
+{
+	return false;
+}
 void VID_CheckGLLoaded(rendermode_t oldrender)
 {
 	(void)oldrender;
@@ -995,7 +999,7 @@ static INT32 WINAPI VID_SetDirectDrawMode(viddef_t *lvid, vmode_t *currentmode)
 	// DD modes do double-buffer page flipping, but the game engine doesn't need this..
-	lvid->u.numpages = 2;
+	lvid->numpages = 2;
 	// release ddraw surfaces etc..
 	ReleaseChtuff();

--- a/src/y_inter.c
+++ b/src/y_inter.c
@@ -66,7 +66,7 @@ typedef union
 		INT32 passedx2;
 		y_bonus_t bonuses[4];
-		patch_t *bonuspatches[4];
+		patch_t **bonuspatches[4];
 		SINT8 gotperfbonus; // Used for visitation flags.
@@ -74,7 +74,7 @@ typedef union
 		UINT32 tics; // time
 		UINT8 actnum; // act number being displayed
-		patch_t *ptotal; // TOTAL
+		patch_t **ptotal; // TOTAL
 		UINT8 gotlife; // Number of extra lives obtained
 	} coop;
@@ -90,14 +90,14 @@ typedef union
 		INT32 passedx4;
 		y_bonus_t bonuses[2];
-		patch_t *bonuspatches[2];
+		patch_t **bonuspatches[2];
-		patch_t *pscore; // SCORE
+		patch_t **pscore; // SCORE
 		UINT32 score; // fake score
 		// Continues
 		UINT8 continues;
-		patch_t *pcontinues;
+		patch_t **pcontinues;
 		INT32 *playerchar; // Continue HUD
 		UINT16 *playercolor;
@@ -112,9 +112,9 @@ typedef union
 		INT32 *character[MAXPLAYERS]; // Winner's character #
 		INT32 num[MAXPLAYERS]; // Winner's player #
 		char *name[MAXPLAYERS]; // Winner's name
-		patch_t *result; // RESULT
+		patch_t **result; // RESULT
-		patch_t *blueflag;
+		patch_t **blueflag;
-		patch_t *redflag; // int_ctf uses this struct too.
+		patch_t **redflag; // int_ctf uses this struct too.
 		INT32 numplayers; // Number of players being displayed
 		char levelstring[40]; // holds levelnames up to 32 characters
 	} match;
@@ -140,10 +140,10 @@ typedef union
 static y_data data;
 // graphics
-static patch_t *bgpatch = NULL;     // INTERSCR
+static patch_t **bgpatch = NULL;     // INTERSCR
-static patch_t *widebgpatch = NULL; // INTERSCW
+static patch_t **widebgpatch = NULL; // INTERSCW
-static patch_t *bgtile = NULL;      // SPECTILE/SRB2BACK
+static patch_t **bgtile = NULL;      // SPECTILE/SRB2BACK
-static patch_t *interpic = NULL;    // custom picture defined in map header
+static patch_t **interpic = NULL;    // custom picture defined in map header
 static boolean usetile;
 static INT32 timer;
@@ -176,7 +176,6 @@ static void Y_CalculateCompetitionWinners(void);
 static void Y_CalculateTimeRaceWinners(void);
 static void Y_CalculateMatchWinners(void);
 static void Y_UnloadData(void);
-static void Y_CleanupData(void);
 // Stuff copy+pasted from st_stuff.c
 #define ST_DrawNumFromHud(h,n)        V_DrawTallNum(hudinfo[h].x, hudinfo[h].y, hudinfo[h].f, n)
@@ -323,13 +322,6 @@ void Y_IntermissionDrawer(void)
 	if (intertype == int_none || rendermode == render_none)
 		return;
-	// Lactozilla: Renderer switching
-	if (needpatchrecache)
-	{
-		Y_CleanupData();
-		safetorender = false;
-	}
 	if (!usebuffer || !safetorender)
 		V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
@@ -337,7 +329,7 @@ void Y_IntermissionDrawer(void)
 		goto dontdrawbg;
 	if (useinterpic)
-		V_DrawScaledPatch(0, 0, 0, interpic);
+		V_DrawScaledPatch(0, 0, 0, *interpic);
 	else if (!usetile)
 	{
 		if (rendermode == render_soft && usebuffer)
@@ -362,13 +354,13 @@ void Y_IntermissionDrawer(void)
 		else
 		{
 			if (widebgpatch && rendermode == render_soft && vid.width / vid.dupx == 400)
-				V_DrawScaledPatch(0, 0, V_SNAPTOLEFT, widebgpatch);
+				V_DrawScaledPatch(0, 0, V_SNAPTOLEFT, *widebgpatch);
 			else if (bgpatch)
-				V_DrawScaledPatch(0, 0, 0, bgpatch);
+				V_DrawScaledPatch(0, 0, 0, *bgpatch);
 		}
 	}
 	else if (bgtile)
-		V_DrawPatchFill(bgtile);
+		V_DrawPatchFill(*bgtile);
 	LUAh_IntermissionHUD();
 	if (!LUA_HudEnabled(hud_intermissiontally))
@@ -426,7 +418,7 @@ dontdrawbg:
 		// Total
 		if (safetorender)
 		{
-			V_DrawScaledPatch(152, bonusy, 0, data.coop.ptotal);
+			V_DrawScaledPatch(152, bonusy, 0, *data.coop.ptotal);
 			V_DrawTallNum(BASEVIDWIDTH - 68, bonusy + 1, 0, data.coop.total);
 		}
 		bonusy -= (3*SHORT(tallnum[0]->height)/2) + 1;
@@ -436,7 +428,7 @@ dontdrawbg:
 		{
 			if (data.coop.bonuses[i].display && safetorender)
 			{
-				V_DrawScaledPatch(152, bonusy, 0, data.coop.bonuspatches[i]);
+				V_DrawScaledPatch(152, bonusy, 0, *data.coop.bonuspatches[i]);
 				V_DrawTallNum(BASEVIDWIDTH - 68, bonusy + 1, 0, data.coop.bonuses[i].points);
 			}
 			bonusy -= (3*SHORT(tallnum[0]->height)/2) + 1;
@@ -539,18 +531,18 @@ dontdrawbg:
 				V_DrawLevelTitle(data.spec.passedx2 + xoffset1, ttheight, 0, data.spec.passed2);
 			}
-			V_DrawScaledPatch(152 + xoffset3, 108, 0, data.spec.bonuspatches[0]);
+			V_DrawScaledPatch(152 + xoffset3, 108, 0, *data.spec.bonuspatches[0]);
 			V_DrawTallNum(BASEVIDWIDTH + xoffset3 - 68, 109, 0, data.spec.bonuses[0].points);
 			if (data.spec.bonuses[1].display)
 			{
-				V_DrawScaledPatch(152 + xoffset4, 124, 0, data.spec.bonuspatches[1]);
+				V_DrawScaledPatch(152 + xoffset4, 124, 0, *data.spec.bonuspatches[1]);
 				V_DrawTallNum(BASEVIDWIDTH + xoffset4 - 68, 125, 0, data.spec.bonuses[1].points);
 				yoffset = 16;
 				// hack; pass the buck along...
 				xoffset4 = xoffset5;
 				xoffset5 = xoffset6;
 			}
-			V_DrawScaledPatch(152 + xoffset4, 124+yoffset, 0, data.spec.pscore);
+			V_DrawScaledPatch(152 + xoffset4, 124+yoffset, 0, *data.spec.pscore);
 			V_DrawTallNum(BASEVIDWIDTH + xoffset4 - 68, 125+yoffset, 0, data.spec.score);
 			// Draw continues!
@@ -558,7 +550,7 @@ dontdrawbg:
 			{
 				UINT8 continues = data.spec.continues & 0x7F;
-				V_DrawScaledPatch(152 + xoffset5, 150+yoffset, 0, data.spec.pcontinues);
+				V_DrawScaledPatch(152 + xoffset5, 150+yoffset, 0, *data.spec.pcontinues);
 				if (continues > 5)
 				{
 					INT32 leftx = (continues >= 10) ? 216 : 224;
@@ -664,7 +656,7 @@ dontdrawbg:
 		// draw the header
 		if (safetorender)
-			V_DrawScaledPatch(112, 2, 0, data.match.result);
+			V_DrawScaledPatch(112, 2, 0, *data.match.result);
 		// draw the level name
 		V_DrawCenteredString(BASEVIDWIDTH/2, 20, 0, data.match.levelstring);
@@ -777,10 +769,10 @@ dontdrawbg:
 		char name[MAXPLAYERNAME+1];
 		// Show the team flags and the team score at the top instead of "RESULTS"
-		V_DrawSmallScaledPatch(128 - SHORT(data.match.blueflag->width)/4, 2, 0, data.match.blueflag);
+		V_DrawSmallScaledPatch(128 - SHORT((*data.match.blueflag)->width)/4, 2, 0, *data.match.blueflag);
 		V_DrawCenteredString(128, 16, 0, va("%u", bluescore));
-		V_DrawSmallScaledPatch(192 - SHORT(data.match.redflag->width)/4, 2, 0, data.match.redflag);
+		V_DrawSmallScaledPatch(192 - SHORT((*data.match.redflag)->width)/4, 2, 0, *data.match.redflag);
 		V_DrawCenteredString(192, 16, 0, va("%u", redscore));
 		// draw the level name
@@ -1259,20 +1251,20 @@ void Y_StartIntermission(void)
 			data.coop.tics = players[consoleplayer].realtime;
 			for (i = 0; i < 4; ++i)
-				data.coop.bonuspatches[i] = W_CachePatchName(data.coop.bonuses[i].patch, PU_PATCH);
+				data.coop.bonuspatches[i] = (patch_t **)W_GetPatchPointerFromName(data.coop.bonuses[i].patch, PU_PATCH);
-			data.coop.ptotal = W_CachePatchName("YB_TOTAL", PU_PATCH);
+			data.coop.ptotal = (patch_t **)W_GetPatchPointerFromName("YB_TOTAL", PU_PATCH);
 			// get act number
 			data.coop.actnum = mapheaderinfo[gamemap-1]->actnum;
 			// get background patches
-			widebgpatch = W_CachePatchName("INTERSCW", PU_PATCH);
+			widebgpatch = (patch_t **)W_GetPatchPointerFromName("INTERSCW", PU_PATCH);
-			bgpatch = W_CachePatchName("INTERSCR", PU_PATCH);
+			bgpatch = (patch_t **)W_GetPatchPointerFromName("INTERSCR", PU_PATCH);
 			// grab an interscreen if appropriate
 			if (mapheaderinfo[gamemap-1]->interscreen[0] != '#')
 			{
-				interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_PATCH);
+				interpic = (patch_t **)W_GetPatchPointerFromName(mapheaderinfo[gamemap-1]->interscreen, PU_PATCH);
 				useinterpic = true;
 				usebuffer = false;
 			}
@@ -1330,18 +1322,18 @@ void Y_StartIntermission(void)
 			Y_AwardSpecialStageBonus();
 			for (i = 0; i < 2; ++i)
-				data.spec.bonuspatches[i] = W_CachePatchName(data.spec.bonuses[i].patch, PU_PATCH);
+				data.spec.bonuspatches[i] = (patch_t **)W_GetPatchPointerFromName(data.spec.bonuses[i].patch, PU_PATCH);
-			data.spec.pscore = W_CachePatchName("YB_SCORE", PU_PATCH);
+			data.spec.pscore = (patch_t **)W_GetPatchPointerFromName("YB_SCORE", PU_PATCH);
-			data.spec.pcontinues = W_CachePatchName("YB_CONTI", PU_PATCH);
+			data.spec.pcontinues = (patch_t **)W_GetPatchPointerFromName("YB_CONTI", PU_PATCH);
 			// get background tile
-			bgtile = W_CachePatchName("SPECTILE", PU_PATCH);
+			bgtile = (patch_t **)W_GetPatchPointerFromName("SPECTILE", PU_PATCH);
 			// grab an interscreen if appropriate
 			if (mapheaderinfo[gamemap-1]->interscreen[0] != '#')
 			{
-				interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_PATCH);
+				interpic = (patch_t **)W_GetPatchPointerFromName(mapheaderinfo[gamemap-1]->interscreen, PU_PATCH);
 				useinterpic = true;
 			}
 			else
@@ -1353,14 +1345,14 @@ void Y_StartIntermission(void)
 			// get special stage specific patches
 /*			if (!stagefailed && ALL7EMERALDS(emeralds))
 			{
-				data.spec.cemerald = W_CachePatchName("GOTEMALL", PU_PATCH);
+				data.spec.cemerald = (patch_t **)W_GetPatchPointerFromName("GOTEMALL", PU_PATCH);
 				data.spec.headx = 70;
 				data.spec.nowsuper = players[consoleplayer].skin
-					? NULL : W_CachePatchName("NOWSUPER", PU_PATCH);
+					? NULL : W_GetPatchPointerFromName("NOWSUPER", PU_PATCH);
 			}
 			else
 			{
-				data.spec.cemerald = W_CachePatchName("CEMERALD", PU_PATCH);
+				data.spec.cemerald = (patch_t **)W_GetPatchPointerFromName("CEMERALD", PU_PATCH);
 				data.spec.headx = 48;
 				data.spec.nowsuper = NULL;
 			} */
@@ -1437,10 +1429,9 @@ void Y_StartIntermission(void)
 			data.match.levelstring[sizeof data.match.levelstring - 1] = '\0';
 			// get RESULT header
-			data.match.result =
+			data.match.result = (patch_t **)W_GetPatchPointerFromName("RESULT", PU_PATCH);
-				W_CachePatchName("RESULT", PU_PATCH);
-			bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
+			bgtile = (patch_t **)W_GetPatchPointerFromName("SRB2BACK", PU_PATCH);
 			usetile = true;
 			useinterpic = false;
 			break;
@@ -1466,9 +1457,9 @@ void Y_StartIntermission(void)
 			data.match.levelstring[sizeof data.match.levelstring - 1] = '\0';
 			// get RESULT header
-			data.match.result = W_CachePatchName("RESULT", PU_PATCH);
+			data.match.result = (patch_t **)W_GetPatchPointerFromName("RESULT", PU_PATCH);
-			bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
+			bgtile = (patch_t **)W_GetPatchPointerFromName("SRB2BACK", PU_PATCH);
 			usetile = true;
 			useinterpic = false;
 			break;
@@ -1505,7 +1496,7 @@ void Y_StartIntermission(void)
 				data.match.blueflag = bmatcico;
 			}
-			bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
+			bgtile = (patch_t **)W_GetPatchPointerFromName("SRB2BACK", PU_PATCH);
 			usetile = true;
 			useinterpic = false;
 			break;
@@ -1531,7 +1522,7 @@ void Y_StartIntermission(void)
 			data.competition.levelstring[sizeof data.competition.levelstring - 1] = '\0';
 			// get background tile
-			bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
+			bgtile = (patch_t **)W_GetPatchPointerFromName("SRB2BACK", PU_PATCH);
 			usetile = true;
 			useinterpic = false;
 			break;
@@ -2069,15 +2060,14 @@ void Y_EndIntermission(void)
 	usebuffer = false;
 }
-#define UNLOAD(x) if (x) {Z_ChangeTag(x, PU_CACHE);} x = NULL;
+#define UNLOAD(x) if (x) {Z_ChangeTag(*x, PU_CACHE);} x = NULL;
-#define CLEANUP(x) x = NULL;
 //
 // Y_UnloadData
 //
 static void Y_UnloadData(void)
 {
-	// In hardware mode, don't Z_ChangeTag a pointer returned by W_CachePatchName().
+	// In hardware mode, don't Z_ChangeTag a pointer returned by W_GetPatchPointerFromName().
 	// It doesn't work and is unnecessary.
 	if (rendermode != render_soft)
 		return;
@@ -2122,46 +2112,3 @@ static void Y_UnloadData(void)
 			break;
 	}
 }
-static void Y_CleanupData(void)
-{
-	// unload the background patches
-	CLEANUP(bgpatch);
-	CLEANUP(widebgpatch);
-	CLEANUP(bgtile);
-	CLEANUP(interpic);
-	switch (intertype)
-	{
-		case int_coop:
-			// unload the coop and single player patches
-			CLEANUP(data.coop.bonuspatches[3]);
-			CLEANUP(data.coop.bonuspatches[2]);
-			CLEANUP(data.coop.bonuspatches[1]);
-			CLEANUP(data.coop.bonuspatches[0]);
-			CLEANUP(data.coop.ptotal);
-			break;
-		case int_spec:
-			// unload the special stage patches
-			//CLEANUP(data.spec.cemerald);
-			//CLEANUP(data.spec.nowsuper);
-			CLEANUP(data.spec.bonuspatches[1]);
-			CLEANUP(data.spec.bonuspatches[0]);
-			CLEANUP(data.spec.pscore);
-			CLEANUP(data.spec.pcontinues);
-			break;
-		case int_match:
-		case int_race:
-			CLEANUP(data.match.result);
-			break;
-		case int_ctf:
-			CLEANUP(data.match.blueflag);
-			CLEANUP(data.match.redflag);
-			break;
-		default:
-			//without this default,
-			//int_none, int_tag, int_chaos, and int_classicrace
-			//are not handled
-			break;
-	}
-}
--- a/src/z_zone.c
+++ b/src/z_zone.c
@@ -27,7 +27,6 @@
 #include "doomdef.h"
 #include "doomstat.h"
-#include "r_patch.h"
 #include "i_system.h" // I_GetFreeMem
 #include "i_video.h" // rendermode
 #include "z_zone.h"
@@ -499,33 +498,6 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
 // Utility functions
 // -----------------
-// for renderer switching
-boolean needpatchflush = false;
-boolean needpatchrecache = false;
-// flush all patches from memory
-void Z_FlushCachedPatches(void)
-{
-	CONS_Debug(DBG_RENDER, "Z_FlushCachedPatches()...\n");
-	Z_FreeTag(PU_PATCH);
-	Z_FreeTag(PU_HUDGFX);
-	Z_FreeTag(PU_HWRPATCHINFO);
-	Z_FreeTag(PU_HWRMODELTEXTURE);
-	Z_FreeTag(PU_HWRCACHE);
-	Z_FreeTag(PU_HWRCACHE_UNLOCKED);
-	Z_FreeTag(PU_HWRPATCHINFO_UNLOCKED);
-	Z_FreeTag(PU_HWRMODELTEXTURE_UNLOCKED);
-}
-// happens before a renderer switch
-void Z_PreparePatchFlush(void)
-{
-	CONS_Debug(DBG_RENDER, "Z_PreparePatchFlush()...\n");
-#ifdef ROTSPRITE
-	R_FreeAllRotSprite();
-#endif
-}
 // starting value of nextcleanup
 #define CLEANUPCOUNT 2000

--- a/src/z_zone.h
+++ b/src/z_zone.h
@@ -142,12 +142,5 @@ size_t Z_TagsUsage(INT32 lowtag, INT32 hightag);
 // Miscellaneous functions
 //
 char *Z_StrDup(const char *in);
-#define Z_Unlock(p) (void)p // TODO: remove this now that NDS code has been removed
-// For renderer switching
-extern boolean needpatchflush;
-extern boolean needpatchrecache;
-void Z_FlushCachedPatches(void);
-void Z_PreparePatchFlush(void);
 #endif
No results found