diff --git a/src/f_wipe.cpp b/src/f_wipe.cpp
index aa9038eeb2..1fb7c982b5 100644
--- a/src/f_wipe.cpp
+++ b/src/f_wipe.cpp
@@ -28,6 +28,9 @@
 #include "f_wipe.h"
 #include "c_cvars.h"
 #include "templates.h"
+#include "v_palette.h"
+
+EXTERN_CVAR(Bool, r_blendmethod)
 
 //
 //		SCREEN WIPE PACKAGE
@@ -280,39 +283,80 @@ bool wipe_doBurn (int ticks)
 	fromold = (BYTE *)wipe_scr_start;
 	fromnew = (BYTE *)wipe_scr_end;
 
-	for (y = 0, firey = 0; y < SCREENHEIGHT; y++, firey += ystep)
+	if (!r_blendmethod)
 	{
-		for (x = 0, firex = 0; x < SCREENWIDTH; x++, firex += xstep)
+		for (y = 0, firey = 0; y < SCREENHEIGHT; y++, firey += ystep)
 		{
-			int fglevel;
+			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;
-				DWORD *fg2rgb = Col2RGB8[fglevel];
-				DWORD *bg2rgb = Col2RGB8[bglevel];
-				DWORD fg = fg2rgb[fromnew[x]];
-				DWORD bg = bg2rgb[fromold[x]];
-				fg = (fg+bg) | 0x1f07c1f;
-				to[x] = RGB32k.All[fg & (fg>>15)];
-				done = false;
+				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;
+					DWORD *fg2rgb = Col2RGB8[fglevel];
+					DWORD *bg2rgb = Col2RGB8[bglevel];
+					DWORD fg = fg2rgb[fromnew[x]];
+					DWORD bg = bg2rgb[fromold[x]];
+					fg = (fg+bg) | 0x1f07c1f;
+					to[x] = RGB32k.All[fg & (fg>>15)];
+					done = false;
+				}
 			}
+			fromold += SCREENWIDTH;
+			fromnew += SCREENWIDTH;
+			to += SCREENPITCH;
 		}
-		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;
+
+					DWORD fg = fromnew[x];
+					DWORD 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);
 }
 
@@ -347,19 +391,41 @@ bool wipe_doFade (int ticks)
 		BYTE *fromnew = (BYTE *)wipe_scr_end;
 		BYTE *fromold = (BYTE *)wipe_scr_start;
 		BYTE *to = screen->GetBuffer();
+		const PalEntry *pal = GPalette.BaseColors;
 
-		for (y = 0; y < SCREENHEIGHT; y++)
+		if (!r_blendmethod)
 		{
-			for (x = 0; x < SCREENWIDTH; x++)
+			for (y = 0; y < SCREENHEIGHT; y++)
 			{
-				DWORD fg = fg2rgb[fromnew[x]];
-				DWORD bg = bg2rgb[fromold[x]];
-				fg = (fg+bg) | 0x1f07c1f;
-				to[x] = RGB32k.All[fg & (fg>>15)];
+				for (x = 0; x < SCREENWIDTH; x++)
+				{
+					DWORD fg = fg2rgb[fromnew[x]];
+					DWORD 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++)
+				{
+					DWORD fg = fromnew[x];
+					DWORD 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;
 			}
-			fromnew += SCREENWIDTH;
-			fromold += SCREENWIDTH;
-			to += SCREENPITCH;
 		}
 	}
 	return false;
diff --git a/src/r_draw.cpp b/src/r_draw.cpp
index dabc97ff25..14b6ec55aa 100644
--- a/src/r_draw.cpp
+++ b/src/r_draw.cpp
@@ -480,7 +480,7 @@ namespace swrenderer
 			uint32_t g = GPART(color);
 			uint32_t b = BPART(color);
 			// dc_color is used by the rt_* routines. It is indexed into dc_srcblend.
-			dc_color = RGB32k.RGB[r >> 3][g >> 3][b >> 3];
+			dc_color = RGB256k.RGB[r >> 2][g >> 2][b >> 2];
 			if (style.Flags & STYLEF_InvertSource)
 			{
 				r = 255 - r;
@@ -1662,11 +1662,4 @@ namespace swrenderer
 		}
 	}
 
-	void R_DrawParticle(vissprite_t *sprite)
-	{
-		if (r_swtruecolor)
-			R_DrawParticle_rgba(sprite);
-		else
-			R_DrawParticle_C(sprite);
-	}
 }
diff --git a/src/r_draw.h b/src/r_draw.h
index 31d7cdbc03..f0aee6f1a9 100644
--- a/src/r_draw.h
+++ b/src/r_draw.h
@@ -232,5 +232,4 @@ namespace swrenderer
 
 	void R_MapTiltedPlane(int y, int x1);
 	void R_MapColoredPlane(int y, int x1);
-	void R_DrawParticle(vissprite_t *);
 }
diff --git a/src/r_draw_pal.cpp b/src/r_draw_pal.cpp
index 2cdeba3140..37d38891ef 100644
--- a/src/r_draw_pal.cpp
+++ b/src/r_draw_pal.cpp
@@ -4,6 +4,7 @@
 **---------------------------------------------------------------------------
 ** Copyright 1998-2016 Randy Heit
 ** Copyright 2016 Magnus Norddahl
+** Copyright 2016 Rachael Alexanderson
 ** All rights reserved.
 **
 ** Redistribution and use in source and binary forms, with or without
@@ -42,6 +43,9 @@
 #include "v_video.h"
 #include "r_draw_pal.h"
 
