diff --git a/src/d_main.cpp b/src/d_main.cpp
index 69298aa4d..b101c555e 100644
--- a/src/d_main.cpp
+++ b/src/d_main.cpp
@@ -833,7 +833,7 @@ void D_Display ()
 			}
 			if (!automapactive || viewactive)
 			{
-				V_RefreshViewBorder ();
+				screen->RefreshViewBorder ();
 			}
 
 			// for timing the statusbar code.
diff --git a/src/f_wipe.cpp b/src/f_wipe.cpp
index 02a9268e7..f47106839 100644
--- a/src/f_wipe.cpp
+++ b/src/f_wipe.cpp
@@ -32,148 +32,6 @@
 #include "templates.h"
 #include "v_palette.h"
 
-EXTERN_CVAR(Bool, r_blendmethod)
-
-//
-//		SCREEN WIPE PACKAGE
-//
-
-static int CurrentWipeType;
-
-static short *wipe_scr_start;
-static short *wipe_scr_end;
-static int *y;
-
-// [RH] Fire Wipe
-#define FIREWIDTH	64
-#define FIREHEIGHT	64
-static uint8_t *burnarray;
-static int density;
-static int burntime;
-
-// [RH] Crossfade
-static int fade;
-
-
-// Melt -------------------------------------------------------------
-
-// Match the strip sizes that oldschool Doom used on a 320x200 screen.
-#define MELT_WIDTH		160
-#define MELT_HEIGHT		200
-
-void wipe_shittyColMajorXform (short *array)
-{
-	int x, y;
-	short *dest;
-	int width = SCREENWIDTH / 2;
-
-	dest = new short[width*SCREENHEIGHT*2];
-
-	for(y = 0; y < SCREENHEIGHT; y++)
-		for(x = 0; x < width; x++)
-			dest[x*SCREENHEIGHT+y] = array[y*width+x];
-
-	memcpy(array, dest, SCREENWIDTH*SCREENHEIGHT);
-
-	delete[] dest;
-}
-
-bool wipe_initMelt (int ticks)
-{
-	int i, r;
-	
-	// copy start screen to main screen
-	screen->DrawBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_start);
-	
-	// makes this wipe faster (in theory)
-	// to have stuff in column-major format
-	wipe_shittyColMajorXform (wipe_scr_start);
-	wipe_shittyColMajorXform (wipe_scr_end);
-	
-	// setup initial column positions
-	// (y<0 => not ready to scroll yet)
-	y = new int[MELT_WIDTH];
-	y[0] = -(M_Random() & 15);
-	for (i = 1; i < MELT_WIDTH; i++)
-	{
-		r = (M_Random()%3) - 1;
-		y[i] = clamp(y[i-1] + r, -15, 0);
-	}
-
-	return 0;
-}
-
-bool wipe_doMelt (int ticks)
-{
-	int i, j, dy, x;
-	const short *s;
-	short *d;
-	bool done = true;
-
-	while (ticks--)
-	{
-		done = true;
-		for (i = 0; i < MELT_WIDTH; i++)
-		{
-			if (y[i] < 0)
-			{
-				y[i]++;
-				done = false;
-			} 
-			else if (y[i] < MELT_HEIGHT)
-			{
-				dy = (y[i] < 16) ? y[i]+1 : 8;
-				y[i] = MIN(y[i] + dy, MELT_HEIGHT);
-				done = false;
-			}
-			if (ticks == 0 && y[i] >= 0)
-			{ // Only draw for the final tick.
-				const int pitch = screen->GetPitch() / 2;
-				int sy = y[i] * SCREENHEIGHT / MELT_HEIGHT;
-
-				for (x = i * (SCREENWIDTH/2) / MELT_WIDTH; x < (i + 1) * (SCREENWIDTH/2) / MELT_WIDTH; ++x)
-				{
-					s = &wipe_scr_end[x*SCREENHEIGHT];
-					d = &((short *)screen->GetBuffer())[x];
-
-					for (j = sy; j != 0; --j)
-					{
-						*d = *(s++);
-						d += pitch;
-					}
-
-					s = &wipe_scr_start[x*SCREENHEIGHT];
-
-					for (j = SCREENHEIGHT - sy; j != 0; --j)
-					{
-						*d = *(s++);
-						d += pitch;
-					}
-				}
-			}
-		}
-	}
-
-	return done;
-}
-
-bool wipe_exitMelt (int ticks)
-{
-	delete[] y;
-	return 0;
-}
-
-// Burn -------------------------------------------------------------
-
-bool wipe_initBurn (int ticks)
-{
-	burnarray = new uint8_t[FIREWIDTH * (FIREHEIGHT+5)];
-	memset (burnarray, 0, FIREWIDTH * (FIREHEIGHT+5));
-	density = 4;
-	burntime = 0;
-	return 0;
-}
-
 int wipe_CalcBurn (uint8_t *burnarray, int width, int height, int density)
 {
 	// This is a modified version of the fire that was once used
@@ -258,263 +116,3 @@ int wipe_CalcBurn (uint8_t *burnarray, int width, int height, int density)
 	return -1;
 }
 
