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/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;