Merge branch 'zdoom-rgb666-take3' of https://github.com/raa-eruanna/qzdoom into qzdoom-rgb666

# Conflicts:
#	src/r_draw.cpp
#	src/r_plane.cpp
#	src/r_things.h
#	src/v_draw.cpp
#	src/v_video.cpp

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,6 +283,8 @@ bool wipe_doBurn (int ticks)
 	fromold = (BYTE *)wipe_scr_start;
 	fromnew = (BYTE *)wipe_scr_end;
 
+	if (!r_blendmethod)
+	{
 		for (y = 0, firey = 0; y < SCREENHEIGHT; y++, firey += ystep)
 		{
 			for (x = 0, firex = 0; x < SCREENWIDTH; x++, firex += xstep)
@@ -313,6 +318,45 @@ bool wipe_doBurn (int ticks)
 			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,7 +391,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			for (y = 0; y < SCREENHEIGHT; y++)
 			{
 				for (x = 0; x < SCREENWIDTH; x++)
@@ -362,6 +409,25 @@ bool wipe_doFade (int ticks)
 				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;
+			}
+		}
+	}
 	return false;
 }
 

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);
-	}
 }

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 *);
 }

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

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,7 +452,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t fg = colormap[*source];
 				uint32_t bg = *dest;
@@ -459,6 +468,21 @@ namespace swrenderer
 				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,7 +502,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t fg = colormap[source[0]];
 				uint32_t bg = dest[0];
@@ -513,6 +540,24 @@ namespace swrenderer
 				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,7 +577,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t val = colormap[*source];
 				uint32_t fg = fgstart[val<<8];
@@ -542,6 +590,19 @@ namespace swrenderer
 				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,7 +622,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t val;
 		
@@ -585,6 +649,25 @@ namespace swrenderer
 				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,7 +687,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t a = fg2rgb[colormap[*source]] + bg2rgb[*dest];
 				uint32_t b = a;
@@ -619,6 +705,20 @@ namespace swrenderer
 				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,10 +736,13 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t a = fg2rgb[colormap[source[0]]] + bg2rgb[dest[0]];
 				uint32_t b = a;
@@ -682,6 +785,24 @@ namespace swrenderer
 				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,7 +822,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t a = (fg2rgb[colormap[*source]] | 0x40100400) - bg2rgb[*dest];
 				uint32_t b = a;
@@ -715,6 +839,20 @@ namespace swrenderer
 				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,7 +872,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t a = (fg2rgb[colormap[source[0]]] | 0x40100400) - bg2rgb[dest[0]];
 				uint32_t b = a;
@@ -773,6 +914,24 @@ namespace swrenderer
 				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,7 +951,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t a = (bg2rgb[*dest] | 0x40100400) - fg2rgb[colormap[*source]];
 				uint32_t b = a;
@@ -806,6 +968,20 @@ namespace swrenderer
 				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,7 +1001,10 @@ 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;
 
+		if (!r_blendmethod)
+		{
 			do {
 				uint32_t a = (bg2rgb[dest[0]] | 0x40100400) - fg2rgb[colormap[source[0]]];
 				uint32_t b = a;
@@ -864,4 +1043,22 @@ namespace swrenderer
 				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);
+		}
+	}
 }

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

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;
+
+	{
 		DWORD *fg2rgb;
 
 		fglevel = ((vis->renderflags + 1) << 8) & ~0x3ff;
@@ -2837,6 +2844,8 @@ void R_DrawParticle_C (vissprite_t *vis)
 
 	spacing = RenderTarget->GetPitch();
 
+	if (!r_blendmethod)
+	{
 		for (int x = x1; x < (x1+countbase); x++)
 		{
 			dc_x = x;
@@ -2852,6 +2861,26 @@ void R_DrawParticle_C (vissprite_t *vis)
 			}
 		}
 	}
+	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;
+			}
+		}
+	}
+}
 
 void R_DrawParticle_rgba(vissprite_t *vis)
 {

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

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)

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,17 +413,17 @@ 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--)
@@ -436,6 +438,22 @@ void DCanvas::Dim (PalEntry color, float damount, int x1, int y1, int w, int h)
 				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;
+			}
+		}
+	}
 }
 
 //==========================================================================

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

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"