-bool wipe_doBurn (int ticks)
-{
-	bool done;
-
-	burntime += ticks;
-	ticks *= 2;
-
-	// Make the fire burn
-	done = false;
-	while (!done && ticks--)
-	{
-		density = wipe_CalcBurn(burnarray, FIREWIDTH, FIREHEIGHT, density);
-		done = (density < 0);
-	}
-
-	// Draw the screen
-	int xstep, ystep, firex, firey;
-	int x, y;
-	uint8_t *to, *fromold, *fromnew;
-	const int SHIFT = 16;
-
-	xstep = (FIREWIDTH << SHIFT) / SCREENWIDTH;
-	ystep = (FIREHEIGHT << SHIFT) / SCREENHEIGHT;
-	to = screen->GetBuffer();
-	fromold = (uint8_t *)wipe_scr_start;
-	fromnew = (uint8_t *)wipe_scr_end;
-
-	if (!r_blendmethod)
-	{
-		for (y = 0, firey = 0; y < SCREENHEIGHT; y++, firey += ystep)
-		{
-			for (x = 0, firex = 0; x < SCREENWIDTH; x++, firex += xstep)
-			{
-				int fglevel;
-
-				fglevel = burnarray[(firex>>SHIFT)+(firey>>SHIFT)*FIREWIDTH] / 2;
-				if (fglevel >= 63)
-				{
-					to[x] = fromnew[x];
-				}
-				else if (fglevel == 0)
-				{
-					to[x] = fromold[x];
-					done = false;
-				}
-				else
-				{
-					int bglevel = 64-fglevel;
-					uint32_t *fg2rgb = Col2RGB8[fglevel];
-					uint32_t *bg2rgb = Col2RGB8[bglevel];
-					uint32_t fg = fg2rgb[fromnew[x]];
-					uint32_t bg = bg2rgb[fromold[x]];
-					fg = (fg+bg) | 0x1f07c1f;
-					to[x] = RGB32k.All[fg & (fg>>15)];
-					done = false;
-				}
-			}
-			fromold += SCREENWIDTH;
-			fromnew += SCREENWIDTH;
-			to += SCREENPITCH;
-		}
-
-	}
-	else
-	{
-		for (y = 0, firey = 0; y < SCREENHEIGHT; y++, firey += ystep)
-		{
-			for (x = 0, firex = 0; x < SCREENWIDTH; x++, firex += xstep)
-			{
-				int fglevel;
-
-				fglevel = burnarray[(firex>>SHIFT)+(firey>>SHIFT)*FIREWIDTH] / 2;
-				if (fglevel >= 63)
-				{
-					to[x] = fromnew[x];
-				}
-				else if (fglevel == 0)
-				{
-					to[x] = fromold[x];
-					done = false;
-				}
-				else
-				{
-					int bglevel = 64-fglevel;
-
-					const PalEntry* pal = GPalette.BaseColors;
-
-					uint32_t fg = fromnew[x];
-					uint32_t bg = fromold[x];
-					int r = MIN((pal[fg].r * fglevel + pal[bg].r * bglevel) >> 8, 63);
-					int g = MIN((pal[fg].g * fglevel + pal[bg].g * bglevel) >> 8, 63);
-					int b = MIN((pal[fg].b * fglevel + pal[bg].b * bglevel) >> 8, 63);
-					to[x] = RGB256k.RGB[r][g][b];
-					done = false;
-				}
-			}
-			fromold += SCREENWIDTH;
-			fromnew += SCREENWIDTH;
-			to += SCREENPITCH;
-		}
-	}
-	return done || (burntime > 40);
-}
-
-bool wipe_exitBurn (int ticks)
-{
-	delete[] burnarray;
-	return 0;
-}
-
-// Crossfade --------------------------------------------------------
-
-bool wipe_initFade (int ticks)
-{
-	fade = 0;
-	return 0;
-}
-
-bool wipe_doFade (int ticks)
-{
-	fade += ticks * 2;
-	if (fade > 64)
-	{
-		screen->DrawBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_end);
-		return true;
-	}
-	else
-	{
-		int x, y;
-		int bglevel = 64 - fade;
-		uint32_t *fg2rgb = Col2RGB8[fade];
-		uint32_t *bg2rgb = Col2RGB8[bglevel];
-		uint8_t *fromnew = (uint8_t *)wipe_scr_end;
-		uint8_t *fromold = (uint8_t *)wipe_scr_start;
-		uint8_t *to = screen->GetBuffer();
-		const PalEntry *pal = GPalette.BaseColors;
-
-		if (!r_blendmethod)
-		{
-			for (y = 0; y < SCREENHEIGHT; y++)
-			{
-				for (x = 0; x < SCREENWIDTH; x++)
-				{
-					uint32_t fg = fg2rgb[fromnew[x]];
-					uint32_t bg = bg2rgb[fromold[x]];
-					fg = (fg+bg) | 0x1f07c1f;
-					to[x] = RGB32k.All[fg & (fg>>15)];
-				}
-				fromnew += SCREENWIDTH;
-				fromold += SCREENWIDTH;
-				to += SCREENPITCH;
-			}
-		}
-		else
-		{
-			for (y = 0; y < SCREENHEIGHT; y++)
-			{
-				for (x = 0; x < SCREENWIDTH; x++)
-				{
-					uint32_t fg = fromnew[x];
-					uint32_t bg = fromold[x];
-					int r = MIN((pal[fg].r * (64-bglevel) + pal[bg].r * bglevel) >> 8, 63);
-					int g = MIN((pal[fg].g * (64-bglevel) + pal[bg].g * bglevel) >> 8, 63);
-					int b = MIN((pal[fg].b * (64-bglevel) + pal[bg].b * bglevel) >> 8, 63);
-					to[x] = RGB256k.RGB[r][g][b];
-				}
-				fromnew += SCREENWIDTH;
-				fromold += SCREENWIDTH;
-				to += SCREENPITCH;
-			}
-		}
-	}
-	return false;
-}
-
-bool wipe_exitFade (int ticks)
-{
-	return 0;
-}
-
-// General Wipe Functions -------------------------------------------
-
-static bool (*wipes[])(int) =
-{
-	wipe_initMelt, wipe_doMelt, wipe_exitMelt,
-	wipe_initBurn, wipe_doBurn, wipe_exitBurn,
-	wipe_initFade, wipe_doFade, wipe_exitFade
-};
-
-// Returns true if the wipe should be performed.
-bool wipe_StartScreen (int type)
-{
-	if (screen->IsBgra())
-		return false;
-
-	CurrentWipeType = clamp(type, 0, wipe_NUMWIPES - 1);
-
-	if (CurrentWipeType)
-	{
-		wipe_scr_start = new short[SCREENWIDTH * SCREENHEIGHT / 2];
-		screen->GetBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_start);
-		return true;
-	}
-	return false;
-}
-
-void wipe_EndScreen (void)
-{
-	if (screen->IsBgra())
-		return;
-
-	if (CurrentWipeType)
-	{
-		wipe_scr_end = new short[SCREENWIDTH * SCREENHEIGHT / 2];
-		screen->GetBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_end);
-		screen->DrawBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_start); // restore start scr.
-
-		// Initialize the wipe
-		(*wipes[(CurrentWipeType-1)*3])(0);
-	}
-}
-
-// Returns true if the wipe is done.
-bool wipe_ScreenWipe (int ticks)
-{
-	bool rc;
-
-	if (screen->IsBgra())
-		return true;
-
-	if (CurrentWipeType == wipe_None)
-		return true;
-
-	// do a piece of wipe-in
-	rc = (*wipes[(CurrentWipeType-1)*3+1])(ticks);
-
-	return rc;
-}
-
-// Final things for the wipe
-void wipe_Cleanup()
-{
-	if (screen->IsBgra())
-		return;
-
-	if (wipe_scr_start != NULL)
-	{
-		delete[] wipe_scr_start;
-		wipe_scr_start = NULL;
-	}
-	if (wipe_scr_end != NULL)
-	{
-		delete[] wipe_scr_end;
-		wipe_scr_end = NULL;
-	}
-	if (CurrentWipeType > 0)
-	{
-		(*wipes[(CurrentWipeType-1)*3+2])(0);
-	}
-}
diff --git a/src/f_wipe.h b/src/f_wipe.h
index a9296745d..dc4cfb8cc 100644
--- a/src/f_wipe.h
+++ b/src/f_wipe.h
@@ -30,6 +30,7 @@
 //						 SCREEN WIPE PACKAGE
 //
 
+#if 0
 bool wipe_StartScreen (int type);
 void wipe_EndScreen (void);
 bool wipe_ScreenWipe (int ticks);
@@ -37,7 +38,8 @@ void wipe_Cleanup ();
 
 // The buffer must have an additional 5 rows not included in height
 // to use for a seeding area.
-int wipe_CalcBurn (uint8_t *buffer, int width, int height, int density);
+#endif
+int wipe_CalcBurn(uint8_t *buffer, int width, int height, int density);
 
 enum
 {
diff --git a/src/g_statusbar/shared_sbar.cpp b/src/g_statusbar/shared_sbar.cpp
index ecbf2bd51..297561d65 100644
--- a/src/g_statusbar/shared_sbar.cpp
+++ b/src/g_statusbar/shared_sbar.cpp
@@ -835,8 +835,8 @@ void DBaseStatusBar::RefreshBackground () const
 	{
 		if(y < SCREENHEIGHT)
 		{
-			V_DrawBorder (x+1, y, SCREENWIDTH, y+1);
-			V_DrawBorder (x+1, SCREENHEIGHT-1, SCREENWIDTH, SCREENHEIGHT);
+			screen->DrawBorder (x+1, y, SCREENWIDTH, y+1);
+			screen->DrawBorder (x+1, SCREENHEIGHT-1, SCREENWIDTH, SCREENHEIGHT);
 		}
 	}
 	else
@@ -855,8 +855,8 @@ void DBaseStatusBar::RefreshBackground () const
 			x2 = SCREENWIDTH;
 		}
 
