diff --git a/src/r_draw.cpp b/src/r_draw.cpp
index d7b7409739..5a314e6400 100644
--- a/src/r_draw.cpp
+++ b/src/r_draw.cpp
@@ -155,6 +155,8 @@ int				dc_color;				// [RH] Color for column filler
 DWORD			dc_srccolor;
 DWORD			*dc_srcblend;			// [RH] Source and destination
 DWORD			*dc_destblend;			// blending lookups
+fixed_t			dc_srcalpha;			// Alpha value used by dc_srcblend
+fixed_t			dc_destalpha;			// Alpha value used by dc_destblend
 
 // first pixel in a column (possibly virtual) 
 const BYTE*		dc_source;				
@@ -414,9 +416,10 @@ void R_FillAddColumn_RGBA_C()
 	dest = (uint32_t*)dc_dest;
 	int pitch = dc_pitch;
 
-	uint32_t fg_red = (dc_srccolor >> 12) & 0xf8;
-	uint32_t fg_green = (dc_srccolor >> 2) & 0xf8;
-	uint32_t fg_blue = (dc_srccolor << 3) & 0xf8;
+	uint32_t fg = shade_pal_index(dc_color, calc_light_multiplier(0));
+	uint32_t fg_red = (fg >> 24) & 0xff;
+	uint32_t fg_green = (fg >> 16) & 0xff;
+	uint32_t fg_blue = fg & 0xff;
 
 	do
 	{
@@ -478,9 +481,10 @@ void R_FillAddClampColumn_RGBA()
 	dest = (uint32_t*)dc_dest;
 	int pitch = dc_pitch;
 
-	uint32_t fg_red = (dc_srccolor >> 12) & 0xf8;
-	uint32_t fg_green = (dc_srccolor >> 2) & 0xf8;
-	uint32_t fg_blue = (dc_srccolor << 3) & 0xf8;
+	uint32_t fg = shade_pal_index(dc_color, calc_light_multiplier(0));
+	uint32_t fg_red = (fg >> 24) & 0xff;
+	uint32_t fg_green = (fg >> 16) & 0xff;
+	uint32_t fg_blue = fg & 0xff;
 
 	do
 	{
@@ -541,9 +545,10 @@ void R_FillSubClampColumn_RGBA()
 	dest = (uint32_t*)dc_dest;
 	int pitch = dc_pitch;
 
-	uint32_t fg_red = (dc_srccolor >> 12) & 0xf8;
-	uint32_t fg_green = (dc_srccolor >> 2) & 0xf8;
-	uint32_t fg_blue = (dc_srccolor << 3) & 0xf8;
+	uint32_t fg = shade_pal_index(dc_color, calc_light_multiplier(0));
+	uint32_t fg_red = (fg >> 24) & 0xff;
+	uint32_t fg_green = (fg >> 16) & 0xff;
+	uint32_t fg_blue = fg & 0xff;
 
 	do
 	{
@@ -604,9 +609,10 @@ void R_FillRevSubClampColumn_RGBA()
 	dest = (uint32_t*)dc_dest;
 	int pitch = dc_pitch;
 
-	uint32_t fg_red = (dc_srccolor >> 12) & 0xf8;
-	uint32_t fg_green = (dc_srccolor >> 2) & 0xf8;
-	uint32_t fg_blue = (dc_srccolor << 3) & 0xf8;
+	uint32_t fg = shade_pal_index(dc_color, calc_light_multiplier(0));
+	uint32_t fg_red = (fg >> 24) & 0xff;
+	uint32_t fg_green = (fg >> 16) & 0xff;
+	uint32_t fg_blue = fg & 0xff;
 
 	do
 	{
@@ -946,6 +952,9 @@ void R_DrawAddColumnP_RGBA_C()
 		int pitch = dc_pitch;
 		BYTE *colormap = dc_colormap;
 
+		uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+		uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 		do
 		{
 			uint32_t fg = shade_pal_index(colormap[source[frac >> FRACBITS]], 0);
@@ -958,9 +967,9 @@ void R_DrawAddColumnP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			dest += pitch;
@@ -1107,6 +1116,9 @@ void R_DrawTlatedAddColumnP_RGBA_C()
 		const BYTE *source = dc_source;
 		int pitch = dc_pitch;
 
+		uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+		uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 		do
 		{
 			uint32_t fg = shade_pal_index(colormap[translation[source[frac >> FRACBITS]]], light);
@@ -1119,9 +1131,9 @@ void R_DrawTlatedAddColumnP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			dest += pitch;
@@ -1276,6 +1288,9 @@ void R_DrawAddClampColumnP_RGBA_C()
 		int pitch = dc_pitch;
 		uint32_t light = calc_light_multiplier(dc_light);
 
+		uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+		uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 		do
 		{
 			uint32_t fg = shade_pal_index(colormap[source[frac >> FRACBITS]], light);
@@ -1287,9 +1302,9 @@ void R_DrawAddClampColumnP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			dest += pitch;
@@ -1363,6 +1378,9 @@ void R_DrawAddClampTranslatedColumnP_RGBA_C()
 		int pitch = dc_pitch;
 		uint32_t light = calc_light_multiplier(dc_light);
 
+		uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+		uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 		do
 		{
 			uint32_t fg = shade_pal_index(colormap[translation[source[frac >> FRACBITS]]], light);
@@ -1374,9 +1392,9 @@ void R_DrawAddClampTranslatedColumnP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			dest += pitch;
@@ -1447,6 +1465,9 @@ void R_DrawSubClampColumnP_RGBA_C()
 		int pitch = dc_pitch;
 		uint32_t light = calc_light_multiplier(dc_light);
 
+		uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+		uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 		do
 		{
 			uint32_t fg = shade_pal_index(colormap[source[frac >> FRACBITS]], light);
@@ -1458,9 +1479,9 @@ void R_DrawSubClampColumnP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(256 - fg_red + bg_red, 256, 256 + 255) - 256;
-			uint32_t green = clamp<uint32_t>(256 - fg_green + bg_green, 256, 256 + 255) - 256;
-			uint32_t blue = clamp<uint32_t>(256 - fg_blue + bg_blue, 256, 256 + 255) - 256;
+			uint32_t red = clamp<uint32_t>((0x10000 - fg_red * fg_alpha + bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t green = clamp<uint32_t>((0x10000 - fg_green * fg_alpha + bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t blue = clamp<uint32_t>((0x10000 - fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			dest += pitch;
@@ -1533,6 +1554,9 @@ void R_DrawSubClampTranslatedColumnP_RGBA_C()
 		int pitch = dc_pitch;
 		uint32_t light = calc_light_multiplier(dc_light);
 
+		uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+		uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 		do
 		{
 			uint32_t fg = shade_pal_index(colormap[translation[source[frac >> FRACBITS]]], light);
@@ -1544,9 +1568,9 @@ void R_DrawSubClampTranslatedColumnP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(256 - fg_red + bg_red, 256, 256 + 255) - 256;
-			uint32_t green = clamp<uint32_t>(256 - fg_green + bg_green, 256, 256 + 255) - 256;
-			uint32_t blue = clamp<uint32_t>(256 - fg_blue + bg_blue, 256, 256 + 255) - 256;
+			uint32_t red = clamp<uint32_t>((0x10000 - fg_red * fg_alpha + bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t green = clamp<uint32_t>((0x10000 - fg_green * fg_alpha + bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t blue = clamp<uint32_t>((0x10000 - fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			dest += pitch;
@@ -1616,6 +1640,8 @@ void R_DrawRevSubClampColumnP_RGBA_C()
 		const BYTE *source = dc_source;
 		int pitch = dc_pitch;
 		uint32_t light = calc_light_multiplier(dc_light);
+		uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+		uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
 
 		do
 		{
@@ -1628,9 +1654,9 @@ void R_DrawRevSubClampColumnP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(256 + fg_red - bg_red, 256, 256 + 255) - 256;
-			uint32_t green = clamp<uint32_t>(256 + fg_green - bg_green, 256, 256 + 255) - 256;
-			uint32_t blue = clamp<uint32_t>(256 + fg_blue - bg_blue, 256, 256 + 255) - 256;
+			uint32_t red = clamp<uint32_t>((0x10000 + fg_red * fg_alpha - bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t green = clamp<uint32_t>((0x10000 + fg_green * fg_alpha - bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t blue = clamp<uint32_t>((0x10000 + fg_blue * fg_alpha - bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			dest += pitch;
@@ -1703,6 +1729,9 @@ void R_DrawRevSubClampTranslatedColumnP_RGBA_C()
 		int pitch = dc_pitch;
 		uint32_t light = calc_light_multiplier(dc_light);
 
+		uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+		uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 		do
 		{
 			uint32_t fg = shade_pal_index(colormap[translation[source[frac >> FRACBITS]]], light);
@@ -1714,9 +1743,9 @@ void R_DrawRevSubClampTranslatedColumnP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(256 + fg_red - bg_red, 256, 256 + 255) - 256;
-			uint32_t green = clamp<uint32_t>(256 + fg_green - bg_green, 256, 256 + 255) - 256;
-			uint32_t blue = clamp<uint32_t>(256 + fg_blue - bg_blue, 256, 256 + 255) - 256;
+			uint32_t red = clamp<uint32_t>((0x10000 + fg_red * fg_alpha - bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t green = clamp<uint32_t>((0x10000 + fg_green * fg_alpha - bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t blue = clamp<uint32_t>((0x10000 + fg_blue * fg_alpha - bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			dest += pitch;
@@ -1806,8 +1835,7 @@ void R_SetSpanSource(const BYTE *pixels)
 
 void R_SetSpanColormap(BYTE *colormap)
 {
-	ds_colormap = colormap;
-	ds_light = 0;
+	R_SetDSColorMapLight(colormap, 0, 0);
 #ifdef X86_ASM
 	if (!r_swtruecolor && ds_colormap != ds_curcolormap)
 	{
@@ -2316,8 +2344,6 @@ void R_DrawSpanTranslucentP_RGBA_C()
 	const BYTE*			colormap = ds_colormap;
 	int 				count;
 	int 				spot;
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
 
 	xfrac = ds_xfrac;
 	yfrac = ds_yfrac;
@@ -2331,6 +2357,9 @@ void R_DrawSpanTranslucentP_RGBA_C()
 
 	uint32_t light = calc_light_multiplier(ds_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	if (ds_xbits == 6 && ds_ybits == 6)
 	{
 		// 64x64 is the most common case by far, so special case it.
@@ -2347,9 +2376,9 @@ void R_DrawSpanTranslucentP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = (fg_red + bg_red + 1) / 2;
-			uint32_t green = (fg_green + bg_green + 1) / 2;
-			uint32_t blue = (fg_blue + bg_blue + 1) / 2;
+			uint32_t red = (fg_red * fg_alpha + bg_red * bg_alpha) / 256;
+			uint32_t green = (fg_green * fg_alpha + bg_green * bg_alpha) / 256;
+			uint32_t blue = (fg_blue * fg_alpha + bg_blue * bg_alpha) / 256;
 
 			*dest++ = 0xff000000 | (red << 16) | (green << 8) | blue;
 
@@ -2375,9 +2404,9 @@ void R_DrawSpanTranslucentP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = (fg_red + bg_red + 1) / 2;
-			uint32_t green = (fg_green + bg_green + 1) / 2;
-			uint32_t blue = (fg_blue + bg_blue + 1) / 2;
+			uint32_t red = (fg_red * fg_alpha + bg_red * bg_alpha) / 256;
+			uint32_t green = (fg_green * fg_alpha + bg_green * bg_alpha) / 256;
+			uint32_t blue = (fg_blue * fg_alpha + bg_blue * bg_alpha) / 256;
 
 			*dest++ = 0xff000000 | (red << 16) | (green << 8) | blue;
 
@@ -2474,11 +2503,12 @@ void R_DrawSpanMaskedTranslucentP_RGBA_C()
 	const BYTE*			colormap = ds_colormap;
 	int 				count;
 	int 				spot;
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
 
 	uint32_t light = calc_light_multiplier(ds_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	xfrac = ds_xfrac;
 	yfrac = ds_yfrac;
 
@@ -2509,9 +2539,9 @@ void R_DrawSpanMaskedTranslucentP_RGBA_C()
 				uint32_t bg_green = (*dest >> 8) & 0xff;
 				uint32_t bg_blue = (*dest) & 0xff;
 
-				uint32_t red = (fg_red + bg_red + 1) / 2;
-				uint32_t green = (fg_green + bg_green + 1) / 2;
-				uint32_t blue = (fg_blue + bg_blue + 1) / 2;
+				uint32_t red = (fg_red * fg_alpha + bg_red * bg_alpha) / 256;
+				uint32_t green = (fg_green * fg_alpha + bg_green * bg_alpha) / 256;
+				uint32_t blue = (fg_blue * fg_alpha + bg_blue * bg_alpha) / 256;
 
 				*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			}
@@ -2542,9 +2572,9 @@ void R_DrawSpanMaskedTranslucentP_RGBA_C()
 				uint32_t bg_green = (*dest >> 8) & 0xff;
 				uint32_t bg_blue = (*dest) & 0xff;
 
-				uint32_t red = (fg_red + bg_red + 1) / 2;
-				uint32_t green = (fg_green + bg_green + 1) / 2;
-				uint32_t blue = (fg_blue + bg_blue + 1) / 2;
+				uint32_t red = (fg_red * fg_alpha + bg_red * bg_alpha) / 256;
+				uint32_t green = (fg_green * fg_alpha + bg_green * bg_alpha) / 256;
+				uint32_t blue = (fg_blue * fg_alpha + bg_blue * bg_alpha) / 256;
 
 				*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			}
@@ -2636,11 +2666,12 @@ void R_DrawSpanAddClampP_RGBA_C()
 	const BYTE*			colormap = ds_colormap;
 	int 				count;
 	int 				spot;
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
 
 	uint32_t light = calc_light_multiplier(ds_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	xfrac = ds_xfrac;
 	yfrac = ds_yfrac;
 
@@ -2667,9 +2698,9 @@ void R_DrawSpanAddClampP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			*dest++ = 0xff000000 | (red << 16) | (green << 8) | blue;
 
@@ -2695,9 +2726,9 @@ void R_DrawSpanAddClampP_RGBA_C()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			*dest++ = 0xff000000 | (red << 16) | (green << 8) | blue;
 
@@ -2800,11 +2831,12 @@ void R_DrawSpanMaskedAddClampP_RGBA_C()
 	const BYTE*			colormap = ds_colormap;
 	int 				count;
 	int 				spot;
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
 
 	uint32_t light = calc_light_multiplier(ds_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	xfrac = ds_xfrac;
 	yfrac = ds_yfrac;
 
@@ -2835,9 +2867,9 @@ void R_DrawSpanMaskedAddClampP_RGBA_C()
 				uint32_t bg_green = (*dest >> 8) & 0xff;
 				uint32_t bg_blue = (*dest) & 0xff;
 
-				uint32_t red = (fg_red + bg_red + 1) / 2;
-				uint32_t green = (fg_green + bg_green + 1) / 2;
-				uint32_t blue = (fg_blue + bg_blue + 1) / 2;
+				uint32_t red = (fg_red * fg_alpha + bg_red * bg_alpha) / 256;
+				uint32_t green = (fg_green * fg_alpha + bg_green * bg_alpha) / 256;
+				uint32_t blue = (fg_blue * fg_alpha + bg_blue * bg_alpha) / 256;
 
 				*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			}
@@ -2868,9 +2900,9 @@ void R_DrawSpanMaskedAddClampP_RGBA_C()
 				uint32_t bg_green = (*dest >> 8) & 0xff;
 				uint32_t bg_blue = (*dest) & 0xff;
 
-				uint32_t red = (fg_red + bg_red + 1) / 2;
-				uint32_t green = (fg_green + bg_green + 1) / 2;
-				uint32_t blue = (fg_blue + bg_blue + 1) / 2;
+				uint32_t red = (fg_red * fg_alpha + bg_red * bg_alpha) / 256;
+				uint32_t green = (fg_green * fg_alpha + bg_green * bg_alpha) / 256;
+				uint32_t blue = (fg_blue * fg_alpha + bg_blue * bg_alpha) / 256;
 
 				*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 			}
@@ -3468,8 +3500,7 @@ void R_DrawFogBoundary_C (int x1, int x2, short *uclip, short *dclip)
 		clearbufshort (spanend+t2, b2-t2, x);
 	}
 
-	dc_colormap = basecolormapdata + (rcolormap << COLORMAPSHIFT);
-	dc_light = 0;
+	R_SetColorMapLight(basecolormapdata, (float)light, wallshade);
 
 	for (--x; x >= x1; --x)
 	{
@@ -3494,8 +3525,7 @@ void R_DrawFogBoundary_C (int x1, int x2, short *uclip, short *dclip)
 				clearbufshort (spanend+t2, b2-t2, x);
 			}
 			rcolormap = lcolormap;
-			dc_colormap = basecolormapdata + (lcolormap << COLORMAPSHIFT);
-			dc_light = 0;
+			R_SetColorMapLight(basecolormapdata, (float)light, wallshade);
 		}
 		else
 		{
@@ -3594,8 +3624,7 @@ void R_DrawFogBoundary_RGBA(int x1, int x2, short *uclip, short *dclip)
 		clearbufshort(spanend + t2, b2 - t2, x);
 	}
 
-	dc_colormap = basecolormapdata + (rcolormap << COLORMAPSHIFT);
-	dc_light = 0;
+	R_SetColorMapLight(basecolormapdata, (float)light, wallshade);
 
 	for (--x; x >= x1; --x)
 	{
@@ -3620,8 +3649,7 @@ void R_DrawFogBoundary_RGBA(int x1, int x2, short *uclip, short *dclip)
 				clearbufshort(spanend + t2, b2 - t2, x);
 			}
 			rcolormap = lcolormap;
-			dc_colormap = basecolormapdata + (lcolormap << COLORMAPSHIFT);
-			dc_light = 0;
+			R_SetColorMapLight(basecolormapdata, (float)light, wallshade);
 		}
 		else
 		{
@@ -3717,11 +3745,11 @@ fixed_t tmvline1_add_RGBA()
 	int bits = tmvlinebits;
 	int pitch = dc_pitch;
 
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
-
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do
 	{
 		BYTE pix = source[frac >> bits];
@@ -3736,9 +3764,9 @@ fixed_t tmvline1_add_RGBA()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
@@ -3794,6 +3822,9 @@ void tmvline4_add_RGBA()
 	light[2] = calc_light_multiplier(palookuplight[2]);
 	light[3] = calc_light_multiplier(palookuplight[3]);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do
 	{
 		for (int i = 0; i < 4; ++i)
@@ -3810,9 +3841,9 @@ void tmvline4_add_RGBA()
 				uint32_t bg_green = (*dest >> 8) & 0xff;
 				uint32_t bg_blue = (*dest) & 0xff;
 
-				uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-				uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-				uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+				uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+				uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+				uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
 			}
@@ -3871,11 +3902,11 @@ fixed_t tmvline1_addclamp_RGBA()
 	int bits = tmvlinebits;
 	int pitch = dc_pitch;
 
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
-
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do
 	{
 		BYTE pix = source[frac >> bits];
@@ -3890,9 +3921,9 @@ fixed_t tmvline1_addclamp_RGBA()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
@@ -3947,6 +3978,9 @@ void tmvline4_addclamp_RGBA()
 	light[2] = calc_light_multiplier(palookuplight[2]);
 	light[3] = calc_light_multiplier(palookuplight[3]);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do
 	{
 		for (int i = 0; i < 4; ++i)
@@ -3963,9 +3997,9 @@ void tmvline4_addclamp_RGBA()
 				uint32_t bg_green = (dest[i] >> 8) & 0xff;
 				uint32_t bg_blue = (dest[i]) & 0xff;
 
-				uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-				uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-				uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+				uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+				uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+				uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
 			}
@@ -4023,6 +4057,9 @@ fixed_t tmvline1_subclamp_RGBA()
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do
 	{
 		BYTE pix = source[frac >> bits];
@@ -4037,9 +4074,9 @@ fixed_t tmvline1_subclamp_RGBA()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(256 - fg_red + bg_red, 256, 256 + 255) - 256;
-			uint32_t green = clamp<uint32_t>(256 - fg_green + bg_green, 256, 256 + 255) - 256;
-			uint32_t blue = clamp<uint32_t>(256 - fg_blue + bg_blue, 256, 256 + 255) - 256;
+			uint32_t red = clamp<uint32_t>((0x10000 - fg_red * fg_alpha + bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t green = clamp<uint32_t>((0x10000 - fg_green * fg_alpha + bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t blue = clamp<uint32_t>((0x10000 - fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
@@ -4093,6 +4130,9 @@ void tmvline4_subclamp_RGBA()
 	light[2] = calc_light_multiplier(palookuplight[2]);
 	light[3] = calc_light_multiplier(palookuplight[3]);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do
 	{
 		for (int i = 0; i < 4; ++i)
@@ -4109,9 +4149,9 @@ void tmvline4_subclamp_RGBA()
 				uint32_t bg_green = (dest[i] >> 8) & 0xff;
 				uint32_t bg_blue = (dest[i]) & 0xff;
 
-				uint32_t red = clamp<uint32_t>(256 - fg_red + bg_red, 256, 256 + 255) - 256;
-				uint32_t green = clamp<uint32_t>(256 - fg_green + bg_green, 256, 256 + 255) - 256;
-				uint32_t blue = clamp<uint32_t>(256 - fg_blue + bg_blue, 256, 256 + 255) - 256;
+				uint32_t red = clamp<uint32_t>((0x10000 - fg_red * fg_alpha + bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+				uint32_t green = clamp<uint32_t>((0x10000 - fg_green * fg_alpha + bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+				uint32_t blue = clamp<uint32_t>((0x10000 - fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
 			}
@@ -4169,6 +4209,9 @@ fixed_t tmvline1_revsubclamp_RGBA()
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do
 	{
 		BYTE pix = source[frac >> bits];
@@ -4183,9 +4226,9 @@ fixed_t tmvline1_revsubclamp_RGBA()
 			uint32_t bg_green = (*dest >> 8) & 0xff;
 			uint32_t bg_blue = (*dest) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(256 + fg_red - bg_red, 256, 256 + 255) - 256;
-			uint32_t green = clamp<uint32_t>(256 + fg_green - bg_green, 256, 256 + 255) - 256;
-			uint32_t blue = clamp<uint32_t>(256 + fg_blue - bg_blue, 256, 256 + 255) - 256;
+			uint32_t red = clamp<uint32_t>((0x10000 + fg_red * fg_alpha - bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t green = clamp<uint32_t>((0x10000 + fg_green * fg_alpha - bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t blue = clamp<uint32_t>((0x10000 + fg_blue * fg_alpha - bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 			*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
@@ -4233,15 +4276,15 @@ void tmvline4_revsubclamp_RGBA()
 	int count = dc_count;
 	int bits = tmvlinebits;
 
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
-
 	uint32_t light[4];
 	light[0] = calc_light_multiplier(palookuplight[0]);
 	light[1] = calc_light_multiplier(palookuplight[1]);
 	light[2] = calc_light_multiplier(palookuplight[2]);
 	light[3] = calc_light_multiplier(palookuplight[3]);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do
 	{
 		for (int i = 0; i < 4; ++i)
@@ -4258,9 +4301,9 @@ void tmvline4_revsubclamp_RGBA()
 				uint32_t bg_green = (dest[i] >> 8) & 0xff;
 				uint32_t bg_blue = (dest[i]) & 0xff;
 
-				uint32_t red = clamp<uint32_t>(256 + fg_red - bg_red, 256, 256 + 255) - 256;
-				uint32_t green = clamp<uint32_t>(256 + fg_green - bg_green, 256, 256 + 255) - 256;
-				uint32_t blue = clamp<uint32_t>(256 + fg_blue - bg_blue, 256, 256 + 255) - 256;
+				uint32_t red = clamp<uint32_t>((0x10000 + fg_red * fg_alpha - bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+				uint32_t green = clamp<uint32_t>((0x10000 + fg_green * fg_alpha - bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+				uint32_t blue = clamp<uint32_t>((0x10000 + fg_blue * fg_alpha - bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 				dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
 			}
@@ -4558,16 +4601,22 @@ static bool R_SetBlendFunc (int op, fixed_t fglevel, fixed_t bglevel, int flags)
 	{
 		dc_srcblend = Col2RGB8_Inverse[fglevel>>10];
 		dc_destblend = Col2RGB8_LessPrecision[bglevel>>10];
+		dc_srcalpha = fglevel;
+		dc_destalpha = bglevel;
 	}
 	else if (op == STYLEOP_Add && fglevel + bglevel <= FRACUNIT)
 	{
 		dc_srcblend = Col2RGB8[fglevel>>10];
 		dc_destblend = Col2RGB8[bglevel>>10];
+		dc_srcalpha = fglevel;
+		dc_destalpha = bglevel;
 	}
 	else
 	{
 		dc_srcblend = Col2RGB8_LessPrecision[fglevel>>10];
 		dc_destblend = Col2RGB8_LessPrecision[bglevel>>10];
+		dc_srcalpha = fglevel;
+		dc_destalpha = bglevel;
 	}
 	switch (op)
 	{
@@ -4736,12 +4785,15 @@ ESPSResult R_SetPatchStyle (FRenderStyle style, fixed_t alpha, int translation,
 		hcolfunc_post1 = rt_shaded1col;
 		hcolfunc_post4 = rt_shaded4cols;
 		dc_color = fixedcolormap ? fixedcolormap[APART(color)] : basecolormap->Maps[APART(color)];
-		dc_colormap = (basecolormap = &ShadeFakeColormap[16-alpha])->Maps;
+		lighttable_t *colormap = (basecolormap = &ShadeFakeColormap[16-alpha])->Maps;
 		if (fixedlightlev >= 0 && fixedcolormap == NULL)
 		{
-			dc_colormap += fixedlightlev;
+			R_SetColorMapLight(colormap, 0, FIXEDLIGHT2SHADE(fixedlightlev));
+		}
+		else
+		{
+			R_SetColorMapLight(colormap, 0, 0);
 		}
-		dc_light = 0;
 		return r_columnmethod ? DoDraw1 : DoDraw0;
 	}
 
@@ -4766,8 +4818,7 @@ ESPSResult R_SetPatchStyle (FRenderStyle style, fixed_t alpha, int translation,
 		// with the alpha.
 		dc_srccolor = ((((r*x)>>4)<<20) | ((g*x)>>4) | ((((b)*x)>>4)<<10)) & 0x3feffbff;
 		hcolfunc_pre = R_FillColumnHoriz;
-		dc_colormap = identitymap;
-		dc_light = 0;
+		R_SetColorMapLight(identitymap, 0, 0);
 	}
 
 	if (!R_SetBlendFunc (style.BlendOp, fglevel, bglevel, style.Flags))
diff --git a/src/r_draw.h b/src/r_draw.h
index d5007c885c..f60b2299eb 100644
--- a/src/r_draw.h
+++ b/src/r_draw.h
@@ -41,6 +41,8 @@ extern "C" int			dc_color;		// [RH] For flat colors (no texturing)
 extern "C" DWORD		dc_srccolor;
 extern "C" DWORD		*dc_srcblend;
 extern "C" DWORD		*dc_destblend;
+extern "C" fixed_t		dc_srcalpha;
+extern "C" fixed_t		dc_destalpha;
 
 // first pixel in a column
 extern "C" const BYTE*	dc_source;
diff --git a/src/r_drawt_rgba.cpp b/src/r_drawt_rgba.cpp
index 872cb4b89e..1725b80e4d 100644
--- a/src/r_drawt_rgba.cpp
+++ b/src/r_drawt_rgba.cpp
@@ -308,6 +308,9 @@ void rt_add1col_RGBA_c (int hx, int sx, int yl, int yh)
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do {
 		uint32_t fg = shade_pal_index(colormap[*source], light);
 		uint32_t fg_red = (fg >> 16) & 0xff;
@@ -318,9 +321,9 @@ void rt_add1col_RGBA_c (int hx, int sx, int yl, int yh)
 		uint32_t bg_green = (*dest >> 8) & 0xff;
 		uint32_t bg_blue = (*dest) & 0xff;
 
-		uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-		uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-		uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+		uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+		uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+		uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 		*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 
@@ -350,6 +353,9 @@ void rt_add4cols_RGBA_c (int sx, int yl, int yh)
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do {
 		for (int i = 0; i < 4; i++)
 		{
@@ -362,9 +368,9 @@ void rt_add4cols_RGBA_c (int sx, int yl, int yh)
 			uint32_t bg_green = (dest[i] >> 8) & 0xff;
 			uint32_t bg_blue = (dest[i]) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
@@ -496,6 +502,9 @@ void rt_addclamp1col_RGBA_c (int hx, int sx, int yl, int yh)
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do {
 		uint32_t fg = shade_pal_index(colormap[*source], light);
 		uint32_t fg_red = (fg >> 16) & 0xff;
@@ -506,9 +515,9 @@ void rt_addclamp1col_RGBA_c (int hx, int sx, int yl, int yh)
 		uint32_t bg_green = (*dest >> 8) & 0xff;
 		uint32_t bg_blue = (*dest) & 0xff;
 
-		uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-		uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-		uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+		uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+		uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+		uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 		*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 		source += 4;
@@ -537,6 +546,9 @@ void rt_addclamp4cols_RGBA_c (int sx, int yl, int yh)
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do {
 		for (int i = 0; i < 4; i++)
 		{
@@ -549,9 +561,9 @@ void rt_addclamp4cols_RGBA_c (int sx, int yl, int yh)
 			uint32_t bg_green = (dest[i] >> 8) & 0xff;
 			uint32_t bg_blue = (dest[i]) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(fg_red + bg_red, 0, 255);
-			uint32_t green = clamp<uint32_t>(fg_green + bg_green, 0, 255);
-			uint32_t blue = clamp<uint32_t>(fg_blue + bg_blue, 0, 255);
+			uint32_t red = clamp<uint32_t>((fg_red * fg_alpha + bg_red * bg_alpha) / 256, 0, 255);
+			uint32_t green = clamp<uint32_t>((fg_green * fg_alpha + bg_green * bg_alpha) / 256, 0, 255);
+			uint32_t blue = clamp<uint32_t>((fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 0, 255);
 
 			dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
@@ -595,6 +607,9 @@ void rt_subclamp1col_RGBA_c (int hx, int sx, int yl, int yh)
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do {
 		uint32_t fg = shade_pal_index(colormap[*source], light);
 		uint32_t fg_red = (fg >> 16) & 0xff;
@@ -605,9 +620,9 @@ void rt_subclamp1col_RGBA_c (int hx, int sx, int yl, int yh)
 		uint32_t bg_green = (*dest >> 8) & 0xff;
 		uint32_t bg_blue = (*dest) & 0xff;
 
-		uint32_t red = clamp<uint32_t>(256 - fg_red + bg_red, 256, 256 + 255) - 256;
-		uint32_t green = clamp<uint32_t>(256 - fg_green + bg_green, 256, 256 + 255) - 256;
-		uint32_t blue = clamp<uint32_t>(256 - fg_blue + bg_blue, 256, 256 + 255) - 256;
+		uint32_t red = clamp<uint32_t>((0x10000 - fg_red * fg_alpha + bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+		uint32_t green = clamp<uint32_t>((0x10000 - fg_green * fg_alpha + bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+		uint32_t blue = clamp<uint32_t>((0x10000 - fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 		*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 		source += 4;
@@ -636,6 +651,9 @@ void rt_subclamp4cols_RGBA_c (int sx, int yl, int yh)
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do {
 		for (int i = 0; i < 4; i++)
 		{
@@ -648,9 +666,9 @@ void rt_subclamp4cols_RGBA_c (int sx, int yl, int yh)
 			uint32_t bg_green = (dest[i] >> 8) & 0xff;
 			uint32_t bg_blue = (dest[i]) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(256 - fg_red + bg_red, 256, 256 + 255) - 256;
-			uint32_t green = clamp<uint32_t>(256 - fg_green + bg_green, 256, 256 + 255) - 256;
-			uint32_t blue = clamp<uint32_t>(256 - fg_blue + bg_blue, 256, 256 + 255) - 256;
+			uint32_t red = clamp<uint32_t>((0x10000 - fg_red * fg_alpha + bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t green = clamp<uint32_t>((0x10000 - fg_green * fg_alpha + bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t blue = clamp<uint32_t>((0x10000 - fg_blue * fg_alpha + bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 			dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
@@ -688,8 +706,6 @@ void rt_revsubclamp1col_RGBA_c (int hx, int sx, int yl, int yh)
 		return;
 	count++;
 
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
 	dest = ylookup[yl] + sx + (uint32_t*)dc_destorg;
 	source = &dc_temp_rgba[yl*4 + hx];
 	pitch = dc_pitch;
@@ -697,6 +713,9 @@ void rt_revsubclamp1col_RGBA_c (int hx, int sx, int yl, int yh)
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do {
 		uint32_t fg = shade_pal_index(colormap[*source], light);
 		uint32_t fg_red = (fg >> 16) & 0xff;
@@ -707,9 +726,9 @@ void rt_revsubclamp1col_RGBA_c (int hx, int sx, int yl, int yh)
 		uint32_t bg_green = (*dest >> 8) & 0xff;
 		uint32_t bg_blue = (*dest) & 0xff;
 
-		uint32_t red = clamp<uint32_t>(256 + fg_red - bg_red, 256, 256 + 255) - 256;
-		uint32_t green = clamp<uint32_t>(256 + fg_green - bg_green, 256, 256 + 255) - 256;
-		uint32_t blue = clamp<uint32_t>(256 + fg_blue - bg_blue, 256, 256 + 255) - 256;
+		uint32_t red = clamp<uint32_t>((0x10000 + fg_red * fg_alpha - bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+		uint32_t green = clamp<uint32_t>((0x10000 + fg_green * fg_alpha - bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+		uint32_t blue = clamp<uint32_t>((0x10000 + fg_blue * fg_alpha - bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 		*dest = 0xff000000 | (red << 16) | (green << 8) | blue;
 		source += 4;
@@ -731,8 +750,6 @@ void rt_revsubclamp4cols_RGBA_c (int sx, int yl, int yh)
 		return;
 	count++;
 
-	DWORD *fg2rgb = dc_srcblend;
-	DWORD *bg2rgb = dc_destblend;
 	dest = ylookup[yl] + sx + (uint32_t*)dc_destorg;
 	source = &dc_temp_rgba[yl*4];
 	pitch = dc_pitch;
@@ -740,6 +757,9 @@ void rt_revsubclamp4cols_RGBA_c (int sx, int yl, int yh)
 
 	uint32_t light = calc_light_multiplier(dc_light);
 
+	uint32_t fg_alpha = dc_srcalpha >> (FRACBITS - 8);
+	uint32_t bg_alpha = dc_destalpha >> (FRACBITS - 8);
+
 	do {
 		for (int i = 0; i < 4; i++)
 		{
@@ -752,9 +772,9 @@ void rt_revsubclamp4cols_RGBA_c (int sx, int yl, int yh)
 			uint32_t bg_green = (dest[i] >> 8) & 0xff;
 			uint32_t bg_blue = (dest[i]) & 0xff;
 
-			uint32_t red = clamp<uint32_t>(256 + fg_red - bg_red, 256, 256 + 255) - 256;
-			uint32_t green = clamp<uint32_t>(256 + fg_green - bg_green, 256, 256 + 255) - 256;
-			uint32_t blue = clamp<uint32_t>(256 + fg_blue - bg_blue, 256, 256 + 255) - 256;
+			uint32_t red = clamp<uint32_t>((0x10000 + fg_red * fg_alpha - bg_red * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t green = clamp<uint32_t>((0x10000 + fg_green * fg_alpha - bg_green * bg_alpha) / 256, 256, 256 + 255) - 256;
+			uint32_t blue = clamp<uint32_t>((0x10000 + fg_blue * fg_alpha - bg_blue * bg_alpha) / 256, 256, 256 + 255) - 256;
 
 			dest[i] = 0xff000000 | (red << 16) | (green << 8) | blue;
 		}
diff --git a/src/r_main.h b/src/r_main.h
index 765635e5da..e8be3c1a30 100644
--- a/src/r_main.h
+++ b/src/r_main.h
@@ -82,15 +82,18 @@ extern bool				r_dontmaplines;
 // Change R_CalcTiltedLighting() when this changes.
 #define GETPALOOKUP(vis,shade)	(clamp<int> (((shade)-FLOAT2FIXED(MIN(MAXLIGHTVIS,double(vis))))>>FRACBITS, 0, NUMCOLORMAPS-1))
 
-// Calculate the light multiplier for ds_light
-// This is used instead of GETPALOOKUP when ds_colormap+dc_colormap is set to the base colormap
-#define LIGHTSCALE(vis,shade) ((shade)-FLOAT2FIXED(MIN(MAXLIGHTVIS,double(vis))))
+// Calculate the light multiplier for dc_light/ds_light
+// This is used instead of GETPALOOKUP when ds_colormap/dc_colormap is set to the base colormap
+// Returns a value between 0 and 1 in fixed point
+#define LIGHTSCALE(vis,shade) FLOAT2FIXED(clamp((FIXED2DBL(shade) - (MIN(MAXLIGHTVIS,double(vis)))) / NUMCOLORMAPS, 0.0, (NUMCOLORMAPS-1)/(double)NUMCOLORMAPS))
+
+// Converts fixedlightlev into a shade value
+#define FIXEDLIGHT2SHADE(lightlev) (((lightlev) >> COLORMAPSHIFT) << FRACBITS)
 
 // calculates the light constant passed to the shade_pal_index function
 inline uint32_t calc_light_multiplier(dsfixed_t light)
 {
-	// the 0.70 multiplier shouldn't be needed - maybe the palette shades in doom weren't linear?
-	return (uint32_t)clamp((1.0 - FIXED2DBL(light) / MAXLIGHTVIS * 0.70) * 256 + 0.5, 0.0, 256.0);
+	return 256 - (light >> (FRACBITS - 8));
 }
 
 // Calculates a ARGB8 color for the given palette index and light multiplier
diff --git a/src/r_plane.cpp b/src/r_plane.cpp
index 40e14c0200..9805ab2006 100644
--- a/src/r_plane.cpp
+++ b/src/r_plane.cpp
@@ -391,8 +391,7 @@ void R_MapTiltedPlane_C (int y, int x1)
 
 		u = SQWORD(uz*z) + pviewx;
 		v = SQWORD(vz*z) + pviewy;
-		ds_colormap = tiltlighting[i];
-		ds_light = 0;
+		R_SetDSColorMapLight(tiltlighting[i], 0, 0);
 		fb[i++] = ds_colormap[ds_source[(v >> vshift) | ((u >> ushift) & umask)]];
 		iz += plane_sz[0];
 		uz += plane_su[0];
@@ -515,8 +514,7 @@ void R_MapTiltedPlane_RGBA (int y, int x1)
 
 		u = SQWORD(uz*z) + pviewx;
 		v = SQWORD(vz*z) + pviewy;
-		ds_colormap = tiltlighting[i];
-		ds_light = 0;
+		R_SetDSColorMapLight(tiltlighting[i], 0, 0);
 		fb[i++] = ds_colormap[ds_source[(v >> vshift) | ((u >> ushift) & umask)]];
 		iz += plane_sz[0];
 		uz += plane_su[0];
@@ -1595,14 +1593,13 @@ void R_DrawSkyPlane (visplane_t *pl)
 	bool fakefixed = false;
 	if (fixedcolormap)
 	{
-		dc_colormap = fixedcolormap;
-		dc_light = 0;
+		R_SetColorMapLight(fixedcolormap, 0, 0);
 	}
 	else
 	{
 		fakefixed = true;
-		fixedcolormap = dc_colormap = NormalLight.Maps;
-		dc_light = 0;
+		fixedcolormap = NormalLight.Maps;
+		R_SetColorMapLight(fixedcolormap, 0, 0);
 	}
 
 	R_DrawSky (pl);
@@ -1685,11 +1682,19 @@ void R_DrawNormalPlane (visplane_t *pl, double _xscale, double _yscale, fixed_t
 	GlobVis = r_FloorVisibility / planeheight;
 	ds_light = 0;
 	if (fixedlightlev >= 0)
-		ds_colormap = basecolormap->Maps + fixedlightlev, plane_shade = false;
+	{
+		R_SetDSColorMapLight(basecolormap->Maps, 0, FIXEDLIGHT2SHADE(fixedlightlev));
+		plane_shade = false;
+	}
 	else if (fixedcolormap)
-		ds_colormap = fixedcolormap, plane_shade = false;
+	{
+		R_SetDSColorMapLight(fixedcolormap, 0, 0);
+		plane_shade = false;
+	}
 	else
+	{
 		plane_shade = true;
+	}
 
 	if (spanfunc != R_FillSpan)
 	{
@@ -1702,12 +1707,16 @@ void R_DrawNormalPlane (visplane_t *pl, double _xscale, double _yscale, fixed_t
 					spanfunc = R_DrawSpanMaskedTranslucent;
 					dc_srcblend = Col2RGB8[alpha>>10];
 					dc_destblend = Col2RGB8[(OPAQUE-alpha)>>10];
+					dc_srcalpha = alpha;
+					dc_destalpha = OPAQUE - alpha;
 				}
 				else
 				{
 					spanfunc = R_DrawSpanMaskedAddClamp;
 					dc_srcblend = Col2RGB8_LessPrecision[alpha>>10];
 					dc_destblend = Col2RGB8_LessPrecision[FRACUNIT>>10];
+					dc_srcalpha = alpha;
+					dc_destalpha = OPAQUE - alpha;
 				}
 			}
 			else
@@ -1724,12 +1733,16 @@ void R_DrawNormalPlane (visplane_t *pl, double _xscale, double _yscale, fixed_t
 					spanfunc = R_DrawSpanTranslucent;
 					dc_srcblend = Col2RGB8[alpha>>10];
 					dc_destblend = Col2RGB8[(OPAQUE-alpha)>>10];
+					dc_srcalpha = alpha;
+					dc_destalpha = OPAQUE - alpha;
 				}
 				else
 				{
 					spanfunc = R_DrawSpanAddClamp;
 					dc_srcblend = Col2RGB8_LessPrecision[alpha>>10];
 					dc_destblend = Col2RGB8_LessPrecision[FRACUNIT>>10];
+					dc_srcalpha = alpha;
+					dc_destalpha = OPAQUE - alpha;
 				}
 			}
 			else
@@ -1846,11 +1859,20 @@ void R_DrawTiltedPlane(visplane_t *pl, double _xscale, double _yscale, fixed_t a
 
 	ds_light = 0;
 	if (fixedlightlev >= 0)
-		ds_colormap = basecolormap->Maps + fixedlightlev, plane_shade = false;
+	{
+		R_SetDSColorMapLight(basecolormap->Maps, 0, FIXEDLIGHT2SHADE(fixedlightlev));
+		plane_shade = false;
+	}
 	else if (fixedcolormap)
-		ds_colormap = fixedcolormap, plane_shade = false;
+	{
+		R_SetDSColorMapLight(fixedcolormap, 0, 0);
+		plane_shade = false;
+	}
 	else
-		ds_colormap = basecolormap->Maps, plane_shade = true;
+	{
+		R_SetDSColorMapLight(basecolormap->Maps, 0, 0);
+		plane_shade = true;
+	}
 
 	if (!plane_shade)
 	{
diff --git a/src/r_segs.cpp b/src/r_segs.cpp
index cab97adfca..43590247e8 100644
--- a/src/r_segs.cpp
+++ b/src/r_segs.cpp
@@ -177,8 +177,7 @@ static void BlastMaskedColumn (void (*blastfunc)(const BYTE *pixels, const FText
 	// calculate lighting
 	if (fixedcolormap == NULL && fixedlightlev < 0)
 	{
-		dc_colormap = basecolormap->Maps + (GETPALOOKUP (rw_light, wallshade) << COLORMAPSHIFT);
-		dc_light = 0;
+		R_SetColorMapLight(basecolormap->Maps, rw_light, wallshade);
 	}
 
 	dc_iscale = xs_Fix<16>::ToFix(MaskedSWall[dc_x] * MaskedScaleY);
@@ -314,10 +313,9 @@ void R_RenderMaskedSegRange (drawseg_t *ds, int x1, int x2)
 	rw_scalestep = ds->iscalestep;
 
 	if (fixedlightlev >= 0)
-		dc_colormap = basecolormap->Maps + fixedlightlev;
+		R_SetColorMapLight(basecolormap->Maps, 0, FIXEDLIGHT2SHADE(fixedlightlev));
 	else if (fixedcolormap != NULL)
-		dc_colormap = fixedcolormap;
-	dc_light = 0;
+		R_SetColorMapLight(fixedcolormap, 0, 0);
 
 	// find positioning
 	texheight = tex->GetScaledHeightDouble();
@@ -632,10 +630,9 @@ void R_RenderFakeWall(drawseg_t *ds, int x1, int x2, F3DFloor *rover)
 	}
 
 	if (fixedlightlev >= 0)
-		dc_colormap = basecolormap->Maps + fixedlightlev;
+		R_SetColorMapLight(basecolormap->Maps, 0, FIXEDLIGHT2SHADE(fixedlightlev));
 	else if (fixedcolormap != NULL)
-		dc_colormap = fixedcolormap;
-	dc_light = 0;
+		R_SetColorMapLight(fixedcolormap, 0, 0);
 
 	WallC.sz1 = ds->sz1;
 	WallC.sz2 = ds->sz2;
@@ -1435,11 +1432,11 @@ static void wallscan_np2_ds(drawseg_t *ds, int x1, int x2, short *uwal, short *d
 	}
 }
 
-inline fixed_t mvline1 (fixed_t vince, BYTE *colormap, int count, fixed_t vplce, const BYTE *bufplce, BYTE *dest)
+inline fixed_t mvline1 (fixed_t vince, BYTE *colormap, fixed_t light, int count, fixed_t vplce, const BYTE *bufplce, BYTE *dest)
 {
 	dc_iscale = vince;
 	dc_colormap = colormap;
-	dc_light = 0;
+	dc_light = light;
 	dc_count = count;
 	dc_texturefrac = vplce;
 	dc_source = bufplce;
@@ -1508,8 +1505,7 @@ void maskwallscan (int x1, int x2, short *uwal, short *dwal, float *swal, fixed_
 
 		if (!fixed)
 		{ // calculate lighting
-			dc_colormap = basecolormapdata + (GETPALOOKUP (light, wallshade) << COLORMAPSHIFT);
-			dc_light = 0;
+			R_SetColorMapLight(basecolormapdata, light, wallshade);
 		}
 
 		dc_source = getcol (rw_pic, (lwal[x] + xoffset) >> FRACBITS);
@@ -1569,7 +1565,7 @@ void maskwallscan (int x1, int x2, short *uwal, short *dwal, float *swal, fixed_
 			{
 				if (!(bad & 1))
 				{
-					mvline1(vince[z],palookupoffse[z],y2ve[z]-y1ve[z],vplce[z],bufplce[z],(ylookup[y1ve[z]]+z)*pixelsize+pixel);
+					mvline1(vince[z],palookupoffse[z],palookuplight[z],y2ve[z]-y1ve[z],vplce[z],bufplce[z],(ylookup[y1ve[z]]+z)*pixelsize+pixel);
 				}
 				bad >>= 1;
 			}
@@ -1580,7 +1576,7 @@ void maskwallscan (int x1, int x2, short *uwal, short *dwal, float *swal, fixed_
 		{
 			if (u4 > y1ve[z])
 			{
-				vplce[z] = mvline1(vince[z],palookupoffse[z],u4-y1ve[z],vplce[z],bufplce[z],(ylookup[y1ve[z]]+z)*pixelsize+pixel);
+				vplce[z] = mvline1(vince[z],palookupoffse[z],palookuplight[z],u4-y1ve[z],vplce[z],bufplce[z],(ylookup[y1ve[z]]+z)*pixelsize+pixel);
 			}
 		}
 
@@ -1596,7 +1592,7 @@ void maskwallscan (int x1, int x2, short *uwal, short *dwal, float *swal, fixed_
 		{
 			if (y2ve[z] > d4)
 			{
-				mvline1(vince[z],palookupoffse[0],y2ve[z]-d4,vplce[z],bufplce[z],i+z*pixelsize);
+				mvline1(vince[z],palookupoffse[0],palookuplight[0],y2ve[z]-d4,vplce[z],bufplce[z],i+z*pixelsize);
 			}
 		}
 	}
@@ -1609,8 +1605,7 @@ void maskwallscan (int x1, int x2, short *uwal, short *dwal, float *swal, fixed_
 
 		if (!fixed)
 		{ // calculate lighting
-			dc_colormap = basecolormapdata + (GETPALOOKUP (light, wallshade) << COLORMAPSHIFT);
-			dc_light = 0;
+			R_SetColorMapLight(basecolormapdata, light, wallshade);
 		}
 
 		dc_source = getcol (rw_pic, (lwal[x] + xoffset) >> FRACBITS);
@@ -1844,10 +1839,9 @@ void R_RenderSegLoop ()
 	fixed_t xoffset = rw_offset;
 
 	if (fixedlightlev >= 0)
-		dc_colormap = basecolormap->Maps + fixedlightlev;
+		R_SetColorMapLight(basecolormap->Maps, 0, FIXEDLIGHT2SHADE(fixedlightlev));
 	else if (fixedcolormap != NULL)
-		dc_colormap = fixedcolormap;
-	dc_light = 0;
+		R_SetColorMapLight(fixedcolormap, 0, 0);
 
 	// clip wall to the floor and ceiling
 	for (x = x1; x < x2; ++x)
@@ -3244,14 +3238,13 @@ static void R_RenderDecal (side_t *wall, DBaseDecal *decal, drawseg_t *clipper,
 
 	rw_light = rw_lightleft + (x1 - WallC.sx1) * rw_lightstep;
 	if (fixedlightlev >= 0)
-		dc_colormap = usecolormap->Maps + fixedlightlev;
+		R_SetColorMapLight(usecolormap->Maps, 0, FIXEDLIGHT2SHADE(fixedlightlev));
 	else if (fixedcolormap != NULL)
-		dc_colormap = fixedcolormap;
+		R_SetColorMapLight(fixedcolormap, 0, 0);
 	else if (!foggy && (decal->RenderFlags & RF_FULLBRIGHT))
-		dc_colormap = usecolormap->Maps;
+		R_SetColorMapLight(usecolormap->Maps, 0, 0);
 	else
 		calclighting = true;
-	dc_light = 0;
 
 	// Draw it
 	if (decal->RenderFlags & RF_YFLIP)
diff --git a/src/r_things.cpp b/src/r_things.cpp
index f52c80376c..98557817de 100644
--- a/src/r_things.cpp
+++ b/src/r_things.cpp
@@ -408,8 +408,7 @@ void R_DrawVisSprite (vissprite_t *vis)
 	}
 
 	fixed_t centeryfrac = FLOAT2FIXED(CenterY);
-	dc_colormap = vis->Style.colormap;
-	dc_light = 0;
+	R_SetColorMapLight(vis->Style.colormap, 0, 0);
 
 	mode = R_SetPatchStyle (vis->Style.RenderStyle, vis->Style.Alpha, vis->Translation, vis->FillColor);
 
@@ -539,14 +538,13 @@ void R_DrawWallSprite(vissprite_t *spr)
 	rw_lightstep = float((GlobVis / spr->wallc.sz2 - rw_lightleft) / (spr->wallc.sx2 - spr->wallc.sx1));
 	rw_light = rw_lightleft + (x1 - spr->wallc.sx1) * rw_lightstep;
 	if (fixedlightlev >= 0)
-		dc_colormap = usecolormap->Maps + fixedlightlev;
+		R_SetColorMapLight(usecolormap->Maps, 0, FIXEDLIGHT2SHADE(fixedlightlev));
 	else if (fixedcolormap != NULL)
-		dc_colormap = fixedcolormap;
+		R_SetColorMapLight(fixedcolormap, 0, 0);
 	else if (!foggy && (spr->renderflags & RF_FULLBRIGHT))
-		dc_colormap = usecolormap->Maps;
+		R_SetColorMapLight(usecolormap->Maps, 0, 0);
 	else
 		calclighting = true;
-	dc_light = 0;
 
 	// Draw it
 	WallSpriteTile = spr->pic;
@@ -656,8 +654,7 @@ void R_DrawVisVoxel(vissprite_t *spr, int minslabz, int maxslabz, short *cliptop
 	int flags = 0;
 
 	// Do setup for blending.
-	dc_colormap = spr->Style.colormap;
-	dc_light = 0;
+	R_SetColorMapLight(spr->Style.colormap, 0, 0);
 	mode = R_SetPatchStyle(spr->Style.RenderStyle, spr->Style.Alpha, spr->Translation, spr->FillColor);
 
 	if (mode == DontDraw)
diff --git a/src/v_draw.cpp b/src/v_draw.cpp
index 57fac3cda5..ff0427b345 100644
--- a/src/v_draw.cpp
+++ b/src/v_draw.cpp
@@ -171,13 +171,11 @@ void DCanvas::DrawTextureParms(FTexture *img, DrawParms &parms)
 
 	if (translation != NULL)
 	{
-		dc_colormap = (lighttable_t *)translation;
-		dc_light = 0;
+		R_SetColorMapLight((lighttable_t *)translation, 0, 0);
 	}
 	else
 	{
-		dc_colormap = identitymap;
-		dc_light = 0;
+		R_SetColorMapLight(identitymap, 0, 0);
 	}
 
 	fixedcolormap = dc_colormap;