+// [SP] r_blendmethod - false = rgb555 matching (ZDoom classic), true = rgb666 (refactored)
+CVAR(Bool, r_blendmethod, false, CVAR_GLOBALCONFIG | CVAR_ARCHIVE)
+
 /*
 	[RH] This translucency algorithm is based on DOSDoom 0.65's, but uses
 	a 32k RGB table instead of an 8k one. At least on my machine, it's
@@ -305,19 +309,39 @@ namespace swrenderer
 		fracstep *= thread->num_cores;
 		pitch *= thread->num_cores;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint8_t pix = source[frac >> bits];
-			if (pix != 0)
+			do
 			{
-				uint32_t fg = fg2rgb[colormap[pix]];
-				uint32_t bg = bg2rgb[*dest];
-				fg = (fg + bg) | 0x1f07c1f;
-				*dest = RGB32k.All[fg & (fg >> 15)];
-			}
-			frac += fracstep;
-			dest += pitch;
-		} while (--count);
+				uint8_t pix = source[frac >> bits];
+				if (pix != 0)
+				{
+					uint32_t fg = fg2rgb[colormap[pix]];
+					uint32_t bg = bg2rgb[*dest];
+					fg = (fg + bg) | 0x1f07c1f;
+					*dest = RGB32k.All[fg & (fg >> 15)];
+				}
+				frac += fracstep;
+				dest += pitch;
+			} while (--count);
+
+		}
+		else
+		{
+			do
+			{
+				uint8_t pix = source[frac >> bits];
+				if (pix != 0)
+				{
+					uint32_t r = MIN(GPalette.BaseColors[colormap[pix]].r + GPalette.BaseColors[*dest].r, 255);
+					uint32_t g = MIN(GPalette.BaseColors[colormap[pix]].g + GPalette.BaseColors[*dest].g, 255);
+					uint32_t b = MIN(GPalette.BaseColors[colormap[pix]].b + GPalette.BaseColors[*dest].b, 255);
+					*dest = RGB256k.RGB[r>>2][g>>2][b>>2];
+				}
+				frac += fracstep;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawWallAdd4PalCommand::Execute(DrawerThread *thread)
@@ -346,22 +370,44 @@ namespace swrenderer
 		}
 		pitch *= thread->num_cores;
 
-		do
+		if (!r_blendmethod)
 		{
-			for (int i = 0; i < 4; ++i)
+			do
 			{
-				uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
-				if (pix != 0)
+				for (int i = 0; i < 4; ++i)
 				{
-					uint32_t fg = fg2rgb[_colormap[i][pix]];
-					uint32_t bg = bg2rgb[dest[i]];
-					fg = (fg + bg) | 0x1f07c1f;
-					dest[i] = RGB32k.All[fg & (fg >> 15)];
+					uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
+					if (pix != 0)
+					{
+						uint32_t fg = fg2rgb[_colormap[i][pix]];
+						uint32_t bg = bg2rgb[dest[i]];
+						fg = (fg + bg) | 0x1f07c1f;
+						dest[i] = RGB32k.All[fg & (fg >> 15)];
+					}
+					dc_wall_texturefrac[i] += dc_wall_iscale[i];
 				}
-				dc_wall_texturefrac[i] += dc_wall_iscale[i];
-			}
-			dest += pitch;
-		} while (--count);
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				for (int i = 0; i < 4; ++i)
+				{
+					uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
+					if (pix != 0)
+					{
+						uint32_t r = MIN(GPalette.BaseColors[_colormap[i][pix]].r + GPalette.BaseColors[dest[i]].r, 255);
+						uint32_t g = MIN(GPalette.BaseColors[_colormap[i][pix]].g + GPalette.BaseColors[dest[i]].g, 255);
+						uint32_t b = MIN(GPalette.BaseColors[_colormap[i][pix]].b + GPalette.BaseColors[dest[i]].b, 255);
+						dest[i] = RGB256k.RGB[r>>2][g>>2][b>>2];
+					}
+					dc_wall_texturefrac[i] += dc_wall_iscale[i];
+				}
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawWallAddClamp1PalCommand::Execute(DrawerThread *thread)
@@ -387,24 +433,43 @@ namespace swrenderer
 		fracstep *= thread->num_cores;
 		pitch *= thread->num_cores;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint8_t pix = source[frac >> bits];
-			if (pix != 0)
+			do
 			{
-				uint32_t a = fg2rgb[colormap[pix]] + bg2rgb[*dest];
-				uint32_t b = a;
+				uint8_t pix = source[frac >> bits];
+				if (pix != 0)
+				{
+					uint32_t a = fg2rgb[colormap[pix]] + bg2rgb[*dest];
+					uint32_t b = a;
 
-				a |= 0x01f07c1f;
-				b &= 0x40100400;
-				a &= 0x3fffffff;
-				b = b - (b >> 5);
-				a |= b;
-				*dest = RGB32k.All[a & (a >> 15)];
-			}
-			frac += fracstep;
-			dest += pitch;
-		} while (--count);
+					a |= 0x01f07c1f;
+					b &= 0x40100400;
+					a &= 0x3fffffff;
+					b = b - (b >> 5);
+					a |= b;
+					*dest = RGB32k.All[a & (a >> 15)];
+				}
+				frac += fracstep;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				uint8_t pix = source[frac >> bits];
+				if (pix != 0)
+				{
+					uint32_t r = MIN(GPalette.BaseColors[colormap[pix]].r + GPalette.BaseColors[*dest].r, 255);
+					uint32_t g = MIN(GPalette.BaseColors[colormap[pix]].g + GPalette.BaseColors[*dest].g, 255);
+					uint32_t b = MIN(GPalette.BaseColors[colormap[pix]].b + GPalette.BaseColors[*dest].b, 255);
+					*dest = RGB256k.RGB[r>>2][g>>2][b>>2];
+				}
+				frac += fracstep;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawWallAddClamp4PalCommand::Execute(DrawerThread *thread)
@@ -440,15 +505,10 @@ namespace swrenderer
 				uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
 				if (pix != 0)
 				{
-					uint32_t a = fg2rgb[_colormap[i][pix]] + bg2rgb[dest[i]];
-					uint32_t b = a;
-
-					a |= 0x01f07c1f;
-					b &= 0x40100400;
-					a &= 0x3fffffff;
-					b = b - (b >> 5);
-					a |= b;
-					dest[i] = RGB32k.All[a & (a >> 15)];
+					uint32_t r = MIN(GPalette.BaseColors[_colormap[i][pix]].r + GPalette.BaseColors[dest[i]].r, 255);
+					uint32_t g = MIN(GPalette.BaseColors[_colormap[i][pix]].g + GPalette.BaseColors[dest[i]].g, 255);
+					uint32_t b = MIN(GPalette.BaseColors[_colormap[i][pix]].b + GPalette.BaseColors[dest[i]].b, 255);
+					dest[i] = RGB256k.RGB[r>>2][g>>2][b>>2];
 				}
 				dc_wall_texturefrac[i] += dc_wall_iscale[i];
 			}
@@ -479,23 +539,42 @@ namespace swrenderer
 		fracstep *= thread->num_cores;
 		pitch *= thread->num_cores;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint8_t pix = source[frac >> bits];
-			if (pix != 0)
+			do
 			{
-				uint32_t a = (fg2rgb[colormap[pix]] | 0x40100400) - bg2rgb[*dest];
-				uint32_t b = a;
+				uint8_t pix = source[frac >> bits];
+				if (pix != 0)
+				{
+					uint32_t a = (fg2rgb[colormap[pix]] | 0x40100400) - bg2rgb[*dest];
+					uint32_t b = a;
 
-				b &= 0x40100400;
-				b = b - (b >> 5);
-				a &= b;
-				a |= 0x01f07c1f;
-				*dest = RGB32k.All[a & (a >> 15)];
-			}
-			frac += fracstep;
-			dest += pitch;
-		} while (--count);
+					b &= 0x40100400;
+					b = b - (b >> 5);
+					a &= b;
+					a |= 0x01f07c1f;
+					*dest = RGB32k.All[a & (a >> 15)];
+				}
+				frac += fracstep;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				uint8_t pix = source[frac >> bits];
+				if (pix != 0)
+				{
+					int r = clamp(-GPalette.BaseColors[colormap[pix]].r + GPalette.BaseColors[*dest].r, 0, 255);
+					int g = clamp(-GPalette.BaseColors[colormap[pix]].g + GPalette.BaseColors[*dest].g, 0, 255);
+					int b = clamp(-GPalette.BaseColors[colormap[pix]].b + GPalette.BaseColors[*dest].b, 0, 255);
+					*dest = RGB256k.RGB[r>>2][g>>2][b>>2];
+				}
+				frac += fracstep;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawWallSubClamp4PalCommand::Execute(DrawerThread *thread)
@@ -524,26 +603,48 @@ namespace swrenderer
 		}
 		pitch *= thread->num_cores;
 
-		do
+		if (!r_blendmethod)
 		{
-			for (int i = 0; i < 4; ++i)
+			do
 			{
-				uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
-				if (pix != 0)
+				for (int i = 0; i < 4; ++i)
 				{
-					uint32_t a = (fg2rgb[_colormap[i][pix]] | 0x40100400) - bg2rgb[dest[i]];
-					uint32_t b = a;
+					uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
+					if (pix != 0)
+					{
+						uint32_t a = (fg2rgb[_colormap[i][pix]] | 0x40100400) - bg2rgb[dest[i]];
+						uint32_t b = a;
 
-					b &= 0x40100400;
-					b = b - (b >> 5);
-					a &= b;
-					a |= 0x01f07c1f;
-					dest[i] = RGB32k.All[a & (a >> 15)];
+						b &= 0x40100400;
+						b = b - (b >> 5);
+						a &= b;
+						a |= 0x01f07c1f;
+						dest[i] = RGB32k.All[a & (a >> 15)];
+					}
+					dc_wall_texturefrac[i] += dc_wall_iscale[i];
 				}
-				dc_wall_texturefrac[i] += dc_wall_iscale[i];
-			}
-			dest += pitch;
-		} while (--count);
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				for (int i = 0; i < 4; ++i)
+				{
+					uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
+					if (pix != 0)
+					{
+						int r = clamp(-GPalette.BaseColors[_colormap[i][pix]].r + GPalette.BaseColors[dest[i]].r, 0, 255);
+						int g = clamp(-GPalette.BaseColors[_colormap[i][pix]].g + GPalette.BaseColors[dest[i]].g, 0, 255);
+						int b = clamp(-GPalette.BaseColors[_colormap[i][pix]].b + GPalette.BaseColors[dest[i]].b, 0, 255);
+						dest[i] = RGB256k.RGB[r>>2][g>>2][b>>2];
+					}
+					dc_wall_texturefrac[i] += dc_wall_iscale[i];
+				}
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawWallRevSubClamp1PalCommand::Execute(DrawerThread *thread)
@@ -569,23 +670,42 @@ namespace swrenderer
 		fracstep *= thread->num_cores;
 		pitch *= thread->num_cores;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint8_t pix = source[frac >> bits];
-			if (pix != 0)
+			do
 			{
-				uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[pix]];
-				uint32_t b = a;
+				uint8_t pix = source[frac >> bits];
+				if (pix != 0)
+				{
+					uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[pix]];
+					uint32_t b = a;
 
-				b &= 0x40100400;
-				b = b - (b >> 5);
-				a &= b;
-				a |= 0x01f07c1f;
-				*dest = RGB32k.All[a & (a >> 15)];
-			}
-			frac += fracstep;
-			dest += pitch;
-		} while (--count);
+					b &= 0x40100400;
+					b = b - (b >> 5);
+					a &= b;
+					a |= 0x01f07c1f;
+					*dest = RGB32k.All[a & (a >> 15)];
+				}
+				frac += fracstep;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				uint8_t pix = source[frac >> bits];
+				if (pix != 0)
+				{
+					int r = clamp(GPalette.BaseColors[colormap[pix]].r - GPalette.BaseColors[*dest].r, 0, 255);
+					int g = clamp(GPalette.BaseColors[colormap[pix]].g - GPalette.BaseColors[*dest].g, 0, 255);
+					int b = clamp(GPalette.BaseColors[colormap[pix]].b - GPalette.BaseColors[*dest].b, 0, 255);
+					*dest = RGB256k.RGB[r>>2][g>>2][b>>2];
+				}
+				frac += fracstep;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawWallRevSubClamp4PalCommand::Execute(DrawerThread *thread)
@@ -614,26 +734,48 @@ namespace swrenderer
 		}
 		pitch *= thread->num_cores;
 
-		do
+		if (!r_blendmethod)
 		{
-			for (int i = 0; i < 4; ++i)
+			do
 			{
-				uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
-				if (pix != 0)
+				for (int i = 0; i < 4; ++i)
 				{
-					uint32_t a = (bg2rgb[dest[i]] | 0x40100400) - fg2rgb[_colormap[i][pix]];
-					uint32_t b = a;
+					uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
+					if (pix != 0)
+					{
+						uint32_t a = (bg2rgb[dest[i]] | 0x40100400) - fg2rgb[_colormap[i][pix]];
+						uint32_t b = a;
 
-					b &= 0x40100400;
-					b = b - (b >> 5);
-					a &= b;
-					a |= 0x01f07c1f;
-					dest[i] = RGB32k.All[a & (a >> 15)];
+						b &= 0x40100400;
+						b = b - (b >> 5);
+						a &= b;
+						a |= 0x01f07c1f;
+						dest[i] = RGB32k.All[a & (a >> 15)];
+					}
+					dc_wall_texturefrac[i] += dc_wall_iscale[i];
 				}
-				dc_wall_texturefrac[i] += dc_wall_iscale[i];
-			}
-			dest += _pitch;
-		} while (--count);
+				dest += _pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				for (int i = 0; i < 4; ++i)
+				{
+					uint8_t pix = _source[i][dc_wall_texturefrac[i] >> bits];
+					if (pix != 0)
+					{
+						uint32_t r = clamp(GPalette.BaseColors[_colormap[i][pix]].r - GPalette.BaseColors[dest[i]].r, 0, 255);
+						uint32_t g = clamp(GPalette.BaseColors[_colormap[i][pix]].g - GPalette.BaseColors[dest[i]].g, 0, 255);
+						uint32_t b = clamp(GPalette.BaseColors[_colormap[i][pix]].b - GPalette.BaseColors[dest[i]].b, 0, 255);
+						dest[i] = RGB256k.RGB[r>>2][g>>2][b>>2];
+					}
+					dc_wall_texturefrac[i] += dc_wall_iscale[i];
+				}
+				dest += _pitch;
+			} while (--count);
+		}
 	}
 
 	/////////////////////////////////////////////////////////////////////////
@@ -712,7 +854,7 @@ namespace swrenderer
 				c_red = (c_red * alpha_bottom + solid_bottom_r * inv_alpha_bottom) >> 8;
 				c_green = (c_green * alpha_bottom + solid_bottom_g * inv_alpha_bottom) >> 8;
 				c_blue = (c_blue * alpha_bottom + solid_bottom_b * inv_alpha_bottom) >> 8;
-				*dest = RGB32k.RGB[(c_red >> 3)][(c_green >> 3)][(c_blue >> 3)];
+				*dest = RGB256k.RGB[(c_red >> 2)][(c_green >> 2)][(c_blue >> 2)];
 			}
 
 			frac += fracstep;
@@ -740,8 +882,8 @@ namespace swrenderer
 		int solid_bottom_r = RPART(solid_bottom);
 		int solid_bottom_g = GPART(solid_bottom);
 		int solid_bottom_b = BPART(solid_bottom);
-		uint32_t solid_top_fill = RGB32k.RGB[(solid_top_r >> 3)][(solid_top_g >> 3)][(solid_top_b >> 3)];
-		uint32_t solid_bottom_fill = RGB32k.RGB[(solid_bottom_r >> 3)][(solid_bottom_g >> 3)][(solid_bottom_b >> 3)];
+		uint32_t solid_top_fill = RGB256k.RGB[(solid_top_r >> 2)][(solid_top_g >> 2)][(solid_top_b >> 2)];
+		uint32_t solid_bottom_fill = RGB256k.RGB[(solid_bottom_r >> 2)][(solid_bottom_g >> 2)][(solid_bottom_b >> 2)];
 		solid_top_fill = (solid_top_fill << 24) | (solid_top_fill << 16) | (solid_top_fill << 8) | solid_top_fill;
 		solid_bottom_fill = (solid_bottom_fill << 24) | (solid_bottom_fill << 16) | (solid_bottom_fill << 8) | solid_bottom_fill;
 
@@ -801,8 +943,7 @@ namespace swrenderer
 				c_red = (c_red * alpha_top + solid_top_r * inv_alpha_top) >> 8;
 				c_green = (c_green * alpha_top + solid_top_g * inv_alpha_top) >> 8;
 				c_blue = (c_blue * alpha_top + solid_top_b * inv_alpha_top) >> 8;
-				output[col] = RGB32k.RGB[(c_red >> 3)][(c_green >> 3)][(c_blue >> 3)];
-
+				output[col] = RGB256k.RGB[(c_red >> 2)][(c_green >> 2)][(c_blue >> 2)];
 				frac[col] += fracstep[col];
 			}
 			*((uint32_t*)dest) = *((uint32_t*)output);
@@ -843,7 +984,7 @@ namespace swrenderer
 				c_red = (c_red * alpha_bottom + solid_bottom_r * inv_alpha_bottom) >> 8;
 				c_green = (c_green * alpha_bottom + solid_bottom_g * inv_alpha_bottom) >> 8;
 				c_blue = (c_blue * alpha_bottom + solid_bottom_b * inv_alpha_bottom) >> 8;
-				output[col] = RGB32k.RGB[(c_red >> 3)][(c_green >> 3)][(c_blue >> 3)];
+				output[col] = RGB256k.RGB[(c_red >> 2)][(c_green >> 2)][(c_blue >> 2)];
 
 				frac[col] += fracstep[col];
 			}
@@ -925,7 +1066,7 @@ namespace swrenderer
 				c_red = (c_red * alpha_bottom + solid_bottom_r * inv_alpha_bottom) >> 8;
 				c_green = (c_green * alpha_bottom + solid_bottom_g * inv_alpha_bottom) >> 8;
 				c_blue = (c_blue * alpha_bottom + solid_bottom_b * inv_alpha_bottom) >> 8;
-				*dest = RGB32k.RGB[(c_red >> 3)][(c_green >> 3)][(c_blue >> 3)];
+				*dest = RGB256k.RGB[(c_red >> 2)][(c_green >> 2)][(c_blue >> 2)];
 			}
 
 			frac += fracstep;
@@ -955,8 +1096,8 @@ namespace swrenderer
 		int solid_bottom_r = RPART(solid_bottom);
 		int solid_bottom_g = GPART(solid_bottom);
 		int solid_bottom_b = BPART(solid_bottom);
-		uint32_t solid_top_fill = RGB32k.RGB[(solid_top_r >> 3)][(solid_top_g >> 3)][(solid_top_b >> 3)];
-		uint32_t solid_bottom_fill = RGB32k.RGB[(solid_bottom_r >> 3)][(solid_bottom_g >> 3)][(solid_bottom_b >> 3)];
+		uint32_t solid_top_fill = RGB256k.RGB[(solid_top_r >> 2)][(solid_top_g >> 2)][(solid_top_b >> 2)];
+		uint32_t solid_bottom_fill = RGB256k.RGB[(solid_bottom_r >> 2)][(solid_bottom_g >> 2)][(solid_bottom_b >> 2)];
 		solid_top_fill = (solid_top_fill << 24) | (solid_top_fill << 16) | (solid_top_fill << 8) | solid_top_fill;
 		solid_bottom_fill = (solid_bottom_fill << 24) | (solid_bottom_fill << 16) | (solid_bottom_fill << 8) | solid_bottom_fill;
 
@@ -1022,7 +1163,7 @@ namespace swrenderer
 				c_red = (c_red * alpha_top + solid_top_r * inv_alpha_top) >> 8;
 				c_green = (c_green * alpha_top + solid_top_g * inv_alpha_top) >> 8;
 				c_blue = (c_blue * alpha_top + solid_top_b * inv_alpha_top) >> 8;
-				output[col] = RGB32k.RGB[(c_red >> 3)][(c_green >> 3)][(c_blue >> 3)];
+				output[col] = RGB256k.RGB[(c_red >> 2)][(c_green >> 2)][(c_blue >> 2)];
 
 				frac[col] += fracstep[col];
 			}
@@ -1076,7 +1217,7 @@ namespace swrenderer
 				c_red = (c_red * alpha_bottom + solid_bottom_r * inv_alpha_bottom) >> 8;
 				c_green = (c_green * alpha_bottom + solid_bottom_g * inv_alpha_bottom) >> 8;
 				c_blue = (c_blue * alpha_bottom + solid_bottom_b * inv_alpha_bottom) >> 8;
-				output[col] = RGB32k.RGB[(c_red >> 3)][(c_green >> 3)][(c_blue >> 3)];
+				output[col] = RGB256k.RGB[(c_red >> 2)][(c_green >> 2)][(c_blue >> 2)];
 
 				frac[col] += fracstep[col];
 			}
@@ -1112,6 +1253,8 @@ namespace swrenderer
 		_srcblend = dc_srcblend;
 		_destblend = dc_destblend;
 		_srccolor = dc_srccolor;
+		_srcalpha = dc_srcalpha;
+		_destalpha = dc_destalpha;
 	}
 
 	void DrawColumnPalCommand::Execute(DrawerThread *thread)
@@ -1206,14 +1349,32 @@ namespace swrenderer
 		dest = thread->dest_for_thread(_dest_y, pitch, dest);
 		pitch *= thread->num_cores;
 
-		do
-		{
-			uint32_t bg;
-			bg = (fg + bg2rgb[*dest]) | 0x1f07c1f;
-			*dest = RGB32k.All[bg & (bg >> 15)];
-			dest += pitch;
-		} while (--count);
+		const PalEntry* pal = GPalette.BaseColors;
 
+		if (!r_blendmethod)
+		{
+			do
+			{
+				uint32_t bg;
+				bg = (fg + bg2rgb[*dest]) | 0x1f07c1f;
+				*dest = RGB32k.All[bg & (bg >> 15)];
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int src_r = ((_srccolor >> 16) & 0xff) * _srcalpha;
+				int src_g = ((_srccolor >> 0) & 0xff) * _srcalpha;
+				int src_b = ((_srccolor >> 8) & 0xff) * _srcalpha;
+				int r = clamp((src_r + pal[*dest].r * _destalpha)>>18, 0, 255);
+				int g = clamp((src_g + pal[*dest].g * _destalpha)>>18, 0, 255);
+				int b = clamp((src_b + pal[*dest].b * _destalpha)>>18, 0, 255);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void FillColumnAddClampPalCommand::Execute(DrawerThread *thread)
@@ -1238,19 +1399,38 @@ namespace swrenderer
 		dest = thread->dest_for_thread(_dest_y, pitch, dest);
 		pitch *= thread->num_cores;
 
-		do
-		{
-			uint32_t a = fg + bg2rgb[*dest];
-			uint32_t b = a;
+		const PalEntry* pal = GPalette.BaseColors;
 
-			a |= 0x01f07c1f;
-			b &= 0x40100400;
-			a &= 0x3fffffff;
-			b = b - (b >> 5);
-			a |= b;
-			*dest = RGB32k.All[a & (a >> 15)];
-			dest += pitch;
-		} while (--count);
+		if (!r_blendmethod)
+		{
+			do
+			{
+				uint32_t a = fg + bg2rgb[*dest];
+				uint32_t b = a;
+
+				a |= 0x01f07c1f;
+				b &= 0x40100400;
+				a &= 0x3fffffff;
+				b = b - (b >> 5);
+				a |= b;
+				*dest = RGB32k.All[a & (a >> 15)];
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int src_r = ((_srccolor >> 16) & 0xff) * _srcalpha;
+				int src_g = ((_srccolor >> 0) & 0xff) * _srcalpha;
+				int src_b = ((_srccolor >> 8) & 0xff) * _srcalpha;
+				int r = clamp((src_r + pal[*dest].r * _destalpha)>>18, 0, 255);
+				int g = clamp((src_g + pal[*dest].g * _destalpha)>>18, 0, 255);
+				int b = clamp((src_b + pal[*dest].b * _destalpha)>>18, 0, 255);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void FillColumnSubClampPalCommand::Execute(DrawerThread *thread)
@@ -1261,11 +1441,9 @@ namespace swrenderer
 		count = _count;
 
 		dest = _dest;
-		uint32_t *bg2rgb;
-		uint32_t fg;
+		uint32_t *bg2rgb = _destblend;
+		uint32_t fg = _srccolor;
 
-		bg2rgb = _destblend;
-		fg = _srccolor | 0x40100400;
 		int pitch = _pitch;
 
 		count = thread->count_for_thread(_dest_y, count);
@@ -1275,18 +1453,39 @@ namespace swrenderer
 		dest = thread->dest_for_thread(_dest_y, pitch, dest);
 		pitch *= thread->num_cores;
 
-		do
-		{
-			uint32_t a = fg - bg2rgb[*dest];
-			uint32_t b = a;
+		const PalEntry* palette = GPalette.BaseColors;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			*dest = RGB32k.All[a & (a >> 15)];
-			dest += pitch;
-		} while (--count);
+		if (!r_blendmethod)
+		{
+			do
+			{
+				uint32_t a = fg - bg2rgb[*dest];
+				uint32_t b = a;
+
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				*dest = RGB32k.All[a & (a >> 15)];
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int src_r = ((_srccolor >> 16) & 0xff) * _srcalpha;
+				int src_g = ((_srccolor >> 0) & 0xff) * _srcalpha;
+				int src_b = ((_srccolor >> 8) & 0xff) * _srcalpha;
+				int bg = *dest;
+				int r = MAX((src_r * _srcalpha - palette[bg].r * _destalpha)>>18, 0);
+				int g = MAX((src_g * _srcalpha - palette[bg].g * _destalpha)>>18, 0);
+				int b = MAX((src_b * _srcalpha - palette[bg].b * _destalpha)>>18, 0);
+
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void FillColumnRevSubClampPalCommand::Execute(DrawerThread *thread)
@@ -1299,11 +1498,9 @@ namespace swrenderer
 			return;
 
 		dest = _dest;
-		uint32_t *bg2rgb;
-		uint32_t fg;
+		uint32_t *bg2rgb = _destblend;
+		uint32_t fg = _srccolor;
 
-		bg2rgb = _destblend;
-		fg = _srccolor;
 		int pitch = _pitch;
 
 		count = thread->count_for_thread(_dest_y, count);
@@ -1313,18 +1510,39 @@ namespace swrenderer
 		dest = thread->dest_for_thread(_dest_y, pitch, dest);
 		pitch *= thread->num_cores;
 
-		do
-		{
-			uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg;
-			uint32_t b = a;
+		const PalEntry *palette = GPalette.BaseColors;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			*dest = RGB32k.All[a & (a >> 15)];
-			dest += pitch;
-		} while (--count);
+		if (!r_blendmethod)
+		{
+			do
+			{
+				uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg;
+				uint32_t b = a;
+
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				*dest = RGB32k.All[a & (a >> 15)];
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int src_r = ((_srccolor >> 16) & 0xff) * _srcalpha;
+				int src_g = ((_srccolor >> 0) & 0xff) * _srcalpha;
+				int src_b = ((_srccolor >> 8) & 0xff) * _srcalpha;
+				int bg = *dest;
+				int r = MAX((src_r * _srcalpha - palette[bg].r * _destalpha)>>18, 0);
+				int g = MAX((src_g * _srcalpha - palette[bg].g * _destalpha)>>18, 0);
+				int b = MAX((src_b * _srcalpha - palette[bg].b * _destalpha)>>18, 0);
+
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnAddPalCommand::Execute(DrawerThread *thread)
@@ -1354,19 +1572,37 @@ namespace swrenderer
 		uint32_t *bg2rgb = _destblend;
 		const uint8_t *colormap = _colormap;
 		const uint8_t *source = _source;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint32_t fg = colormap[source[frac >> FRACBITS]];
-			uint32_t bg = *dest;
+			do
+			{
+				uint32_t fg = colormap[source[frac >> FRACBITS]];
+				uint32_t bg = *dest;
 
-			fg = fg2rgb[fg];
-			bg = bg2rgb[bg];
-			fg = (fg + bg) | 0x1f07c1f;
-			*dest = RGB32k.All[fg & (fg >> 15)];
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+				fg = fg2rgb[fg];
+				bg = bg2rgb[bg];
+				fg = (fg + bg) | 0x1f07c1f;
+				*dest = RGB32k.All[fg & (fg >> 15)];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				uint32_t fg = colormap[source[frac >> FRACBITS]];
+				uint32_t bg = *dest;
+				uint32_t r = MIN((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 63);
+				uint32_t g = MIN((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 63);
+				uint32_t b = MIN((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 63);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnTranslatedPalCommand::Execute(DrawerThread *thread)
@@ -1436,18 +1672,37 @@ namespace swrenderer
 		const uint8_t *colormap = _colormap;
 		const uint8_t *source = _source;
 
-		do
-		{
-			uint32_t fg = colormap[translation[source[frac >> FRACBITS]]];
-			uint32_t bg = *dest;
+		const PalEntry *palette = GPalette.BaseColors;
 
-			fg = fg2rgb[fg];
-			bg = bg2rgb[bg];
-			fg = (fg + bg) | 0x1f07c1f;
-			*dest = RGB32k.All[fg & (fg >> 15)];
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+		if (!r_blendmethod)
+		{
+			do
+			{
+				uint32_t fg = colormap[translation[source[frac >> FRACBITS]]];
+				uint32_t bg = *dest;
+
+				fg = fg2rgb[fg];
+				bg = bg2rgb[bg];
+				fg = (fg + bg) | 0x1f07c1f;
+				*dest = RGB32k.All[fg & (fg >> 15)];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				uint32_t fg = colormap[translation[source[frac >> FRACBITS]]];
+				uint32_t bg = *dest;
+				uint32_t r = MIN((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 63);
+				uint32_t g = MIN((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 63);
+				uint32_t b = MIN((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 63);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnShadedPalCommand::Execute(DrawerThread *thread)
@@ -1475,17 +1730,36 @@ namespace swrenderer
 		const uint8_t *source = _source;
 		const uint8_t *colormap = _colormap;
 		uint32_t *fgstart = &Col2RGB8[0][_color];
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint32_t val = colormap[source[frac >> FRACBITS]];
-			uint32_t fg = fgstart[val << 8];
-			val = (Col2RGB8[64 - val][*dest] + fg) | 0x1f07c1f;
-			*dest = RGB32k.All[val & (val >> 15)];
+			do
+			{
+				uint32_t val = colormap[source[frac >> FRACBITS]];
+				uint32_t fg = fgstart[val << 8];
+				val = (Col2RGB8[64 - val][*dest] + fg) | 0x1f07c1f;
+				*dest = RGB32k.All[val & (val >> 15)];
 
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				uint32_t val = source[frac >> FRACBITS];
+
+				int r = (palette[*dest].r * (255-val) + palette[_color].r * val) >> 10;
+				int g = (palette[*dest].g * (255-val) + palette[_color].g * val) >> 10;
+				int b = (palette[*dest].b * (255-val) + palette[_color].b * val) >> 10;
+				*dest = RGB256k.RGB[clamp(r,0,63)][clamp(g,0,63)][clamp(b,0,63)];
+
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnAddClampPalCommand::Execute(DrawerThread *thread)
@@ -1515,21 +1789,39 @@ namespace swrenderer
 		const uint8_t *source = _source;
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint32_t a = fg2rgb[colormap[source[frac >> FRACBITS]]] + bg2rgb[*dest];
-			uint32_t b = a;
+			do
+			{
+				uint32_t a = fg2rgb[colormap[source[frac >> FRACBITS]]] + bg2rgb[*dest];
+				uint32_t b = a;
 
-			a |= 0x01f07c1f;
-			b &= 0x40100400;
-			a &= 0x3fffffff;
-			b = b - (b >> 5);
-			a |= b;
-			*dest = RGB32k.All[a & (a >> 15)];
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+				a |= 0x01f07c1f;
+				b &= 0x40100400;
+				a &= 0x3fffffff;
+				b = b - (b >> 5);
+				a |= b;
+				*dest = RGB32k.All[a & (a >> 15)];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int fg = colormap[source[frac >> FRACBITS]];
+				int bg = *dest;
+				int r = MIN((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 63);
+				int g = MIN((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 63);
+				int b = MIN((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 63);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnAddClampTranslatedPalCommand::Execute(DrawerThread *thread)
@@ -1560,21 +1852,39 @@ namespace swrenderer
 		const uint8_t *source = _source;
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint32_t a = fg2rgb[colormap[translation[source[frac >> FRACBITS]]]] + bg2rgb[*dest];
-			uint32_t b = a;
+			do
+			{
+				uint32_t a = fg2rgb[colormap[translation[source[frac >> FRACBITS]]]] + bg2rgb[*dest];
+				uint32_t b = a;
 
-			a |= 0x01f07c1f;
-			b &= 0x40100400;
-			a &= 0x3fffffff;
-			b = b - (b >> 5);
-			a |= b;
-			*dest = RGB32k.All[(a >> 15) & a];
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+				a |= 0x01f07c1f;
+				b &= 0x40100400;
+				a &= 0x3fffffff;
+				b = b - (b >> 5);
+				a |= b;
+				*dest = RGB32k.All[(a >> 15) & a];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int fg = colormap[translation[source[frac >> FRACBITS]]];
+				int bg = *dest;
+				int r = MIN((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 63);
+				int g = MIN((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 63);
+				int b = MIN((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 63);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnSubClampPalCommand::Execute(DrawerThread *thread)
@@ -1604,20 +1914,38 @@ namespace swrenderer
 		const uint8_t *source = _source;
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint32_t a = (fg2rgb[colormap[source[frac >> FRACBITS]]] | 0x40100400) - bg2rgb[*dest];
-			uint32_t b = a;
+			do
+			{
+				uint32_t a = (fg2rgb[colormap[source[frac >> FRACBITS]]] | 0x40100400) - bg2rgb[*dest];
+				uint32_t b = a;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			*dest = RGB32k.All[a & (a >> 15)];
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				*dest = RGB32k.All[a & (a >> 15)];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int fg = colormap[source[frac >> FRACBITS]];
+				int bg = *dest;
+				int r = MAX((palette[fg].r * _srcalpha - palette[bg].r * _destalpha)>>18, 0);
+				int g = MAX((palette[fg].g * _srcalpha - palette[bg].g * _destalpha)>>18, 0);
+				int b = MAX((palette[fg].b * _srcalpha - palette[bg].b * _destalpha)>>18, 0);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnSubClampTranslatedPalCommand::Execute(DrawerThread *thread)
@@ -1648,20 +1976,38 @@ namespace swrenderer
 		const uint8_t *source = _source;
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint32_t a = (fg2rgb[colormap[translation[source[frac >> FRACBITS]]]] | 0x40100400) - bg2rgb[*dest];
-			uint32_t b = a;
+			do
+			{
+				uint32_t a = (fg2rgb[colormap[translation[source[frac >> FRACBITS]]]] | 0x40100400) - bg2rgb[*dest];
+				uint32_t b = a;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			*dest = RGB32k.All[(a >> 15) & a];
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				*dest = RGB32k.All[(a >> 15) & a];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int fg = colormap[translation[source[frac >> FRACBITS]]];
+				int bg = *dest;
+				int r = MAX((palette[fg].r * _srcalpha - palette[bg].r * _destalpha)>>18, 0);
+				int g = MAX((palette[fg].g * _srcalpha - palette[bg].g * _destalpha)>>18, 0);
+				int b = MAX((palette[fg].b * _srcalpha - palette[bg].b * _destalpha)>>18, 0);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRevSubClampPalCommand::Execute(DrawerThread *thread)
@@ -1691,20 +2037,38 @@ namespace swrenderer
 		const uint8_t *source = _source;
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[source[frac >> FRACBITS]]];
-			uint32_t b = a;
+			do
+			{
+				uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[source[frac >> FRACBITS]]];
+				uint32_t b = a;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			*dest = RGB32k.All[a & (a >> 15)];
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				*dest = RGB32k.All[a & (a >> 15)];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int fg = colormap[source[frac >> FRACBITS]];
+				int bg = *dest;
+				int r = MAX((-palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+				int g = MAX((-palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+				int b = MAX((-palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRevSubClampTranslatedPalCommand::Execute(DrawerThread *thread)
@@ -1735,20 +2099,38 @@ namespace swrenderer
 		const uint8_t *source = _source;
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do
+		if (!r_blendmethod)
 		{
-			uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[translation[source[frac >> FRACBITS]]]];
-			uint32_t b = a;
+			do
+			{
+				uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[translation[source[frac >> FRACBITS]]]];
+				uint32_t b = a;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			*dest = RGB32k.All[(a >> 15) & a];
-			dest += pitch;
-			frac += fracstep;
-		} while (--count);
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				*dest = RGB32k.All[(a >> 15) & a];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
+		else
+		{
+			do
+			{
+				int fg = colormap[translation[source[frac >> FRACBITS]]];
+				int bg = *dest;
+				int r = MAX((-palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+				int g = MAX((-palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+				int b = MAX((-palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+				*dest = RGB256k.RGB[r][g][b];
+				dest += pitch;
+				frac += fracstep;
+			} while (--count);
+		}
 	}
 
 	/////////////////////////////////////////////////////////////////////////
@@ -1861,6 +2243,8 @@ namespace swrenderer
 		_srcblend = dc_srcblend;
 		_destblend = dc_destblend;
 		_color = ds_color;
+		_srcalpha = dc_srcalpha;
+		_destalpha = dc_destalpha;
 	}
 
 	void DrawSpanPalCommand::Execute(DrawerThread *thread)
@@ -2019,39 +2403,83 @@ namespace swrenderer
 		xstep = _xstep;
 		ystep = _ystep;
 
-		if (_xbits == 6 && _ybits == 6)
+		const PalEntry *palette = GPalette.BaseColors;
+
+		if (!r_blendmethod)
 		{
-			// 64x64 is the most common case by far, so special case it.
-			do
+			if (_xbits == 6 && _ybits == 6)
 			{
-				spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
-				uint32_t fg = colormap[source[spot]];
-				uint32_t bg = *dest;
-				fg = fg2rgb[fg];
-				bg = bg2rgb[bg];
-				fg = (fg + bg) | 0x1f07c1f;
-				*dest++ = RGB32k.All[fg & (fg >> 15)];
-				xfrac += xstep;
-				yfrac += ystep;
-			} while (--count);
+				// 64x64 is the most common case by far, so special case it.
+				do
+				{
+					spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
+					uint32_t fg = colormap[source[spot]];
+					uint32_t bg = *dest;
+					fg = fg2rgb[fg];
+					bg = bg2rgb[bg];
+					fg = (fg + bg) | 0x1f07c1f;
+					*dest++ = RGB32k.All[fg & (fg >> 15)];
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
+			else
+			{
+				uint8_t yshift = 32 - _ybits;
+				uint8_t xshift = yshift - _xbits;
+				int xmask = ((1 << _xbits) - 1) << _ybits;
+				do
+				{
+					spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
+					uint32_t fg = colormap[source[spot]];
+					uint32_t bg = *dest;
+					fg = fg2rgb[fg];
+					bg = bg2rgb[bg];
+					fg = (fg + bg) | 0x1f07c1f;
+					*dest++ = RGB32k.All[fg & (fg >> 15)];
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
 		}
 		else
 		{
-			uint8_t yshift = 32 - _ybits;
-			uint8_t xshift = yshift - _xbits;
-			int xmask = ((1 << _xbits) - 1) << _ybits;
-			do
+			if (_xbits == 6 && _ybits == 6)
 			{
-				spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
-				uint32_t fg = colormap[source[spot]];
-				uint32_t bg = *dest;
-				fg = fg2rgb[fg];
-				bg = bg2rgb[bg];
-				fg = (fg + bg) | 0x1f07c1f;
-				*dest++ = RGB32k.All[fg & (fg >> 15)];
-				xfrac += xstep;
-				yfrac += ystep;
-			} while (--count);
+				// 64x64 is the most common case by far, so special case it.
+				do
+				{
+					spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
+					uint32_t fg = colormap[source[spot]];
+					uint32_t bg = *dest;
+					int r = MAX((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+					int g = MAX((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+					int b = MAX((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+					*dest++ = RGB256k.RGB[r][g][b];
+
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
+			else
+			{
+				uint8_t yshift = 32 - _ybits;
+				uint8_t xshift = yshift - _xbits;
+				int xmask = ((1 << _xbits) - 1) << _ybits;
+				do
+				{
+					spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
+					uint32_t fg = colormap[source[spot]];
+					uint32_t bg = *dest;
+					int r = MAX((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+					int g = MAX((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+					int b = MAX((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+					*dest++ = RGB256k.RGB[r][g][b];
+
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
 		}
 	}
 
@@ -2072,6 +2500,8 @@ namespace swrenderer
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
 
+		const PalEntry *palette = GPalette.BaseColors;
+
 		xfrac = _xfrac;
 		yfrac = _yfrac;
 
@@ -2082,53 +2512,107 @@ namespace swrenderer
 		xstep = _xstep;
 		ystep = _ystep;
 
-		if (_xbits == 6 && _ybits == 6)
+		if (!r_blendmethod)
 		{
-			// 64x64 is the most common case by far, so special case it.
-			do
+			if (_xbits == 6 && _ybits == 6)
 			{
-				uint8_t texdata;
-
-				spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
-				texdata = source[spot];
-				if (texdata != 0)
+				// 64x64 is the most common case by far, so special case it.
+				do
 				{
-					uint32_t fg = colormap[texdata];
-					uint32_t bg = *dest;
-					fg = fg2rgb[fg];
-					bg = bg2rgb[bg];
-					fg = (fg + bg) | 0x1f07c1f;
-					*dest = RGB32k.All[fg & (fg >> 15)];
-				}
-				dest++;
-				xfrac += xstep;
-				yfrac += ystep;
-			} while (--count);
+					uint8_t texdata;
+
+					spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
+					texdata = source[spot];
+					if (texdata != 0)
+					{
+						uint32_t fg = colormap[texdata];
+						uint32_t bg = *dest;
+						fg = fg2rgb[fg];
+						bg = bg2rgb[bg];
+						fg = (fg + bg) | 0x1f07c1f;
+						*dest = RGB32k.All[fg & (fg >> 15)];
+					}
+					dest++;
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
+			else
+			{
+				uint8_t yshift = 32 - _ybits;
+				uint8_t xshift = yshift - _xbits;
+				int xmask = ((1 << _xbits) - 1) << _ybits;
+				do
+				{
+					uint8_t texdata;
+
+					spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
+					texdata = source[spot];
+					if (texdata != 0)
+					{
+						uint32_t fg = colormap[texdata];
+						uint32_t bg = *dest;
+						fg = fg2rgb[fg];
+						bg = bg2rgb[bg];
+						fg = (fg + bg) | 0x1f07c1f;
+						*dest = RGB32k.All[fg & (fg >> 15)];
+					}
+					dest++;
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
 		}
 		else
 		{
-			uint8_t yshift = 32 - _ybits;
-			uint8_t xshift = yshift - _xbits;
-			int xmask = ((1 << _xbits) - 1) << _ybits;
-			do
+			if (_xbits == 6 && _ybits == 6)
 			{
-				uint8_t texdata;
-
-				spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
-				texdata = source[spot];
-				if (texdata != 0)
+				// 64x64 is the most common case by far, so special case it.
+				do
 				{
-					uint32_t fg = colormap[texdata];
-					uint32_t bg = *dest;
-					fg = fg2rgb[fg];
-					bg = bg2rgb[bg];
-					fg = (fg + bg) | 0x1f07c1f;
-					*dest = RGB32k.All[fg & (fg >> 15)];
-				}
-				dest++;
-				xfrac += xstep;
-				yfrac += ystep;
-			} while (--count);
+					uint8_t texdata;
+
+					spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
+					texdata = source[spot];
+					if (texdata != 0)
+					{
+						uint32_t fg = colormap[texdata];
+						uint32_t bg = *dest;
+						int r = MAX((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+						int g = MAX((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+						int b = MAX((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+						*dest = RGB256k.RGB[r][g][b];
+					}
+					dest++;
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
+			else
+			{
+				uint8_t yshift = 32 - _ybits;
+				uint8_t xshift = yshift - _xbits;
+				int xmask = ((1 << _xbits) - 1) << _ybits;
+				do
+				{
+					uint8_t texdata;
+
+					spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
+					texdata = source[spot];
+					if (texdata != 0)
+					{
+						uint32_t fg = colormap[texdata];
+						uint32_t bg = *dest;
+						int r = MAX((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+						int g = MAX((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+						int b = MAX((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+						*dest = RGB256k.RGB[r][g][b];
+					}
+					dest++;
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
 		}
 	}
 
@@ -2148,6 +2632,7 @@ namespace swrenderer
 		int spot;
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
+		const PalEntry *palette = GPalette.BaseColors;
 
 		xfrac = _xfrac;
 		yfrac = _yfrac;
@@ -2159,45 +2644,87 @@ namespace swrenderer
 		xstep = _xstep;
 		ystep = _ystep;
 
-		if (_xbits == 6 && _ybits == 6)
+		if (!r_blendmethod)
 		{
-			// 64x64 is the most common case by far, so special case it.
-			do
+			if (_xbits == 6 && _ybits == 6)
 			{
-				spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
-				uint32_t a = fg2rgb[colormap[source[spot]]] + bg2rgb[*dest];
-				uint32_t b = a;
+				// 64x64 is the most common case by far, so special case it.
+				do
+				{
+					spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
+					uint32_t a = fg2rgb[colormap[source[spot]]] + bg2rgb[*dest];
+					uint32_t b = a;
 
-				a |= 0x01f07c1f;
-				b &= 0x40100400;
-				a &= 0x3fffffff;
-				b = b - (b >> 5);
-				a |= b;
-				*dest++ = RGB32k.All[a & (a >> 15)];
-				xfrac += xstep;
-				yfrac += ystep;
-			} while (--count);
+					a |= 0x01f07c1f;
+					b &= 0x40100400;
+					a &= 0x3fffffff;
+					b = b - (b >> 5);
+					a |= b;
+					*dest++ = RGB32k.All[a & (a >> 15)];
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
+			else
+			{
+				uint8_t yshift = 32 - _ybits;
+				uint8_t xshift = yshift - _xbits;
+				int xmask = ((1 << _xbits) - 1) << _ybits;
+				do
+				{
+					spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
+					uint32_t a = fg2rgb[colormap[source[spot]]] + bg2rgb[*dest];
+					uint32_t b = a;
+
+					a |= 0x01f07c1f;
+					b &= 0x40100400;
+					a &= 0x3fffffff;
+					b = b - (b >> 5);
+					a |= b;
+					*dest++ = RGB32k.All[a & (a >> 15)];
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
 		}
 		else
 		{
-			uint8_t yshift = 32 - _ybits;
-			uint8_t xshift = yshift - _xbits;
-			int xmask = ((1 << _xbits) - 1) << _ybits;
-			do
+			if (_xbits == 6 && _ybits == 6)
 			{
-				spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
-				uint32_t a = fg2rgb[colormap[source[spot]]] + bg2rgb[*dest];
-				uint32_t b = a;
+				// 64x64 is the most common case by far, so special case it.
+				do
+				{
+					spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
+					uint32_t fg = colormap[source[spot]];
+					uint32_t bg = *dest;
+					int r = MAX((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+					int g = MAX((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+					int b = MAX((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+					*dest++ = RGB256k.RGB[r][g][b];
 
-				a |= 0x01f07c1f;
-				b &= 0x40100400;
-				a &= 0x3fffffff;
-				b = b - (b >> 5);
-				a |= b;
-				*dest++ = RGB32k.All[a & (a >> 15)];
-				xfrac += xstep;
-				yfrac += ystep;
-			} while (--count);
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
+			else
+			{
+				uint8_t yshift = 32 - _ybits;
+				uint8_t xshift = yshift - _xbits;
+				int xmask = ((1 << _xbits) - 1) << _ybits;
+				do
+				{
+					spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
+					uint32_t fg = colormap[source[spot]];
+					uint32_t bg = *dest;
+					int r = MAX((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+					int g = MAX((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+					int b = MAX((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+					*dest++ = RGB256k.RGB[r][g][b];
+
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
 		}
 	}
 
@@ -2217,6 +2744,7 @@ namespace swrenderer
 		int spot;
 		uint32_t *fg2rgb = _srcblend;
 		uint32_t *bg2rgb = _destblend;
+		const PalEntry *palette = GPalette.BaseColors;
 
 		xfrac = _xfrac;
 		yfrac = _yfrac;
@@ -2228,59 +2756,113 @@ namespace swrenderer
 		xstep = _xstep;
 		ystep = _ystep;
 
-		if (_xbits == 6 && _ybits == 6)
+		if (!r_blendmethod)
 		{
-			// 64x64 is the most common case by far, so special case it.
-			do
+			if (_xbits == 6 && _ybits == 6)
 			{
-				uint8_t texdata;
-
-				spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
-				texdata = source[spot];
-				if (texdata != 0)
+				// 64x64 is the most common case by far, so special case it.
+				do
 				{
-					uint32_t a = fg2rgb[colormap[texdata]] + bg2rgb[*dest];
-					uint32_t b = a;
+					uint8_t texdata;
 
-					a |= 0x01f07c1f;
-					b &= 0x40100400;
-					a &= 0x3fffffff;
-					b = b - (b >> 5);
-					a |= b;
-					*dest = RGB32k.All[a & (a >> 15)];
-				}
-				dest++;
-				xfrac += xstep;
-				yfrac += ystep;
-			} while (--count);
+					spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
+					texdata = source[spot];
+					if (texdata != 0)
+					{
+						uint32_t a = fg2rgb[colormap[texdata]] + bg2rgb[*dest];
+						uint32_t b = a;
+	
+						a |= 0x01f07c1f;
+						b &= 0x40100400;
+						a &= 0x3fffffff;
+						b = b - (b >> 5);
+						a |= b;
+						*dest = RGB32k.All[a & (a >> 15)];
+					}
+					dest++;
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
+			else
+			{
+				uint8_t yshift = 32 - _ybits;
+				uint8_t xshift = yshift - _xbits;
+				int xmask = ((1 << _xbits) - 1) << _ybits;
+				do
+				{
+					uint8_t texdata;
+
+					spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
+					texdata = source[spot];
+					if (texdata != 0)
+					{
+						uint32_t a = fg2rgb[colormap[texdata]] + bg2rgb[*dest];
+						uint32_t b = a;
+	
+						a |= 0x01f07c1f;
+						b &= 0x40100400;
+						a &= 0x3fffffff;
+						b = b - (b >> 5);
+						a |= b;
+						*dest = RGB32k.All[a & (a >> 15)];
+					}
+					dest++;
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
 		}
 		else
 		{
-			uint8_t yshift = 32 - _ybits;
-			uint8_t xshift = yshift - _xbits;
-			int xmask = ((1 << _xbits) - 1) << _ybits;
-			do
+			if (_xbits == 6 && _ybits == 6)
 			{
-				uint8_t texdata;
-
-				spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
-				texdata = source[spot];
-				if (texdata != 0)
+				// 64x64 is the most common case by far, so special case it.
+				do
 				{
-					uint32_t a = fg2rgb[colormap[texdata]] + bg2rgb[*dest];
-					uint32_t b = a;
+					uint8_t texdata;
 
-					a |= 0x01f07c1f;
-					b &= 0x40100400;
-					a &= 0x3fffffff;
-					b = b - (b >> 5);
-					a |= b;
-					*dest = RGB32k.All[a & (a >> 15)];
-				}
-				dest++;
-				xfrac += xstep;
-				yfrac += ystep;
-			} while (--count);
+					spot = ((xfrac >> (32 - 6 - 6))&(63 * 64)) + (yfrac >> (32 - 6));
+					texdata = source[spot];
+					if (texdata != 0)
+					{
+						uint32_t fg = colormap[texdata];
+						uint32_t bg = *dest;
+						int r = MAX((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+						int g = MAX((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+						int b = MAX((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+						*dest = RGB256k.RGB[r][g][b];
+					}
+					dest++;
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
+			else
+			{
+				uint8_t yshift = 32 - _ybits;
+				uint8_t xshift = yshift - _xbits;
+				int xmask = ((1 << _xbits) - 1) << _ybits;
+				do
+				{
+					uint8_t texdata;
+
+					spot = ((xfrac >> xshift) & xmask) + (yfrac >> yshift);
+					texdata = source[spot];
+					if (texdata != 0)
+					{
+						uint32_t fg = colormap[texdata];
+						uint32_t bg = *dest;
+						int r = MAX((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+						int g = MAX((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+						int b = MAX((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+						*dest = RGB256k.RGB[r][g][b];
+					}
+					dest++;
+					xfrac += xstep;
+					yfrac += ystep;
+				} while (--count);
+			}
 		}
 	}
 
diff --git a/src/r_draw_pal.h b/src/r_draw_pal.h
index ab3c98327e..205e0cc284 100644
--- a/src/r_draw_pal.h
+++ b/src/r_draw_pal.h
@@ -102,6 +102,8 @@ namespace swrenderer
 		uint32_t *_srcblend;
 		uint32_t *_destblend;
 		uint32_t _srccolor;
+		fixed_t _srcalpha;
+		fixed_t _destalpha;
 	};
 
 	class DrawColumnPalCommand : public PalColumnCommand { public: void Execute(DrawerThread *thread) override; };
@@ -160,6 +162,8 @@ namespace swrenderer
 		uint32_t *_srcblend;
 		uint32_t *_destblend;
 		int _color;
+		fixed_t _srcalpha;
+		fixed_t _destalpha;
 	};
 
 	class DrawSpanPalCommand : public PalSpanCommand { public: void Execute(DrawerThread *thread) override; };
@@ -299,6 +303,8 @@ namespace swrenderer
 		const uint32_t *_srcblend;
 		const uint32_t *_destblend;
 		const uint8_t *_translation;
+		fixed_t _srcalpha;
+		fixed_t _destalpha;
 		int _color;
 	};
 
diff --git a/src/r_drawt_pal.cpp b/src/r_drawt_pal.cpp
index 3356592d25..dcc0a09389 100644
--- a/src/r_drawt_pal.cpp
+++ b/src/r_drawt_pal.cpp
@@ -4,6 +4,8 @@
 **
 **---------------------------------------------------------------------------
 ** Copyright 1998-2006 Randy Heit
+** Copyright 2016 Magnus Norddahl
+** Copyright 2016 Rachael Alexanderson
 ** All rights reserved.
 **
 ** Redistribution and use in source and binary forms, with or without
@@ -48,6 +50,8 @@
 #include "v_video.h"
 #include "r_draw_pal.h"
 
+EXTERN_CVAR(Bool, r_blendmethod)
+
 // I should have commented this stuff better.
 //
 // dc_temp is the buffer R_DrawColumnHoriz writes into.
@@ -173,6 +177,8 @@ namespace swrenderer
 		_colormap = dc_colormap;
 		_srcblend = dc_srcblend;
 		_destblend = dc_destblend;
+		_srcalpha = dc_srcalpha;
+		_destalpha = dc_destalpha;
 		_translation = dc_translation;
 		_color = dc_color;
 	}
@@ -446,18 +452,36 @@ namespace swrenderer
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4 + hx];
 		pitch = _pitch * thread->num_cores;
 		colormap = _colormap;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t fg = colormap[*source];
-			uint32_t bg = *dest;
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t fg = colormap[*source];
+				uint32_t bg = *dest;
 
-			fg = fg2rgb[fg];
-			bg = bg2rgb[bg];
-			fg = (fg+bg) | 0x1f07c1f;
-			*dest = RGB32k.All[fg & (fg>>15)];
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				fg = fg2rgb[fg];
+				bg = bg2rgb[bg];
+				fg = (fg+bg) | 0x1f07c1f;
+				*dest = RGB32k.All[fg & (fg>>15)];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				uint32_t fg = colormap[*source];
+				uint32_t bg = *dest;
+
+				int r = MIN((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 63);
+				int g = MIN((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 63);
+				int b = MIN((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 63);
+				*dest = RGB256k.RGB[r][g][b];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt4AddPalCommand::Execute(DrawerThread *thread)
@@ -478,40 +502,61 @@ namespace swrenderer
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4];
 		pitch = _pitch * thread->num_cores;
 		colormap = _colormap;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t fg = colormap[source[0]];
-			uint32_t bg = dest[0];
-			fg = fg2rgb[fg];
-			bg = bg2rgb[bg];
-			fg = (fg+bg) | 0x1f07c1f;
-			dest[0] = RGB32k.All[fg & (fg>>15)];
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t fg = colormap[source[0]];
+				uint32_t bg = dest[0];
+				fg = fg2rgb[fg];
+				bg = bg2rgb[bg];
+				fg = (fg+bg) | 0x1f07c1f;
+				dest[0] = RGB32k.All[fg & (fg>>15)];
 
-			fg = colormap[source[1]];
-			bg = dest[1];
-			fg = fg2rgb[fg];
-			bg = bg2rgb[bg];
-			fg = (fg+bg) | 0x1f07c1f;
-			dest[1] = RGB32k.All[fg & (fg>>15)];
+				fg = colormap[source[1]];
+				bg = dest[1];
+				fg = fg2rgb[fg];
+				bg = bg2rgb[bg];
+				fg = (fg+bg) | 0x1f07c1f;
+				dest[1] = RGB32k.All[fg & (fg>>15)];
 
 
-			fg = colormap[source[2]];
-			bg = dest[2];
-			fg = fg2rgb[fg];
-			bg = bg2rgb[bg];
-			fg = (fg+bg) | 0x1f07c1f;
-			dest[2] = RGB32k.All[fg & (fg>>15)];
+				fg = colormap[source[2]];
+				bg = dest[2];
+				fg = fg2rgb[fg];
+				bg = bg2rgb[bg];
+				fg = (fg+bg) | 0x1f07c1f;
+				dest[2] = RGB32k.All[fg & (fg>>15)];
 
-			fg = colormap[source[3]];
-			bg = dest[3];
-			fg = fg2rgb[fg];
-			bg = bg2rgb[bg];
-			fg = (fg+bg) | 0x1f07c1f;
-			dest[3] = RGB32k.All[fg & (fg>>15)];
+				fg = colormap[source[3]];
+				bg = dest[3];
+				fg = fg2rgb[fg];
+				bg = bg2rgb[bg];
+				fg = (fg+bg) | 0x1f07c1f;
+				dest[3] = RGB32k.All[fg & (fg>>15)];
 
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				for (int ks = 0; ks < 4; ks++)
+				{	// [SP] this 4col function was a block of copy-pasted code. 4 times. I regret nothing.
+					uint32_t fg = colormap[source[ks]];
+					uint32_t bg = dest[ks];
+					int r = MIN((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 63);
+					int g = MIN((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 63);
+					int b = MIN((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 63);
+					dest[ks] = RGB256k.RGB[r][g][b];
+				}
+
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt1ShadedPalCommand::Execute(DrawerThread *thread)
@@ -532,15 +577,31 @@ namespace swrenderer
 		dest = ylookup[yl + thread->skipped_by_thread(yl)] + sx + _destorg;
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4 + hx];
 		pitch = _pitch * thread->num_cores;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t val = colormap[*source];
-			uint32_t fg = fgstart[val<<8];
-			val = (Col2RGB8[64-val][*dest] + fg) | 0x1f07c1f;
-			*dest = RGB32k.All[val & (val>>15)];
-			source += 4;
-			dest += pitch;
-		} while (--count);
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t val = colormap[*source];
+				uint32_t fg = fgstart[val<<8];
+				val = (Col2RGB8[64-val][*dest] + fg) | 0x1f07c1f;
+				*dest = RGB32k.All[val & (val>>15)];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				uint32_t val = *source;
+				int r = (palette[*dest].r * (255-val) + palette[_color].r * val) >> 10;
+				int g = (palette[*dest].g * (255-val) + palette[_color].g * val) >> 10;
+				int b = (palette[*dest].b * (255-val) + palette[_color].b * val) >> 10;
+				*dest = RGB256k.RGB[clamp(r,0,63)][clamp(g,0,63)][clamp(b,0,63)];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt4ShadedPalCommand::Execute(DrawerThread *thread)
@@ -561,29 +622,51 @@ namespace swrenderer
 		dest = ylookup[yl + thread->skipped_by_thread(yl)] + sx + _destorg;
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4];
 		pitch = _pitch * thread->num_cores;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t val;
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t val;
 		
-			val = colormap[source[0]];
-			val = (Col2RGB8[64-val][dest[0]] + fgstart[val<<8]) | 0x1f07c1f;
-			dest[0] = RGB32k.All[val & (val>>15)];
+				val = colormap[source[0]];
+				val = (Col2RGB8[64-val][dest[0]] + fgstart[val<<8]) | 0x1f07c1f;
+				dest[0] = RGB32k.All[val & (val>>15)];
 
-			val = colormap[source[1]];
-			val = (Col2RGB8[64-val][dest[1]] + fgstart[val<<8]) | 0x1f07c1f;
-			dest[1] = RGB32k.All[val & (val>>15)];
+				val = colormap[source[1]];
+				val = (Col2RGB8[64-val][dest[1]] + fgstart[val<<8]) | 0x1f07c1f;
+				dest[1] = RGB32k.All[val & (val>>15)];
 
-			val = colormap[source[2]];
-			val = (Col2RGB8[64-val][dest[2]] + fgstart[val<<8]) | 0x1f07c1f;
-			dest[2] = RGB32k.All[val & (val>>15)];
+				val = colormap[source[2]];
+				val = (Col2RGB8[64-val][dest[2]] + fgstart[val<<8]) | 0x1f07c1f;
+				dest[2] = RGB32k.All[val & (val>>15)];
 
-			val = colormap[source[3]];
-			val = (Col2RGB8[64-val][dest[3]] + fgstart[val<<8]) | 0x1f07c1f;
-			dest[3] = RGB32k.All[val & (val>>15)];
+				val = colormap[source[3]];
+				val = (Col2RGB8[64-val][dest[3]] + fgstart[val<<8]) | 0x1f07c1f;
+				dest[3] = RGB32k.All[val & (val>>15)];
 
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				uint32_t val;
+
+				for (int ks = 0; ks < 4; ks++)
+				{
+					val = source[ks];
+					int r = (palette[dest[ks]].r * (255-val) + palette[_color].r * val) >> 10;
+					int g = (palette[dest[ks]].g * (255-val) + palette[_color].g * val) >> 10;
+					int b = (palette[dest[ks]].b * (255-val) + palette[_color].b * val) >> 10;
+					dest[ks] = RGB256k.RGB[clamp(r,0,63)][clamp(g,0,63)][clamp(b,0,63)];
+				}
+
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt1AddClampPalCommand::Execute(DrawerThread *thread)
@@ -604,20 +687,37 @@ namespace swrenderer
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4 + hx];
 		pitch = _pitch * thread->num_cores;
 		colormap = _colormap;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t a = fg2rgb[colormap[*source]] + bg2rgb[*dest];
-			uint32_t b = a;
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t a = fg2rgb[colormap[*source]] + bg2rgb[*dest];
+				uint32_t b = a;
 
-			a |= 0x01f07c1f;
-			b &= 0x40100400;
-			a &= 0x3fffffff;
-			b = b - (b >> 5);
-			a |= b;
-			*dest = RGB32k.All[(a>>15) & a];
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				a |= 0x01f07c1f;
+				b &= 0x40100400;
+				a &= 0x3fffffff;
+				b = b - (b >> 5);
+				a |= b;
+				*dest = RGB32k.All[(a>>15) & a];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				int fg = colormap[*source];
+				int bg = *dest;
+				int r = MIN((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 63);
+				int g = MIN((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 63);
+				int b = MIN((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 63);
+				*dest = RGB256k.RGB[r][g][b];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt4AddClampPalCommand::Execute(DrawerThread *thread)
@@ -636,51 +736,72 @@ namespace swrenderer
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4];
 		pitch = _pitch * thread->num_cores;
 		colormap = _colormap;
+		const PalEntry *palette = GPalette.BaseColors;
 
 		const uint32_t *fg2rgb = _srcblend;
 		const uint32_t *bg2rgb = _destblend;
 
-		do {
-			uint32_t a = fg2rgb[colormap[source[0]]] + bg2rgb[dest[0]];
-			uint32_t b = a;
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t a = fg2rgb[colormap[source[0]]] + bg2rgb[dest[0]];
+				uint32_t b = a;
 
-			a |= 0x01f07c1f;
-			b &= 0x40100400;
-			a &= 0x3fffffff;
-			b = b - (b >> 5);
-			a |= b;
-			dest[0] = RGB32k.All[(a>>15) & a];
+				a |= 0x01f07c1f;
+				b &= 0x40100400;
+				a &= 0x3fffffff;
+				b = b - (b >> 5);
+				a |= b;
+				dest[0] = RGB32k.All[(a>>15) & a];
 
-			a = fg2rgb[colormap[source[1]]] + bg2rgb[dest[1]];
-			b = a;
-			a |= 0x01f07c1f;
-			b &= 0x40100400;
-			a &= 0x3fffffff;
-			b = b - (b >> 5);
-			a |= b;
-			dest[1] = RGB32k.All[(a>>15) & a];
+				a = fg2rgb[colormap[source[1]]] + bg2rgb[dest[1]];
+				b = a;
+				a |= 0x01f07c1f;
+				b &= 0x40100400;
+				a &= 0x3fffffff;
+				b = b - (b >> 5);
+				a |= b;
+				dest[1] = RGB32k.All[(a>>15) & a];
 
-			a = fg2rgb[colormap[source[2]]] + bg2rgb[dest[2]];
-			b = a;
-			a |= 0x01f07c1f;
-			b &= 0x40100400;
-			a &= 0x3fffffff;
-			b = b - (b >> 5);
-			a |= b;
-			dest[2] = RGB32k.All[(a>>15) & a];
+				a = fg2rgb[colormap[source[2]]] + bg2rgb[dest[2]];
+				b = a;
+				a |= 0x01f07c1f;
+				b &= 0x40100400;
+				a &= 0x3fffffff;
+				b = b - (b >> 5);
+				a |= b;
+				dest[2] = RGB32k.All[(a>>15) & a];
 
-			a = fg2rgb[colormap[source[3]]] + bg2rgb[dest[3]];
-			b = a;
-			a |= 0x01f07c1f;
-			b &= 0x40100400;
-			a &= 0x3fffffff;
-			b = b - (b >> 5);
-			a |= b;
-			dest[3] = RGB32k.All[(a>>15) & a];
+				a = fg2rgb[colormap[source[3]]] + bg2rgb[dest[3]];
+				b = a;
+				a |= 0x01f07c1f;
+				b &= 0x40100400;
+				a &= 0x3fffffff;
+				b = b - (b >> 5);
+				a |= b;
+				dest[3] = RGB32k.All[(a>>15) & a];
 
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				for (int ks = 0; ks < 4; ks++)
+				{
+					int fg = colormap[source[ks]];
+					int bg = dest[ks];
+					int r = MIN((palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 63);
+					int g = MIN((palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 63);
+					int b = MIN((palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 63);
+					dest[ks] = RGB256k.RGB[r][g][b];
+				}
+
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt1SubClampPalCommand::Execute(DrawerThread *thread)
@@ -701,19 +822,36 @@ namespace swrenderer
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4 + hx];
 		pitch = _pitch * thread->num_cores;
 		colormap = _colormap;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t a = (fg2rgb[colormap[*source]] | 0x40100400) - bg2rgb[*dest];
-			uint32_t b = a;
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t a = (fg2rgb[colormap[*source]] | 0x40100400) - bg2rgb[*dest];
+				uint32_t b = a;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			*dest = RGB32k.All[(a>>15) & a];
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				*dest = RGB32k.All[(a>>15) & a];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				int fg = colormap[*source];
+				int bg = *dest;
+				int r = MAX((palette[fg].r * _srcalpha - palette[bg].r * _destalpha)>>18, 0);
+				int g = MAX((palette[fg].g * _srcalpha - palette[bg].g * _destalpha)>>18, 0);
+				int b = MAX((palette[fg].b * _srcalpha - palette[bg].b * _destalpha)>>18, 0);
+				*dest = RGB256k.RGB[r][g][b];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt4SubClampPalCommand::Execute(DrawerThread *thread)
@@ -734,44 +872,65 @@ namespace swrenderer
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4];
 		pitch = _pitch * thread->num_cores;
 		colormap = _colormap;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t a = (fg2rgb[colormap[source[0]]] | 0x40100400) - bg2rgb[dest[0]];
-			uint32_t b = a;
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t a = (fg2rgb[colormap[source[0]]] | 0x40100400) - bg2rgb[dest[0]];
+				uint32_t b = a;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			dest[0] = RGB32k.All[(a>>15) & a];
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				dest[0] = RGB32k.All[(a>>15) & a];
 
-			a = (fg2rgb[colormap[source[1]]] | 0x40100400) - bg2rgb[dest[1]];
-			b = a;
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			dest[1] = RGB32k.All[(a>>15) & a];
+				a = (fg2rgb[colormap[source[1]]] | 0x40100400) - bg2rgb[dest[1]];
+				b = a;
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				dest[1] = RGB32k.All[(a>>15) & a];
 
-			a = (fg2rgb[colormap[source[2]]] | 0x40100400) - bg2rgb[dest[2]];
-			b = a;
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			dest[2] = RGB32k.All[(a>>15) & a];
+				a = (fg2rgb[colormap[source[2]]] | 0x40100400) - bg2rgb[dest[2]];
+				b = a;
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				dest[2] = RGB32k.All[(a>>15) & a];
 
-			a = (fg2rgb[colormap[source[3]]] | 0x40100400) - bg2rgb[dest[3]];
-			b = a;
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			dest[3] = RGB32k.All[(a>>15) & a];
+				a = (fg2rgb[colormap[source[3]]] | 0x40100400) - bg2rgb[dest[3]];
+				b = a;
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				dest[3] = RGB32k.All[(a>>15) & a];
 
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				for (int ks = 0; ks < 4; ks++)
+				{
+					int fg = colormap[source[ks]];
+					int bg = dest[ks];
+					int r = MAX((palette[fg].r * _srcalpha - palette[bg].r * _destalpha)>>18, 0);
+					int g = MAX((palette[fg].g * _srcalpha - palette[bg].g * _destalpha)>>18, 0);
+					int b = MAX((palette[fg].b * _srcalpha - palette[bg].b * _destalpha)>>18, 0);
+					dest[ks] = RGB256k.RGB[r][g][b];
+				}
+
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt1RevSubClampPalCommand::Execute(DrawerThread *thread)
@@ -792,19 +951,36 @@ namespace swrenderer
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4 + hx];
 		pitch = _pitch * thread->num_cores;
 		colormap = _colormap;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[*source]];
-			uint32_t b = a;
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[*source]];
+				uint32_t b = a;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			*dest = RGB32k.All[(a>>15) & a];
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				*dest = RGB32k.All[(a>>15) & a];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				int fg = colormap[*source];
+				int bg = *dest;
+				int r = MAX((-palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+				int g = MAX((-palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+				int b = MAX((-palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+				*dest = RGB256k.RGB[r][g][b];
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 
 	void DrawColumnRt4RevSubClampPalCommand::Execute(DrawerThread *thread)
@@ -825,43 +1001,64 @@ namespace swrenderer
 		source = &thread->dc_temp[thread->temp_line_for_thread(yl)*4];
 		pitch = _pitch * thread->num_cores;
 		colormap = _colormap;
+		const PalEntry *palette = GPalette.BaseColors;
 
-		do {
-			uint32_t a = (bg2rgb[dest[0]] | 0x40100400) - fg2rgb[colormap[source[0]]];
-			uint32_t b = a;
+		if (!r_blendmethod)
+		{
+			do {
+				uint32_t a = (bg2rgb[dest[0]] | 0x40100400) - fg2rgb[colormap[source[0]]];
+				uint32_t b = a;
 
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			dest[0] = RGB32k.All[(a>>15) & a];
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				dest[0] = RGB32k.All[(a>>15) & a];
 
-			a = (bg2rgb[dest[1]] | 0x40100400) - fg2rgb[colormap[source[1]]];
-			b = a;
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			dest[1] = RGB32k.All[(a>>15) & a];
+				a = (bg2rgb[dest[1]] | 0x40100400) - fg2rgb[colormap[source[1]]];
+				b = a;
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				dest[1] = RGB32k.All[(a>>15) & a];
 
-			a = (bg2rgb[dest[2]] | 0x40100400) - fg2rgb[colormap[source[2]]];
-			b = a;
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			dest[2] = RGB32k.All[(a>>15) & a];
+				a = (bg2rgb[dest[2]] | 0x40100400) - fg2rgb[colormap[source[2]]];
+				b = a;
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				dest[2] = RGB32k.All[(a>>15) & a];
 
-			a = (bg2rgb[dest[3]] | 0x40100400) - fg2rgb[colormap[source[3]]];
-			b = a;
-			b &= 0x40100400;
-			b = b - (b >> 5);
-			a &= b;
-			a |= 0x01f07c1f;
-			dest[3] = RGB32k.All[(a>>15) & a];
+				a = (bg2rgb[dest[3]] | 0x40100400) - fg2rgb[colormap[source[3]]];
+				b = a;
+				b &= 0x40100400;
+				b = b - (b >> 5);
+				a &= b;
+				a |= 0x01f07c1f;
+				dest[3] = RGB32k.All[(a>>15) & a];
 
-			source += 4;
-			dest += pitch;
-		} while (--count);
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
+		else
+		{
+			do {
+				for (int ks = 0; ks < 4; ks++)
+				{
+					int fg = colormap[source[ks]];
+					int bg = dest[ks];
+					int r = MAX((-palette[fg].r * _srcalpha + palette[bg].r * _destalpha)>>18, 0);
+					int g = MAX((-palette[fg].g * _srcalpha + palette[bg].g * _destalpha)>>18, 0);
+					int b = MAX((-palette[fg].b * _srcalpha + palette[bg].b * _destalpha)>>18, 0);
+					dest[ks] = RGB256k.RGB[r][g][b];
+				}
+
+				source += 4;
+				dest += pitch;
+			} while (--count);
+		}
 	}
 }
diff --git a/src/r_plane.cpp b/src/r_plane.cpp
index 074bc39f46..ddde435b2f 100644
--- a/src/r_plane.cpp
+++ b/src/r_plane.cpp
@@ -1738,7 +1738,7 @@ void R_DrawNormalPlane (visplane_t *pl, double _xscale, double _yscale, fixed_t
 					dc_srcblend = Col2RGB8_LessPrecision[alpha>>10];
 					dc_destblend = Col2RGB8_LessPrecision[FRACUNIT>>10];
 					dc_srcalpha = alpha;
-					dc_destalpha = OPAQUE - alpha;
+					dc_destalpha = FRACUNIT;
 				}
 			}
 			else
@@ -1764,7 +1764,7 @@ void R_DrawNormalPlane (visplane_t *pl, double _xscale, double _yscale, fixed_t
 					dc_srcblend = Col2RGB8_LessPrecision[alpha>>10];
 					dc_destblend = Col2RGB8_LessPrecision[FRACUNIT>>10];
 					dc_srcalpha = alpha;
-					dc_destalpha = OPAQUE - alpha;
+					dc_destalpha = FRACUNIT;
 				}
 			}
 			else
diff --git a/src/r_things.cpp b/src/r_things.cpp
index 6e6b95402a..53e3c05895 100644
--- a/src/r_things.cpp
+++ b/src/r_things.cpp
@@ -72,6 +72,7 @@ EXTERN_CVAR(Int, r_drawfuzz)
 EXTERN_CVAR(Bool, r_deathcamera);
 EXTERN_CVAR(Bool, r_drawplayersprites)
 EXTERN_CVAR(Bool, r_drawvoxels)
+EXTERN_CVAR(Bool, r_blendmethod)
 
 CVAR(Bool, r_fullbrightignoresectorcolor, true, CVAR_ARCHIVE | CVAR_GLOBALCONFIG);
 CVAR(Bool, r_splitsprites, true, CVAR_ARCHIVE)
@@ -2786,8 +2787,13 @@ static void R_DrawMaskedSegsBehindParticle (const vissprite_t *vis)
 	}
 }
 
-void R_DrawParticle_C (vissprite_t *vis)
+//inline int clamp(int x, int y, int z) { return ((x < y) ? x : (z < y) ? z : y); }
+
+void R_DrawParticle (vissprite_t *vis)
 {
+	if (r_swtruecolor)
+		return R_DrawParticle_rgba(vis);
+		
 	DWORD *bg2rgb;
 	int spacing;
 	BYTE *dest;
@@ -2803,8 +2809,9 @@ void R_DrawParticle_C (vissprite_t *vis)
 	DrawerCommandQueue::WaitForWorkers();
 
 	// vis->renderflags holds translucency level (0-255)
+	fixed_t fglevel, bglevel;
+
 	{
-		fixed_t fglevel, bglevel;
 		DWORD *fg2rgb;
 
 		fglevel = ((vis->renderflags + 1) << 8) & ~0x3ff;
@@ -2837,18 +2844,40 @@ void R_DrawParticle_C (vissprite_t *vis)
 
 	spacing = RenderTarget->GetPitch();
 
-	for (int x = x1; x < (x1+countbase); x++)
+	if (!r_blendmethod)
 	{
-		dc_x = x;
-		if (R_ClipSpriteColumnWithPortals(vis))
-			continue;
-		dest = ylookup[yl] + x + dc_destorg;
-		for (int y = 0; y < ycount; y++)
+		for (int x = x1; x < (x1+countbase); x++)
 		{
-			DWORD bg = bg2rgb[*dest];
-			bg = (fg+bg) | 0x1f07c1f;
-			*dest = RGB32k.All[bg & (bg>>15)];
-			dest += spacing;
+			dc_x = x;
+			if (R_ClipSpriteColumnWithPortals(vis))
+				continue;
+			dest = ylookup[yl] + x + dc_destorg;
+			for (int y = 0; y < ycount; y++)
+			{
+				DWORD bg = bg2rgb[*dest];
+				bg = (fg+bg) | 0x1f07c1f;
+				*dest = RGB32k.All[bg & (bg>>15)];
+				dest += spacing;
+			}
+		}
+	}
+	else
+	{
+		for (int x = x1; x < (x1+countbase); x++)
+		{
+			dc_x = x;
+			if (R_ClipSpriteColumnWithPortals(vis))
+				continue;
+			dest = ylookup[yl] + x + dc_destorg;
+			for (int y = 0; y < ycount; y++)
+			{
+				uint32_t dest_r = MIN((GPalette.BaseColors[*dest].r * bglevel + GPalette.BaseColors[color].r * fglevel) >> 18, 63);
+				uint32_t dest_g = MIN((GPalette.BaseColors[*dest].g * bglevel + GPalette.BaseColors[color].g * fglevel) >> 18, 63);
+				uint32_t dest_b = MIN((GPalette.BaseColors[*dest].b * bglevel + GPalette.BaseColors[color].b * fglevel) >> 18, 63);
+
+				*dest = RGB256k.RGB[dest_r][dest_g][dest_b];
+				dest += spacing;
+			}
 		}
 	}
 }
diff --git a/src/r_things.h b/src/r_things.h
index c1ba2bc40a..657be32c53 100644
--- a/src/r_things.h
+++ b/src/r_things.h
@@ -100,7 +100,7 @@ struct vissprite_t
 	vissprite_t() {}
 };
 
-void R_DrawParticle_C (vissprite_t *);
+void R_DrawParticle (vissprite_t *);
 void R_DrawParticle_rgba (vissprite_t *);
 
 void R_ProjectParticle (particle_t *, const sector_t *sector, int shade, int fakeside);
diff --git a/src/v_draw.cpp b/src/v_draw.cpp
index a56c63998a..703a059ef7 100644
--- a/src/v_draw.cpp
+++ b/src/v_draw.cpp
@@ -988,27 +988,6 @@ void DCanvas::PUTTRANSDOT (int xx, int yy, int basecolor, int level)
 	static int oldyy;
 	static int oldyyshifted;
 
-#if 0
-	if(xx < 32)
-		cc += 7-(xx>>2);
-	else if(xx > (finit_width - 32))
-		cc += 7-((finit_width-xx) >> 2);
-//	if(cc==oldcc) //make sure that we don't double fade the corners.
-//	{
-		if(yy < 32)
-			cc += 7-(yy>>2);
-		else if(yy > (finit_height - 32))
-			cc += 7-((finit_height-yy) >> 2);
-//	}
-	if(cc > cm && cm != NULL)
-	{
-		cc = cm;
-	}
-	else if(cc > oldcc+6) // don't let the color escape from the fade table...
-	{
-		cc=oldcc+6;
-	}
-#endif
 	if (yy == oldyy+1)
 	{
 		oldyy++;
@@ -1044,7 +1023,7 @@ void DCanvas::PUTTRANSDOT (int xx, int yy, int basecolor, int level)
 
 		*spot = 0xff000000 | (red << 16) | (green << 8) | blue;
 	}
-	else
+	else if (!r_blendmethod)
 	{
 		BYTE *spot = GetBuffer() + oldyyshifted + xx;
 		DWORD *bg2rgb = Col2RGB8[1+level];
@@ -1054,6 +1033,16 @@ void DCanvas::PUTTRANSDOT (int xx, int yy, int basecolor, int level)
 		bg = (fg+bg) | 0x1f07c1f;
 		*spot = RGB32k.All[bg&(bg>>15)];
 	}
+	else
+	{
+		BYTE *spot = GetBuffer() + oldyyshifted + xx;
+
+		uint32_t r = (GPalette.BaseColors[*spot].r * (64 - level) + GPalette.BaseColors[basecolor].r * level) / 64;
+		uint32_t g = (GPalette.BaseColors[*spot].g * (64 - level) + GPalette.BaseColors[basecolor].g * level) / 64;
+		uint32_t b = (GPalette.BaseColors[*spot].b * (64 - level) + GPalette.BaseColors[basecolor].b * level) / 64;
+
+		*spot = (BYTE)RGB256k.RGB[r][g][b];
+	}
 }
 
 void DCanvas::DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32 realcolor)
diff --git a/src/v_video.cpp b/src/v_video.cpp
index f3b399bb99..bd322bf52f 100644
--- a/src/v_video.cpp
+++ b/src/v_video.cpp
@@ -66,6 +66,8 @@
 #include "menu/menu.h"
 #include "r_data/voxels.h"
 
+EXTERN_CVAR(Bool, r_blendmethod)
+
 int active_con_scale();
 
 FRenderer *Renderer;
@@ -411,29 +413,45 @@ void DCanvas::Dim (PalEntry color, float damount, int x1, int y1, int w, int h)
 		DWORD *bg2rgb;
 		DWORD fg;
 
+		spot = Buffer + x1 + y1*Pitch;
+		gap = Pitch - w;
+
+		int alpha = (int)((float)64 * damount);
+		int ialpha = 64 - alpha;
+		int dimmedcolor_r = color.r * alpha;
+		int dimmedcolor_g = color.g * alpha;
+		int dimmedcolor_b = color.b * alpha;
+
+		if (!r_blendmethod)
 		{
-			int amount;
-
-			amount = (int)(damount * 64);
-			bg2rgb = Col2RGB8[64-amount];
-
-			fg = (((color.r * amount) >> 4) << 20) |
-				  ((color.g * amount) >> 4) |
-				 (((color.b * amount) >> 4) << 10);
-		}
-
-		for (y = h; y != 0; y--)
-		{
-			for (x = w; x != 0; x--)
+			for (y = h; y != 0; y--)
 			{
-				DWORD bg;
+				for (x = w; x != 0; x--)
+				{
+					DWORD bg;
 
-				bg = bg2rgb[(*spot)&0xff];
-				bg = (fg+bg) | 0x1f07c1f;
-				*spot = RGB32k.All[bg&(bg>>15)];
-				spot++;
+					bg = bg2rgb[(*spot)&0xff];
+					bg = (fg+bg) | 0x1f07c1f;
+					*spot = RGB32k.All[bg&(bg>>15)];
+					spot++;
+				}
+				spot += gap;
+			}
+		}
+		else
+		{
+			for (y = h; y != 0; y--)
+			{
+				for (x = w; x != 0; x--)
+				{
+					uint32_t r = (dimmedcolor_r + GPalette.BaseColors[*spot].r * ialpha) >> 8;
+					uint32_t g = (dimmedcolor_g + GPalette.BaseColors[*spot].g * ialpha) >> 8;
+					uint32_t b = (dimmedcolor_b + GPalette.BaseColors[*spot].b * ialpha) >> 8;
+					*spot = (BYTE)RGB256k.RGB[r][g][b];
+					spot++;
+				}
+				spot += gap;
 			}
-			spot += gap;
 		}
 	}
 }
diff --git a/wadsrc/static/language.enu b/wadsrc/static/language.enu
index 48e2484fd4..c6de55f6f9 100644
--- a/wadsrc/static/language.enu
+++ b/wadsrc/static/language.enu
@@ -1781,6 +1781,8 @@ DSPLYMNU_BRIGHTNESS				= "Brightness";
 DSPLYMNU_VSYNC					= "Vertical Sync";
 DSPLYMNU_CAPFPS					= "Rendering Interpolation";
 DSPLYMNU_COLUMNMETHOD			= "Column render mode";
+DSPLYMNU_BLENDMETHOD			= "Transparency render mode";
+
 DSPLYMNU_WIPETYPE				= "Screen wipe style";
 DSPLYMNU_SHOWENDOOM				= "Show ENDOOM screen";
 DSPLYMNU_BLOODFADE				= "Blood Flash Intensity";
@@ -2198,6 +2200,8 @@ OPTVAL_INVERTED				= "Inverted";
 OPTVAL_NOTINVERTED			= "Not Inverted";
 OPTVAL_ORIGINAL				= "Original";
 OPTVAL_OPTIMIZED			= "Optimized";
+OPTVAL_CLASSIC				= "Classic (Faster)";
+OPTVAL_PRECISE				= "Precise";
 OPTVAL_NORMAL				= "Normal";
 OPTVAL_STRETCH				= "Stretch";
 OPTVAL_CAPPED				= "Capped";
diff --git a/wadsrc/static/menudef.txt b/wadsrc/static/menudef.txt
index 3086312a9b..8882c89ae1 100644
--- a/wadsrc/static/menudef.txt
+++ b/wadsrc/static/menudef.txt
@@ -601,6 +601,12 @@ OptionValue ColumnMethods
 	1.0, "$OPTVAL_OPTIMIZED"
 }
 
+OptionValue BlendMethods
+{
+	0.0, "$OPTVAL_CLASSIC"
+	1.0, "$OPTVAL_PRECISE"
+}
+
 OptionValue SkyModes
 {
 	0.0, "$OPTVAL_NORMAL"
@@ -699,6 +705,7 @@ OptionMenu "VideoOptions"
 	Slider "$DSPLYMNU_PICKUPFADE",				"pickup_fade_scalar", 0.0, 1.0, 0.05, 2
 	Slider "$DSPLYMNU_WATERFADE",				"underwater_fade_scalar", 0.0, 1.0, 0.05, 2
 	Option "$DSPLYMNU_COLUMNMETHOD",			"r_columnmethod", "ColumnMethods"
+	Option "$DSPLYMNU_BLENDMETHOD",				"r_blendmethod", "BlendMethods"
 
 	StaticText " "
 	Option "$DSPLYMNU_WIPETYPE",				"wipetype", "Wipes"