-		V_DrawBorder (0, y, x+1, SCREENHEIGHT);
-		V_DrawBorder (x2-1, y, SCREENWIDTH, SCREENHEIGHT);
+		screen->DrawBorder (0, y, x+1, SCREENHEIGHT);
+		screen->DrawBorder (x2-1, y, SCREENWIDTH, SCREENHEIGHT);
 
 		if (setblocks >= 10)
 		{
diff --git a/src/swrenderer/r_swcanvas.h b/src/swrenderer/r_swcanvas.h
deleted file mode 100644
index 3d8135c2f..000000000
--- a/src/swrenderer/r_swcanvas.h
+++ /dev/null
@@ -1,22 +0,0 @@
-
-#pragma once
-
-#include "v_video.h"
-#include "r_data/colormaps.h"
-
-class SWCanvas
-{
-public:
-	static void DrawTexture(DCanvas *canvas, FTexture *img, DrawParms &parms);
-	static void FillSimplePoly(DCanvas *canvas, FTexture *tex, FVector2 *points, int npoints,
-		double originx, double originy, double scalex, double scaley, DAngle rotation,
-		const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip);
-	static void DrawLine(DCanvas *canvas, int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor);
-	static void DrawPixel(DCanvas *canvas, int x, int y, int palColor, uint32_t realcolor);
-	static void Clear(DCanvas *canvas, int left, int top, int right, int bottom, int palcolor, uint32_t color);
-	static void Dim(DCanvas *canvas, PalEntry color, float damount, int x1, int y1, int w, int h);
-
-private:
-	static void PUTTRANSDOT(DCanvas *canvas, int xx, int yy, int basecolor, int level);
-	static int PalFromRGB(uint32_t rgb);
-};
diff --git a/src/swrenderer/scene/r_portal.cpp b/src/swrenderer/scene/r_portal.cpp
index a22232dbf..75f09dd4a 100644
--- a/src/swrenderer/scene/r_portal.cpp
+++ b/src/swrenderer/scene/r_portal.cpp
@@ -69,7 +69,9 @@
 #include "swrenderer/r_renderthread.h"
 
 CVAR(Int, r_portal_recursions, 4, CVAR_ARCHIVE)
-CVAR(Bool, r_highlight_portals, false, CVAR_ARCHIVE)
+#if 0
+CVAR(Bool, r_highlight_portals, false, 0)
+#endif
 CVAR(Bool, r_skyboxes, true, 0)
 
 // Avoid infinite recursion with stacked sectors by limiting them.
@@ -321,8 +323,10 @@ namespace swrenderer
 				}
 			}
 
+#if 0
 			if (r_highlight_portals)
 				RenderLinePortalHighlight(pds);
+#endif
 
 			return;
 		}
@@ -462,9 +466,11 @@ namespace swrenderer
 		Thread->Clip3D->LeaveSkybox(); // pop 3D floor height map
 		CurrentPortalUniq = prevuniq2;
 
+#if 0
 		// draw a red line around a portal if it's being highlighted
 		if (r_highlight_portals)
 			RenderLinePortalHighlight(pds);
+#endif
 
 		CurrentPortal = prevpds;
 		MirrorFlags = prevmf;
@@ -474,6 +480,7 @@ namespace swrenderer
 		viewpoint.Path[1] = savedpath[1];
 	}
 
+#if 0
 	void RenderPortal::RenderLinePortalHighlight(PortalDrawseg* pds)
 	{
 		// [ZZ] NO OVERFLOW CHECKS HERE
@@ -515,6 +522,7 @@ namespace swrenderer
 			else *(pixels + Ybottom * viewport->RenderTarget->GetPitch() + x) = color;
 		}
 	}
+#endif
 	
 	void RenderPortal::CopyStackedViewParameters()
 	{
diff --git a/src/v_draw.cpp b/src/v_draw.cpp
index 35670abf9..0029e124c 100644
--- a/src/v_draw.cpp
+++ b/src/v_draw.cpp
@@ -32,8 +32,6 @@
 **
 */
 
-// #define NO_SWRENDER 	// set this if you want to exclude the software renderer. Without the software renderer software canvas drawing does nothing.
-
 #include <stdio.h>
 #include <stdarg.h>
 
@@ -43,9 +41,6 @@
 #include "r_defs.h"
 #include "r_utility.h"
 #include "r_renderer.h"
-#ifndef NO_SWRENDER
-#include "swrenderer/r_swcanvas.h"
-#endif
 #include "r_data/r_translate.h"
 #include "doomstat.h"
 #include "v_palette.h"
@@ -64,6 +59,19 @@
 #include "textures.h"
 #include "vm.h"
 
+CUSTOM_CVAR(Float, dimamount, -1.f, CVAR_ARCHIVE)
+{
+	if (self < 0.f && self != -1.f)
+	{
+		self = -1.f;
+	}
+	else if (self > 1.f)
+	{
+		self = 1.f;
+	}
+}
+CVAR(Color, dimcolor, 0xffd700, CVAR_ARCHIVE)
+
 CUSTOM_CVAR(Int, uiscale, 0, CVAR_ARCHIVE | CVAR_NOINITCALL)
 {
 	if (self < 0)
@@ -109,6 +117,12 @@ int CleanWidth, CleanHeight;
 int CleanXfac_1, CleanYfac_1, CleanWidth_1, CleanHeight_1;
 
 
+//==========================================================================
+//
+// ZScript wrappers for inlines
+//
+//==========================================================================
+
 DEFINE_ACTION_FUNCTION(_Screen, GetWidth)
 {
 	PARAM_PROLOGUE;
@@ -130,7 +144,13 @@ DEFINE_ACTION_FUNCTION(_Screen, PaletteColor)
 	ACTION_RETURN_INT(index);
 }
 
-void DCanvas::DrawTexture (FTexture *img, double x, double y, int tags_first, ...)
+//==========================================================================
+//
+// Internal texture drawing function
+//
+//==========================================================================
+
+void DFrameBuffer::DrawTexture (FTexture *img, double x, double y, int tags_first, ...)
 {
 	Va_List tags;
 	va_start(tags.list, tags_first);
@@ -145,9 +165,15 @@ void DCanvas::DrawTexture (FTexture *img, double x, double y, int tags_first, ..
 	DrawTextureParms(img, parms);
 }
 
+//==========================================================================
+//
+// ZScript texture drawing function
+//
+//==========================================================================
+
 int ListGetInt(VMVa_List &tags);
 
-void DCanvas::DrawTexture(FTexture *img, double x, double y, VMVa_List &args)
+void DFrameBuffer::DrawTexture(FTexture *img, double x, double y, VMVa_List &args)
 {
 	DrawParms parms;
 	uint32_t tag = ListGetInt(args);
@@ -172,19 +198,23 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawTexture)
 	return 0;
 }
 
-void DCanvas::DrawTextureParms(FTexture *img, DrawParms &parms)
-{
-#ifndef NO_SWRENDER
-	SWCanvas::DrawTexture(this, img, parms);
-#endif
+//==========================================================================
+//
+// common drawing function
+//
+//==========================================================================
 
-	if (ticdup != 0 && menuactive == MENU_Off)
-	{
-		NetUpdate();
-	}
+void DFrameBuffer::DrawTextureParms(FTexture *img, DrawParms &parms)
+{
 }
 
-void DCanvas::SetClipRect(int x, int y, int w, int h)
+//==========================================================================
+//
+// Clipping rect
+//
+//==========================================================================
+
+void DFrameBuffer::SetClipRect(int x, int y, int w, int h)
 {
 	clipleft = clamp(x, 0, GetWidth());
 	clipwidth = clamp(w, -1, GetWidth() - x);
@@ -210,7 +240,7 @@ DEFINE_ACTION_FUNCTION(_Screen, ClearClipRect)
 	return 0;
 }
 
-void DCanvas::GetClipRect(int *x, int *y, int *w, int *h)
+void DFrameBuffer::GetClipRect(int *x, int *y, int *w, int *h)
 {
 	if (x) *x = clipleft;
 	if (y) *y = cliptop;
@@ -240,7 +270,13 @@ DEFINE_ACTION_FUNCTION(_Screen, GetViewWindow)
 	return MIN(numret, 4);
 }
 
-bool DCanvas::SetTextureParms(DrawParms *parms, FTexture *img, double xx, double yy) const
+//==========================================================================
+//
+// Draw parameter parsing
+//
+//==========================================================================
+
+bool DFrameBuffer::SetTextureParms(DrawParms *parms, FTexture *img, double xx, double yy) const
 {
 	if (img != NULL)
 	{
@@ -322,6 +358,12 @@ bool DCanvas::SetTextureParms(DrawParms *parms, FTexture *img, double xx, double
 	return false;
 }
 
+//==========================================================================
+//
+// template helpers
+//
+//==========================================================================
+
 static void ListEnd(Va_List &tags)
 {
 	va_end(tags.list);
@@ -387,8 +429,14 @@ static inline FColormapStyle * ListGetColormapStyle(VMVa_List &tags)
 	return nullptr;
 }
 
+//==========================================================================
+//
+// Main taglist parsing
+//
+//==========================================================================
+
 template<class T>
-bool DCanvas::ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const
+bool DFrameBuffer::ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const
 {
 	INTBOOL boolval;
 	int intval;
@@ -836,10 +884,16 @@ bool DCanvas::ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t t
 }
 // explicitly instantiate both versions for v_text.cpp.
 
-template bool DCanvas::ParseDrawTextureTags<Va_List>(FTexture *img, double x, double y, uint32_t tag, Va_List& tags, DrawParms *parms, bool fortext) const;
-template bool DCanvas::ParseDrawTextureTags<VMVa_List>(FTexture *img, double x, double y, uint32_t tag, VMVa_List& tags, DrawParms *parms, bool fortext) const;
+template bool DFrameBuffer::ParseDrawTextureTags<Va_List>(FTexture *img, double x, double y, uint32_t tag, Va_List& tags, DrawParms *parms, bool fortext) const;
+template bool DFrameBuffer::ParseDrawTextureTags<VMVa_List>(FTexture *img, double x, double y, uint32_t tag, VMVa_List& tags, DrawParms *parms, bool fortext) const;
 
-void DCanvas::VirtualToRealCoords(double &x, double &y, double &w, double &h,
+//==========================================================================
+//
+// Coordinate conversion
+//
+//==========================================================================
+
+void DFrameBuffer::VirtualToRealCoords(double &x, double &y, double &w, double &h,
 	double vwidth, double vheight, bool vbottom, bool handleaspect) const
 {
 	float myratio = handleaspect ? ActiveRatio (Width, Height) : (4.0f / 3.0f);
@@ -899,7 +953,7 @@ DEFINE_ACTION_FUNCTION(_Screen, VirtualToRealCoords)
 	return MIN(numret, 2);
 }
 
-void DCanvas::VirtualToRealCoordsInt(int &x, int &y, int &w, int &h,
+void DFrameBuffer::VirtualToRealCoordsInt(int &x, int &y, int &w, int &h,
 	int vwidth, int vheight, bool vbottom, bool handleaspect) const
 {
 	double dx, dy, dw, dh;
@@ -915,7 +969,13 @@ void DCanvas::VirtualToRealCoordsInt(int &x, int &y, int &w, int &h,
 	h = int(dy + dh + 0.5) - y;
 }
 
-void DCanvas::FillBorder (FTexture *img)
+//==========================================================================
+//
+//
+//
+//==========================================================================
+
+void DFrameBuffer::FillBorder (FTexture *img)
 {
 	float myratio = ActiveRatio (Width, Height);
 
@@ -961,11 +1021,14 @@ void DCanvas::FillBorder (FTexture *img)
 	}
 }
 
-void DCanvas::DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor)
+//==========================================================================
+//
+// Draw a line
+//
+//==========================================================================
+
+void DFrameBuffer::DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor)
 {
-#ifndef NO_SWRENDER
-	SWCanvas::DrawLine(this, x0, y0, x1, y1, palColor, realcolor);
-#endif
 }
 
 DEFINE_ACTION_FUNCTION(_Screen, DrawLine)
@@ -981,11 +1044,14 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawLine)
 	return 0;
 }
 
-void DCanvas::DrawPixel(int x, int y, int palColor, uint32_t realcolor)
+//==========================================================================
+//
+// Draw a single pixel
+//
+//==========================================================================
+
+void DFrameBuffer::DrawPixel(int x, int y, int palColor, uint32_t realcolor)
 {
-#ifndef NO_SWRENDER
-	SWCanvas::DrawPixel(this, x, y, palColor, realcolor);
-#endif
 }
 
 //==========================================================================
@@ -996,21 +1062,11 @@ void DCanvas::DrawPixel(int x, int y, int palColor, uint32_t realcolor)
 //
 //==========================================================================
 
-void DCanvas::DoClear (int left, int top, int right, int bottom, int palcolor, uint32_t color)
+void DFrameBuffer::DoClear (int left, int top, int right, int bottom, int palcolor, uint32_t color)
 {
-#ifndef NO_SWRENDER
-	if (palcolor < 0 && APART(color) != 255)
-	{
-		Dim(color, APART(color) / 255.f, left, top, right - left, bottom - top);
-	}
-	else
-	{
-		SWCanvas::Clear(this, left, top, right, bottom, palcolor, color);
-	}
-#endif
 }
 
-void DCanvas::Clear(int left, int top, int right, int bottom, int palcolor, uint32_t color)
+void DFrameBuffer::Clear(int left, int top, int right, int bottom, int palcolor, uint32_t color)
 {
 	if (clipwidth >= 0 && clipheight >= 0)
 	{
@@ -1059,14 +1115,11 @@ DEFINE_ACTION_FUNCTION(_Screen, Clear)
 //
 //==========================================================================
 
-void DCanvas::DoDim(PalEntry color, float damount, int x1, int y1, int w, int h)
+void DFrameBuffer::DoDim(PalEntry color, float damount, int x1, int y1, int w, int h)
 {
-#ifndef NO_SWRENDER
-	SWCanvas::Dim(this, color, damount, x1, y1, w, h);
-#endif
 }
 
-void DCanvas::Dim(PalEntry color, float damount, int x1, int y1, int w, int h)
+void DFrameBuffer::Dim(PalEntry color, float damount, int x1, int y1, int w, int h)
 {
 	if (clipwidth >= 0 && clipheight >= 0)
 	{
@@ -1118,112 +1171,84 @@ DEFINE_ACTION_FUNCTION(_Screen, Dim)
 //
 //==========================================================================
 
-void DCanvas::FillSimplePoly(FTexture *tex, FVector2 *points, int npoints,
+void DFrameBuffer::FillSimplePoly(FTexture *tex, FVector2 *points, int npoints,
 	double originx, double originy, double scalex, double scaley, DAngle rotation,
 	const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip)
 {
-#ifndef NO_SWRENDER
-	SWCanvas::FillSimplePoly(this, tex, points, npoints, originx, originy, scalex, scaley, rotation, colormap, flatcolor, lightlevel, bottomclip);
-#endif
 }
 
-
-/********************************/
-/*								*/
-/* Other miscellaneous routines */
-/*								*/
-/********************************/
-
-
+//==========================================================================
 //
-// V_DrawBlock
-// Draw a linear block of pixels into the view buffer.
+// DCanvas :: FlatFill
 //
-void DCanvas::DrawBlock (int x, int y, int _width, int _height, const uint8_t *src) const
+// Fill an area with a texture. If local_origin is false, then the origin
+// used for the wrapping is (0,0). Otherwise, (left,right) is used.
+//
+//==========================================================================
+
+void DFrameBuffer::FlatFill(int left, int top, int right, int bottom, FTexture *src, bool local_origin)
 {
-	if (IsBgra())
-		return;
+	int w = src->GetWidth();
+	int h = src->GetHeight();
 
-	int srcpitch = _width;
-	int destpitch;
-	uint8_t *dest;
-
-	if (ClipBox (x, y, _width, _height, src, srcpitch))
+	// Repeatedly draw the texture, left-to-right, top-to-bottom.
+	for (int y = local_origin ? top : (top / h * h); y < bottom; y += h)
 	{
-		return;		// Nothing to draw
+		for (int x = local_origin ? left : (left / w * w); x < right; x += w)
+		{
+			DrawTexture(src, x, y,
+				DTA_ClipLeft, left,
+				DTA_ClipRight, right,
+				DTA_ClipTop, top,
+				DTA_ClipBottom, bottom,
+				DTA_TopOffset, 0,
+				DTA_LeftOffset, 0,
+				TAG_DONE);
+		}
 	}
-
-	destpitch = Pitch;
-	dest = Buffer + y*Pitch + x;
-
-	do
-	{
-		memcpy (dest, src, _width);
-		src += srcpitch;
-		dest += destpitch;
-	} while (--_height);
 }
 
+//==========================================================================
 //
-// V_GetBlock
-// Gets a linear block of pixels from the view buffer.
+// DCanvas :: Dim
 //
-void DCanvas::GetBlock (int x, int y, int _width, int _height, uint8_t *dest) const
+// Applies a colored overlay to the entire screen, with the opacity
+// determined by the dimamount cvar.
+//
+//==========================================================================
+
+void DFrameBuffer::Dim(PalEntry color)
 {
-	if (IsBgra())
-		return;
+	PalEntry dimmer;
+	float amount;
 
-	const uint8_t *src;
-
-#ifdef RANGECHECK 
-	if (x<0
-		||x+_width > Width
-		|| y<0
-		|| y+_height>Height)
+	if (dimamount >= 0)
 	{
-		I_Error ("Bad V_GetBlock");
+		dimmer = PalEntry(dimcolor);
+		amount = dimamount;
 	}
-#endif
-
-	src = Buffer + y*Pitch + x;
-
-	while (_height--)
+	else
 	{
-		memcpy (dest, src, _width);
-		src += Pitch;
-		dest += _width;
+		dimmer = gameinfo.dimcolor;
+		amount = gameinfo.dimamount;
 	}
+
+	if (gameinfo.gametype == GAME_Hexen && gamestate == GS_DEMOSCREEN)
+	{ // On the Hexen title screen, the default dimming is not
+	  // enough to make the menus readable.
+		amount = MIN<float>(1.f, amount*2.f);
+	}
+	// Add the cvar's dimming on top of the color passed to the function
+	if (color.a != 0)
+	{
+		float dim[4] = { color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f };
+		V_AddBlend(dimmer.r / 255.f, dimmer.g / 255.f, dimmer.b / 255.f, amount, dim);
+		dimmer = PalEntry(uint8_t(dim[0] * 255), uint8_t(dim[1] * 255), uint8_t(dim[2] * 255));
+		amount = dim[3];
+	}
+	Dim(dimmer, amount, 0, 0, Width, Height);
 }
 
-// Returns true if the box was completely clipped. False otherwise.
-bool DCanvas::ClipBox (int &x, int &y, int &w, int &h, const uint8_t *&src, const int srcpitch) const
-{
-	if (x >= Width || y >= Height || x+w <= 0 || y+h <= 0)
-	{ // Completely clipped off screen
-		return true;
-	}
-	if (x < 0)				// clip left edge
-	{
-		src -= x;
-		w += x;
-		x = 0;
-	}
-	if (x+w > Width)		// clip right edge
-	{
-		w = Width - x;
-	}
-	if (y < 0)				// clip top edge
-	{
-		src -= y*srcpitch;
-		h += y;
-		y = 0;
-	}
-	if (y+h > Height)		// clip bottom edge
-	{
-		h = Height - y;
-	}
-	return false;
-}
 
 //==========================================================================
 //
@@ -1251,7 +1276,7 @@ void V_SetBorderNeedRefresh()
 //
 //==========================================================================
 
-void V_DrawFrame (int left, int top, int width, int height)
+void DFrameBuffer::DrawFrame (int left, int top, int width, int height)
 {
 	FTexture *p;
 	const gameborder_t *border = &gameinfo.Border;
@@ -1264,21 +1289,21 @@ void V_DrawFrame (int left, int top, int width, int height)
 
 	// Draw top and bottom sides.
 	p = TexMan[border->t];
-	screen->FlatFill(left, top - p->GetHeight(), right, top, p, true);
+	FlatFill(left, top - p->GetHeight(), right, top, p, true);
 	p = TexMan[border->b];
-	screen->FlatFill(left, bottom, right, bottom + p->GetHeight(), p, true);
+	FlatFill(left, bottom, right, bottom + p->GetHeight(), p, true);
 
 	// Draw left and right sides.
 	p = TexMan[border->l];
-	screen->FlatFill(left - p->GetWidth(), top, left, bottom, p, true);
+	FlatFill(left - p->GetWidth(), top, left, bottom, p, true);
 	p = TexMan[border->r];
-	screen->FlatFill(right, top, right + p->GetWidth(), bottom, p, true);
+	FlatFill(right, top, right + p->GetWidth(), bottom, p, true);
 
 	// Draw beveled corners.
-	screen->DrawTexture (TexMan[border->tl], left-offset, top-offset, TAG_DONE);
-	screen->DrawTexture (TexMan[border->tr], left+width, top-offset, TAG_DONE);
-	screen->DrawTexture (TexMan[border->bl], left-offset, top+height, TAG_DONE);
-	screen->DrawTexture (TexMan[border->br], left+width, top+height, TAG_DONE);
+	DrawTexture (TexMan[border->tl], left-offset, top-offset, TAG_DONE);
+	DrawTexture (TexMan[border->tr], left+width, top-offset, TAG_DONE);
+	DrawTexture (TexMan[border->bl], left-offset, top+height, TAG_DONE);
+	DrawTexture (TexMan[border->br], left+width, top+height, TAG_DONE);
 }
 
 DEFINE_ACTION_FUNCTION(_Screen, DrawFrame)
@@ -1288,17 +1313,17 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawFrame)
 	PARAM_INT(y);
 	PARAM_INT(w);
 	PARAM_INT(h);
-	V_DrawFrame(x, y, w, h);
+	screen->DrawFrame(x, y, w, h);
 	return 0;
 }
 
 //==========================================================================
 //
-// V_DrawBorder
+// screen->DrawBorder
 //
 //==========================================================================
 
-void V_DrawBorder (int x1, int y1, int x2, int y2)
+void DFrameBuffer::DrawBorder (int x1, int y1, int x2, int y2)
 {
 	FTextureID picnum;
 
@@ -1313,11 +1338,11 @@ void V_DrawBorder (int x1, int y1, int x2, int y2)
 
 	if (picnum.isValid())
 	{
-		screen->FlatFill (x1, y1, x2, y2, TexMan(picnum));
+		FlatFill (x1, y1, x2, y2, TexMan(picnum));
 	}
 	else
 	{
-		screen->Clear (x1, y1, x2, y2, 0, 0);
+		Clear (x1, y1, x2, y2, 0, 0);
 	}
 }
 
@@ -1332,19 +1357,19 @@ void V_DrawBorder (int x1, int y1, int x2, int y2)
 int BorderNeedRefresh;
 
 
-static void V_DrawViewBorder (void)
+void DFrameBuffer::DrawViewBorder (void)
 {
-	if (viewwidth == SCREENWIDTH)
+	if (viewwidth == Width)
 	{
 		return;
 	}
 
-	V_DrawBorder (0, 0, SCREENWIDTH, viewwindowy);
-	V_DrawBorder (0, viewwindowy, viewwindowx, viewheight + viewwindowy);
-	V_DrawBorder (viewwindowx + viewwidth, viewwindowy, SCREENWIDTH, viewheight + viewwindowy);
-	V_DrawBorder (0, viewwindowy + viewheight, SCREENWIDTH, StatusBar->GetTopOfStatusbar());
+	DrawBorder (0, 0, Width, viewwindowy);
+	DrawBorder (0, viewwindowy, viewwindowx, viewheight + viewwindowy);
+	DrawBorder (viewwindowx + viewwidth, viewwindowy, Width, viewheight + viewwindowy);
+	DrawBorder (0, viewwindowy + viewheight, Width, StatusBar->GetTopOfStatusbar());
 
-	V_DrawFrame (viewwindowx, viewwindowy, viewwidth, viewheight);
+	DrawFrame (viewwindowx, viewwindowy, viewwidth, viewheight);
 }
 
 //==========================================================================
@@ -1355,41 +1380,38 @@ static void V_DrawViewBorder (void)
 //
 //==========================================================================
 
-static void V_DrawTopBorder ()
+void DFrameBuffer::DrawTopBorder ()
 {
 	FTexture *p;
 	int offset;
 
-	if (viewwidth == SCREENWIDTH)
+	if (viewwidth == Width)
 		return;
 
 	offset = gameinfo.Border.offset;
 
 	if (viewwindowy < 34)
 	{
-		V_DrawBorder (0, 0, viewwindowx, 34);
-		V_DrawBorder (viewwindowx, 0, viewwindowx + viewwidth, viewwindowy);
-		V_DrawBorder (viewwindowx + viewwidth, 0, SCREENWIDTH, 34);
+		DrawBorder (0, 0, viewwindowx, 34);
+		DrawBorder (viewwindowx, 0, viewwindowx + viewwidth, viewwindowy);
+		DrawBorder (viewwindowx + viewwidth, 0, Width, 34);
 		p = TexMan(gameinfo.Border.t);
-		screen->FlatFill(viewwindowx, viewwindowy - p->GetHeight(),
-						 viewwindowx + viewwidth, viewwindowy, p, true);
+		FlatFill(viewwindowx, viewwindowy - p->GetHeight(), viewwindowx + viewwidth, viewwindowy, p, true);
 
 		p = TexMan(gameinfo.Border.l);
-		screen->FlatFill(viewwindowx - p->GetWidth(), viewwindowy,
-						 viewwindowx, 35, p, true);
+		FlatFill(viewwindowx - p->GetWidth(), viewwindowy, viewwindowx, 35, p, true);
 		p = TexMan(gameinfo.Border.r);
-		screen->FlatFill(viewwindowx + viewwidth, viewwindowy,
-						 viewwindowx + viewwidth + p->GetWidth(), 35, p, true);
+		FlatFill(viewwindowx + viewwidth, viewwindowy, viewwindowx + viewwidth + p->GetWidth(), 35, p, true);
 
 		p = TexMan(gameinfo.Border.tl);
-		screen->DrawTexture (p, viewwindowx - offset, viewwindowy - offset, TAG_DONE);
+		DrawTexture (p, viewwindowx - offset, viewwindowy - offset, TAG_DONE);
 
 		p = TexMan(gameinfo.Border.tr);
-		screen->DrawTexture (p, viewwindowx + viewwidth, viewwindowy - offset, TAG_DONE);
+		DrawTexture (p, viewwindowx + viewwidth, viewwindowy - offset, TAG_DONE);
 	}
 	else
 	{
-		V_DrawBorder (0, 0, SCREENWIDTH, 34);
+		DrawBorder (0, 0, Width, 34);
 	}
 }
 
@@ -1401,7 +1423,7 @@ static void V_DrawTopBorder ()
 //
 //==========================================================================
 
-void V_RefreshViewBorder ()
+void DFrameBuffer::RefreshViewBorder ()
 {
 	if (setblocks < 10)
 	{
@@ -1412,12 +1434,12 @@ void V_RefreshViewBorder ()
 			{
 				BorderTopRefresh--;
 			}
-			V_DrawViewBorder();
+			DrawViewBorder();
 		}
 		else if (BorderTopRefresh)
 		{
 			BorderTopRefresh--;
-			V_DrawTopBorder();
+			DrawTopBorder();
 		}
 	}
 }
diff --git a/src/v_text.cpp b/src/v_text.cpp
index 06b09a2ef..e0553ef01 100644
--- a/src/v_text.cpp
+++ b/src/v_text.cpp
@@ -132,7 +132,7 @@ int GetCharFromString(const uint8_t *&string)
 //
 //==========================================================================
 
-void DCanvas::DrawChar (FFont *font, int normalcolor, double x, double y, int character, int tag_first, ...)
+void DFrameBuffer::DrawChar (FFont *font, int normalcolor, double x, double y, int character, int tag_first, ...)
 {
 	if (font == NULL)
 		return;
@@ -161,7 +161,7 @@ void DCanvas::DrawChar (FFont *font, int normalcolor, double x, double y, int ch
 	}
 }
 
-void DCanvas::DrawChar(FFont *font, int normalcolor, double x, double y, int character, VMVa_List &args)
+void DFrameBuffer::DrawChar(FFont *font, int normalcolor, double x, double y, int character, VMVa_List &args)
 {
 	if (font == NULL)
 		return;
@@ -208,7 +208,7 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawChar)
 //
 //==========================================================================
 
-void DCanvas::DrawTextCommon(FFont *font, int normalcolor, double x, double y, const char *string, DrawParms &parms)
+void DFrameBuffer::DrawTextCommon(FFont *font, int normalcolor, double x, double y, const char *string, DrawParms &parms)
 {
 	int 		w;
 	const uint8_t *ch;
@@ -281,7 +281,7 @@ void DCanvas::DrawTextCommon(FFont *font, int normalcolor, double x, double y, c
 	}
 }
 
-void DCanvas::DrawText(FFont *font, int normalcolor, double x, double y, const char *string, int tag_first, ...)
+void DFrameBuffer::DrawText(FFont *font, int normalcolor, double x, double y, const char *string, int tag_first, ...)
 {
 	Va_List tags;
 	DrawParms parms;
@@ -299,7 +299,7 @@ void DCanvas::DrawText(FFont *font, int normalcolor, double x, double y, const c
 	DrawTextCommon(font, normalcolor, x, y, string, parms);
 }
 
-void DCanvas::DrawText(FFont *font, int normalcolor, double x, double y, const char *string, VMVa_List &args)
+void DFrameBuffer::DrawText(FFont *font, int normalcolor, double x, double y, const char *string, VMVa_List &args)
 {
 	DrawParms parms;
 
diff --git a/src/v_video.cpp b/src/v_video.cpp
index 761c805d7..88f6c396d 100644
--- a/src/v_video.cpp
+++ b/src/v_video.cpp
@@ -191,19 +191,6 @@ CUSTOM_CVAR (Int, vid_refreshrate, 0, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
 	}
 }
 
-CUSTOM_CVAR (Float, dimamount, -1.f, CVAR_ARCHIVE)
-{
-	if (self < 0.f && self != -1.f)
-	{
-		self = -1.f;
-	}
-	else if (self > 1.f)
-	{
-		self = 1.f;
-	}
-}
-CVAR (Color, dimcolor, 0xffd700, CVAR_ARCHIVE)
-
 // [RH] Set true when vid_setmode command has been executed
 bool	setmodeneeded = false;
 // [RH] Resolution to change to when setmodeneeded is true
@@ -248,78 +235,6 @@ bool DCanvas::IsValid ()
 	return false;
 }
 
-//==========================================================================
-//
-// DCanvas :: FlatFill
-//
-// Fill an area with a texture. If local_origin is false, then the origin
-// used for the wrapping is (0,0). Otherwise, (left,right) is used.
-//
-//==========================================================================
-
-void DCanvas::FlatFill (int left, int top, int right, int bottom, FTexture *src, bool local_origin)
-{
-	int w = src->GetWidth();
-	int h = src->GetHeight();
-
-	// Repeatedly draw the texture, left-to-right, top-to-bottom.
-	for (int y = local_origin ? top : (top / h * h); y < bottom; y += h)
-	{
-		for (int x = local_origin ? left : (left / w * w); x < right; x += w)
-		{
-			DrawTexture (src, x, y,
-				DTA_ClipLeft, left,
-				DTA_ClipRight, right,
-				DTA_ClipTop, top,
-				DTA_ClipBottom, bottom,
-				DTA_TopOffset, 0,
-				DTA_LeftOffset, 0,
-				TAG_DONE);
-		}
-	}
-}
-
-//==========================================================================
-//
-// DCanvas :: Dim
-//
-// Applies a colored overlay to the entire screen, with the opacity
-// determined by the dimamount cvar.
-//
-//==========================================================================
-
-void DCanvas::Dim (PalEntry color)
-{
-	PalEntry dimmer;
-	float amount;
-
-	if (dimamount >= 0)
-	{
-		dimmer = PalEntry(dimcolor);
-		amount = dimamount;
-	}
-	else
-	{
-		dimmer = gameinfo.dimcolor;
-		amount = gameinfo.dimamount;
-	}
-
-	if (gameinfo.gametype == GAME_Hexen && gamestate == GS_DEMOSCREEN)
-	{ // On the Hexen title screen, the default dimming is not
-		// enough to make the menus readable.
-		amount = MIN<float> (1.f, amount*2.f);
-	}
-	// Add the cvar's dimming on top of the color passed to the function
-	if (color.a != 0)
-	{
-		float dim[4] = { color.r/255.f, color.g/255.f, color.b/255.f, color.a/255.f };
-		V_AddBlend (dimmer.r/255.f, dimmer.g/255.f, dimmer.b/255.f, amount, dim);
-		dimmer = PalEntry (uint8_t(dim[0]*255), uint8_t(dim[1]*255), uint8_t(dim[2]*255));
-		amount = dim[3];
-	}
-	Dim (dimmer, amount, 0, 0, Width, Height);
-}
-
 //==========================================================================
 //
 // DCanvas :: GetScreenshotBuffer
@@ -1196,7 +1111,7 @@ FNativePalette *DFrameBuffer::CreatePalette(FRemapTable *remap)
 
 bool DFrameBuffer::WipeStartScreen(int type)
 {
-	return wipe_StartScreen(type);
+	return false;
 }
 
 //==========================================================================
@@ -1210,8 +1125,6 @@ bool DFrameBuffer::WipeStartScreen(int type)
 
 void DFrameBuffer::WipeEndScreen()
 {
-	wipe_EndScreen();
-	Unlock();
 }
 
 //==========================================================================
@@ -1226,8 +1139,7 @@ void DFrameBuffer::WipeEndScreen()
 
 bool DFrameBuffer::WipeDo(int ticks)
 {
-	Lock(true);
-	return wipe_ScreenWipe(ticks);
+	return false;
 }
 
 //==========================================================================
@@ -1238,7 +1150,6 @@ bool DFrameBuffer::WipeDo(int ticks)
 
 void DFrameBuffer::WipeCleanup()
 {
-	wipe_Cleanup();
 }
 
 //==========================================================================
diff --git a/src/v_video.h b/src/v_video.h
index aaa1492fa..67ba8a334 100644
--- a/src/v_video.h
+++ b/src/v_video.h
@@ -219,36 +219,6 @@ public:
 	virtual void Unlock () = 0;
 	virtual bool IsLocked () { return Buffer != NULL; }	// Returns true if the surface is locked
 
-	// Draw a linear block of pixels into the canvas
-	virtual void DrawBlock (int x, int y, int width, int height, const uint8_t *src) const;
-
-	// Reads a linear block of pixels into the view buffer.
-	virtual void GetBlock (int x, int y, int width, int height, uint8_t *dest) const;
-
-	// Dim the entire canvas for the menus
-	virtual void Dim (PalEntry color = 0);
-
-	// Dim part of the canvas
-	virtual void Dim (PalEntry color, float amount, int x1, int y1, int w, int h) final;
-	virtual void DoDim(PalEntry color, float amount, int x1, int y1, int w, int h);
-
-	// Fill an area with a texture
-	virtual void FlatFill (int left, int top, int right, int bottom, FTexture *src, bool local_origin=false);
-
-	// Fill a simple polygon with a texture
-	virtual void FillSimplePoly(FTexture *tex, FVector2 *points, int npoints,
-		double originx, double originy, double scalex, double scaley, DAngle rotation,
-		const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip);
-
-	// Set an area to a specified color
-	virtual void Clear (int left, int top, int right, int bottom, int palcolor, uint32_t color) final;
-	virtual void DoClear(int left, int top, int right, int bottom, int palcolor, uint32_t color);
-
-	// Draws a line
-	virtual void DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor);
-
-	// Draws a single pixel
-	virtual void DrawPixel(int x, int y, int palcolor, uint32_t rgbcolor);
 
 	// Calculate gamma table
 	void CalcGamma (float gamma, uint8_t gammalookup[256]);
@@ -262,31 +232,6 @@ public:
 	// Releases the screenshot buffer.
 	virtual void ReleaseScreenshotBuffer();
 
-	// Text drawing functions -----------------------------------------------
-
-	// 2D Texture drawing
-	void ClearClipRect() { clipleft = cliptop = 0; clipwidth = clipheight = -1; }
-	void SetClipRect(int x, int y, int w, int h);
-	void GetClipRect(int *x, int *y, int *w, int *h);
-
-	bool SetTextureParms(DrawParms *parms, FTexture *img, double x, double y) const;
-	void DrawTexture (FTexture *img, double x, double y, int tags, ...);
-	void DrawTexture(FTexture *img, double x, double y, VMVa_List &);
-	void FillBorder (FTexture *img);	// Fills the border around a 4:3 part of the screen on non-4:3 displays
-	void VirtualToRealCoords(double &x, double &y, double &w, double &h, double vwidth, double vheight, bool vbottom=false, bool handleaspect=true) const;
-
-	// Code that uses these (i.e. SBARINFO) should probably be evaluated for using doubles all around instead.
-	void VirtualToRealCoordsInt(int &x, int &y, int &w, int &h, int vwidth, int vheight, bool vbottom=false, bool handleaspect=true) const;
-
-#ifdef DrawText
-#undef DrawText	// See WinUser.h for the definition of DrawText as a macro
-#endif
-	// 2D Text drawing
-	void DrawText(FFont *font, int normalcolor, double x, double y, const char *string, int tag_first, ...);
-	void DrawText(FFont *font, int normalcolor, double x, double y, const char *string, VMVa_List &args);
-	void DrawChar(FFont *font, int normalcolor, double x, double y, int character, int tag_first, ...);
-	void DrawChar(FFont *font, int normalcolor, double x, double y, int character, VMVa_List &args);
-
 protected:
 	uint8_t *Buffer;
 	int Width;
@@ -296,14 +241,6 @@ protected:
 	bool Bgra;
 	int clipleft = 0, cliptop = 0, clipwidth = -1, clipheight = -1;
 
-	void DrawTextCommon(FFont *font, int normalcolor, double x, double y, const char *string, DrawParms &parms);
-
-	bool ClipBox (int &left, int &top, int &width, int &height, const uint8_t *&src, const int srcpitch) const;
-	void DrawTextureV(FTexture *img, double x, double y, uint32_t tag, va_list tags) = delete;
-	virtual void DrawTextureParms(FTexture *img, DrawParms &parms);
-
-	template<class T>
-	bool ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const;
 
 	DCanvas() {}
 
@@ -362,6 +299,15 @@ public:
 class DFrameBuffer : public DSimpleCanvas
 {
 	typedef DSimpleCanvas Super;
+protected:
+	void DrawTextureV(FTexture *img, double x, double y, uint32_t tag, va_list tags) = delete;
+	virtual void DrawTextureParms(FTexture *img, DrawParms &parms);
+
+	template<class T>
+	bool ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const;
+	void DrawTextCommon(FFont *font, int normalcolor, double x, double y, const char *string, DrawParms &parms);
+
+
 public:
 	DFrameBuffer (int width, int height, bool bgra);
 
@@ -450,6 +396,63 @@ public:
 
 	uint64_t GetLastFPS() const { return LastCount; }
 
+	// 2D Texture drawing
+	void ClearClipRect() { clipleft = cliptop = 0; clipwidth = clipheight = -1; }
+	void SetClipRect(int x, int y, int w, int h);
+	void GetClipRect(int *x, int *y, int *w, int *h);
+
+	// Dim the entire canvas for the menus
+	virtual void Dim(PalEntry color = 0);
+
+	// Dim part of the canvas
+	virtual void Dim(PalEntry color, float amount, int x1, int y1, int w, int h) final;
+	virtual void DoDim(PalEntry color, float amount, int x1, int y1, int w, int h);
+
+	// Fill an area with a texture
+	virtual void FlatFill(int left, int top, int right, int bottom, FTexture *src, bool local_origin = false);
+
+	// Fill a simple polygon with a texture
+	virtual void FillSimplePoly(FTexture *tex, FVector2 *points, int npoints,
+		double originx, double originy, double scalex, double scaley, DAngle rotation,
+		const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip);
+
+	// Set an area to a specified color
+	virtual void Clear(int left, int top, int right, int bottom, int palcolor, uint32_t color) final;
+	virtual void DoClear(int left, int top, int right, int bottom, int palcolor, uint32_t color);
+
+	// Draws a line
+	virtual void DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor);
+
+	// Draws a single pixel
+	virtual void DrawPixel(int x, int y, int palcolor, uint32_t rgbcolor);
+
+	bool SetTextureParms(DrawParms *parms, FTexture *img, double x, double y) const;
+	void DrawTexture(FTexture *img, double x, double y, int tags, ...);
+	void DrawTexture(FTexture *img, double x, double y, VMVa_List &);
+	void FillBorder(FTexture *img);	// Fills the border around a 4:3 part of the screen on non-4:3 displays
+	void VirtualToRealCoords(double &x, double &y, double &w, double &h, double vwidth, double vheight, bool vbottom = false, bool handleaspect = true) const;
+
+	// Code that uses these (i.e. SBARINFO) should probably be evaluated for using doubles all around instead.
+	void VirtualToRealCoordsInt(int &x, int &y, int &w, int &h, int vwidth, int vheight, bool vbottom = false, bool handleaspect = true) const;
+
+	// Text drawing functions -----------------------------------------------
+
+#ifdef DrawText
+#undef DrawText	// See WinUser.h for the definition of DrawText as a macro
+#endif
+	// 2D Text drawing
+	void DrawText(FFont *font, int normalcolor, double x, double y, const char *string, int tag_first, ...);
+	void DrawText(FFont *font, int normalcolor, double x, double y, const char *string, VMVa_List &args);
+	void DrawChar(FFont *font, int normalcolor, double x, double y, int character, int tag_first, ...);
+	void DrawChar(FFont *font, int normalcolor, double x, double y, int character, VMVa_List &args);
+
+	void DrawFrame(int left, int top, int width, int height);
+	void DrawBorder(int x1, int y1, int x2, int y2);
+	void DrawViewBorder();
+	void DrawTopBorder();
+	void RefreshViewBorder();
+
+
 #ifdef _WIN32
 	virtual void PaletteChanged () = 0;
 	virtual int QueryNewPalette () = 0;
@@ -552,12 +555,8 @@ FString V_GetColorStringByName (const char *name, FScriptPosition *sc = nullptr)
 // Tries to get color by name, then by string
 int V_GetColor (const uint32_t *palette, const char *str, FScriptPosition *sc = nullptr);
 int V_GetColor(const uint32_t *palette, FScanner &sc);
-void V_DrawFrame (int left, int top, int width, int height);
 
 // If the view size is not full screen, draws a border around it.
-void V_DrawBorder (int x1, int y1, int x2, int y2);
-void V_RefreshViewBorder ();
-
 void V_SetBorderNeedRefresh();
 
 int CheckRatio (int width, int height, int *trueratio=NULL);