src/android/i_video.c

@@ -8,10 +8,11 @@
 
 #include "utils/Log.h"
 
-rendermode_t rendermode = render_soft;
+rendermode_t rendermode = render_software;
 rendermode_t chosenrendermode = render_none;
 
 boolean highcolor = false;
+boolean truecolor = false;
 
 boolean allow_fullscreen = false;
 
@@ -53,6 +54,16 @@ INT32 VID_SetMode(INT32 modenum)
   return 0;
 }
 
+boolean VID_IsASoftwareRenderer(rendermode_t mode)
+{
+	return (mode == render_software);
+}
+
+boolean VID_InSoftwareRenderer(void)
+{
+	return VID_IsASoftwareRenderer(rendermode);
+}
+
 boolean VID_CheckRenderer(void)
 {
 	return false;

src/d_main.c

@@ -333,7 +333,7 @@ static void D_Display(void)
 		SCR_Recalc(); // NOTE! setsizeneeded is set by SCR_Recalc()
 
 	// View morph
-	if (rendermode == render_soft && !splitscreen)
+	if (VID_InSoftwareRenderer() && !splitscreen)
 		R_CheckViewMorph();
 
 	// Change the view size if needed
@@ -475,20 +475,28 @@ static void D_Display(void)
 		if (gamestate == GS_LEVEL || (gamestate == GS_TITLESCREEN && titlemapinaction && curbghide && (!hidetitlemap)))
 		{
 			// draw the view directly
-
 			if (!automapactive && !dedicated && cv_renderview.value)
 			{
+				SCR_SetSoftwareTranslucency(); // Set translucency method
+				if (!usetranstables)
+					R_InitAlphaLUT();
+
 				R_ApplyLevelInterpolators(R_UsingFrameInterpolation() ? rendertimefrac : FRACUNIT);
 				PS_START_TIMING(ps_rendercalltime);
+
 				if (players[displayplayer].mo || players[displayplayer].playerstate == PST_DEAD)
 				{
 					topleft = screens[0] + viewwindowy*vid.width + viewwindowx;
+#ifdef TRUECOLOR
+					if (truecolor)
+						topleft_u32 = (UINT32 *)screens[0] + viewwindowy*vid.width + viewwindowx;
+#endif
 					objectsdrawn = 0;
-	#ifdef HWRENDER
-					if (rendermode != render_soft)
+#ifdef HWRENDER
+					if (!VID_InSoftwareRenderer())
 						HWR_RenderPlayerView(0, &players[displayplayer]);
 					else
-	#endif
+#endif
 					if (rendermode != render_none)
 						R_RenderPlayerView(&players[displayplayer]);
 				}
@@ -496,17 +504,21 @@ static void D_Display(void)
 				// render the second screen
 				if (splitscreen && players[secondarydisplayplayer].mo)
 				{
-	#ifdef HWRENDER
-					if (rendermode != render_soft)
+#ifdef HWRENDER
+					if (!VID_InSoftwareRenderer())
 						HWR_RenderPlayerView(1, &players[secondarydisplayplayer]);
 					else
-	#endif
+#endif
 					if (rendermode != render_none)
 					{
 						viewwindowy = vid.height / 2;
 						M_Memcpy(ylookup, ylookup2, viewheight*sizeof (ylookup[0]));
 
 						topleft = screens[0] + viewwindowy*vid.width + viewwindowx;
+#ifdef TRUECOLOR
+						if (truecolor)
+							topleft_u32 = (UINT32 *)screens[0] + viewwindowy*vid.width + viewwindowx;
+#endif
 
 						R_RenderPlayerView(&players[secondarydisplayplayer]);
 
@@ -516,7 +528,7 @@ static void D_Display(void)
 				}
 
 				// Image postprocessing effect
-				if (rendermode == render_soft)
+				if (VID_InSoftwareRenderer())
 				{
 					if (!splitscreen)
 						R_ApplyViewMorph();
@@ -532,7 +544,7 @@ static void D_Display(void)
 
 			if (lastdraw)
 			{
-				if (rendermode == render_soft)
+				if (VID_InSoftwareRenderer())
 				{
 					VID_BlitLinearScreen(screens[0], screens[1], vid.width*vid.bpp, vid.height, vid.width*vid.bpp, vid.rowbytes);
 					Y_ConsiderScreenBuffer();
@@ -688,6 +700,26 @@ static void D_Display(void)
 	}
 }
 
+void D_CheckColorDepth(INT32 newbitdepth, INT32 oldbitdepth)
+{
+#ifdef TRUECOLOR
+	if (oldbitdepth == 0) // Video init
+		return;
+
+	if (newbitdepth != oldbitdepth)
+	{
+		// Reload every texture.
+		R_FlushTextureCache();
+
+		// Also free levelflat pictures.
+		R_ClearLevelFlats();
+	}
+#else
+	(void)newbitdepth;
+	(void)oldbitdepth;
+#endif
+}
+
 // =========================================================================
 // D_SRB2Loop
 // =========================================================================

src/d_main.h

@@ -47,6 +47,12 @@ const char *D_Home(void);
 boolean D_IsPathAllowed(const char *path);
 boolean D_CheckPathAllowed(const char *path, const char *why);
 
+//
+// RENDERER STATE
+//
+void D_CheckRendererState(void);
+void D_CheckColorDepth(INT32 newbitdepth, INT32 oldbitdepth);
+
 //
 // BASE LEVEL
 //

src/deh_soc.c

@@ -2837,7 +2837,6 @@ void readsound(MYFILE *f, INT32 num)
 			tmp = strchr(s, '\n');
 			if (tmp)
 				*tmp = '\0';
-
 			tmp = strchr(s, '#');
 			if (tmp)
 				*tmp = '\0';

src/doomdef.h

@@ -659,6 +659,12 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
 /// Render flats on walls
 #define WALLFLATS
 
+
+/// Software true color mode rendering
+#ifndef NO_TRUECOLOR
+#define TRUECOLOR
+#endif
+
 /// Maintain compatibility with older 2.2 demos
 #define OLD22DEMOCOMPAT
 

src/dummy/i_video.c

@@ -6,6 +6,7 @@ rendermode_t rendermode = render_none;
 rendermode_t chosenrendermode = render_none;
 
 boolean highcolor = false;
+boolean truecolor = false;
 
 boolean allow_fullscreen = false;
 
@@ -41,6 +42,17 @@ INT32 VID_SetMode(INT32 modenum)
 	return 0;
 }
 
+boolean VID_IsASoftwareRenderer(rendermode_t mode)
+{
+	(void)mode;
+	return false;
+}
+
+boolean VID_InSoftwareRenderer(void)
+{
+	return false;
+}
+
 boolean VID_CheckRenderer(void)
 {
 	return false;

src/g_game.c

@@ -2501,7 +2501,7 @@ static inline void G_PlayerFinishLevel(INT32 player)
 	p->starpostz = 0;
 	p->starpostnum = 0;
 
-	if (rendermode == render_soft)
+	if (VID_InSoftwareRenderer())
 		V_SetPaletteLump(GetPalette()); // Reset the palette
 }
 

src/hardware/hw_data.h

@@ -84,6 +84,7 @@ typedef struct GLMapTexture_s GLMapTexture_t;
 struct GLPatch_s
 {
 	GLMipmap_t *mipmap; // Texture data. Allocated whenever the patch is.
+	int         picfmt;
 	float       max_s, max_t;
 };
 typedef struct GLPatch_s GLPatch_t;

src/hardware/hw_glob.h

@@ -82,7 +82,7 @@ typedef struct gl_vissprite_s
 	boolean flip, vflip;
 	boolean precip; // Tails 08-25-2002
 	boolean rotated;
-	UINT8 translucency;       //alpha level 0-255
+	boolean translucent;
 
 	angle_t angle; // for splats
 
@@ -92,6 +92,9 @@ typedef struct gl_vissprite_s
 
 	patch_t *gpatch;
 	mobj_t *mobj; // NOTE: This is a precipmobj_t if precip is true !!! Watch out.
+
+	INT32 blendmode;
+	INT32 alpha;
 } gl_vissprite_t;
 
 // --------

src/hardware/hw_main.c

@@ -704,36 +704,15 @@ FBITFIELD HWR_GetBlendModeFlag(INT32 style)
 	}
 }
 
-UINT8 HWR_GetTranstableAlpha(INT32 transtablenum)
+FBITFIELD HWR_SurfaceBlend(INT32 style, INT32 alpha, FSurfaceInfo *pSurf)
 {
-	transtablenum = max(min(transtablenum, tr_trans90), 0);
-
-	switch (transtablenum)
-	{
-		case 0          : return 0xff;
-		case tr_trans10 : return 0xe6;
-		case tr_trans20 : return 0xcc;
-		case tr_trans30 : return 0xb3;
-		case tr_trans40 : return 0x99;
-		case tr_trans50 : return 0x80;
-		case tr_trans60 : return 0x66;
-		case tr_trans70 : return 0x4c;
-		case tr_trans80 : return 0x33;
-		case tr_trans90 : return 0x19;
-	}
-
-	return 0xff;
-}
-
-FBITFIELD HWR_SurfaceBlend(INT32 style, INT32 transtablenum, FSurfaceInfo *pSurf)
-{
-	if (!transtablenum || style <= AST_COPY || style >= AST_OVERLAY)
+	if (style <= AST_COPY || style >= AST_OVERLAY)
 	{
 		pSurf->PolyColor.s.alpha = 0xff;
 		return PF_Masked;
 	}
 
-	pSurf->PolyColor.s.alpha = HWR_GetTranstableAlpha(transtablenum);
+	pSurf->PolyColor.s.alpha = alpha;
 	return HWR_GetBlendModeFlag(style);
 }
 
@@ -745,7 +724,7 @@ FBITFIELD HWR_TranstableToAlpha(INT32 transtablenum, FSurfaceInfo *pSurf)
 		return PF_Masked;
 	}
 
-	pSurf->PolyColor.s.alpha = HWR_GetTranstableAlpha(transtablenum);
+	pSurf->PolyColor.s.alpha = R_TransnumToAlpha(transtablenum);
 	return PF_Translucent;
 }
 
@@ -3760,8 +3739,8 @@ static void HWR_SplitSprite(gl_vissprite_t *spr)
 	FBITFIELD blend = 0;
 	FBITFIELD occlusion;
 	INT32 shader = SHADER_DEFAULT;
+	INT32 alpha;
 	boolean use_linkdraw_hack = false;
-	UINT8 alpha;
 
 	INT32 i;
 	float realtop, realbot, top, bot;
@@ -3853,37 +3832,18 @@ static void HWR_SplitSprite(gl_vissprite_t *spr)
 	else
 		occlusion = PF_Occlude;
 
-	INT32 blendmode;
-	if (spr->mobj->frame & FF_BLENDMASK)
-		blendmode = ((spr->mobj->frame & FF_BLENDMASK) >> FF_BLENDSHIFT) + 1;
-	else
-		blendmode = spr->mobj->blendmode;
+	alpha = spr->alpha;
 
-	if (!cv_translucency.value) // translucency disabled
-	{
-		Surf.PolyColor.s.alpha = 0xFF;
-		blend = PF_Translucent|occlusion;
-		if (!occlusion) use_linkdraw_hack = true;
-	}
-	else if (spr->mobj->flags2 & MF2_SHADOW)
-	{
-		Surf.PolyColor.s.alpha = 0x40;
-		blend = HWR_GetBlendModeFlag(blendmode);
-	}
-	else if (spr->mobj->frame & FF_TRANSMASK)
+	if (spr->translucent)
 	{
-		INT32 trans = (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT;
-		blend = HWR_SurfaceBlend(blendmode, trans, &Surf);
+		blend = HWR_SurfaceBlend(spr->blendmode, alpha, &Surf);
 	}
 	else
 	{
-		// BP: i agree that is little better in environement but it don't
-		//     work properly under glide nor with fogcolor to ffffff :(
-		// Hurdler: PF_Environement would be cool, but we need to fix
-		//          the issue with the fog before
 		Surf.PolyColor.s.alpha = 0xFF;
-		blend = HWR_GetBlendModeFlag(blendmode)|occlusion;
-		if (!occlusion) use_linkdraw_hack = true;
+		blend = HWR_GetBlendModeFlag(spr->blendmode) | occlusion;
+		if (!occlusion)
+			use_linkdraw_hack = true;
 	}
 
 	if (HWR_UseShader())
@@ -3892,8 +3852,6 @@ static void HWR_SplitSprite(gl_vissprite_t *spr)
 		blend |= PF_ColorMapped;
 	}
 
-	alpha = Surf.PolyColor.s.alpha;
-
 	// Start with the lightlevel and colormap from the top of the sprite
 	lightlevel = *list[sector->numlights - 1].lightlevel;
 	if (!(spr->mobj->renderflags & RF_NOCOLORMAPS))
@@ -4297,49 +4255,16 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
 		else
 			occlusion = PF_Occlude;
 
-		INT32 blendmode;
-		if (spr->mobj->frame & FF_BLENDMASK)
-			blendmode = ((spr->mobj->frame & FF_BLENDMASK) >> FF_BLENDSHIFT) + 1;
-		else
-			blendmode = spr->mobj->blendmode;
-
-		if (!cv_translucency.value) // translucency disabled
+		if (spr->translucent)
 		{
-			Surf.PolyColor.s.alpha = 0xFF;
-			blend = PF_Translucent|occlusion;
-			if (!occlusion) use_linkdraw_hack = true;
-		}
-		else if (spr->mobj->flags2 & MF2_SHADOW)
-		{
-			Surf.PolyColor.s.alpha = 0x40;
-			blend = HWR_GetBlendModeFlag(blendmode);
-		}
-		else if (spr->mobj->frame & FF_TRANSMASK)
-		{
-			INT32 trans = (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT;
-			blend = HWR_SurfaceBlend(blendmode, trans, &Surf);
+			blend = HWR_SurfaceBlend(spr->blendmode, spr->alpha, &Surf);
 		}
 		else
 		{
-			// BP: i agree that is little better in environement but it don't
-			//     work properly under glide nor with fogcolor to ffffff :(
-			// Hurdler: PF_Environement would be cool, but we need to fix
-			//          the issue with the fog before
 			Surf.PolyColor.s.alpha = 0xFF;
-			blend = HWR_GetBlendModeFlag(blendmode)|occlusion;
-			if (!occlusion) use_linkdraw_hack = true;
-		}
-
-		if (spr->renderflags & RF_SHADOWEFFECTS)
-		{
-			INT32 alpha = Surf.PolyColor.s.alpha;
-			alpha -= ((INT32)(spr->shadowheight / 4.0f)) + 75;
-			if (alpha < 1)
-				return;
-
-			Surf.PolyColor.s.alpha = (UINT8)(alpha);
-			blend = PF_Translucent|occlusion;
-			if (!occlusion) use_linkdraw_hack = true;
+			blend = HWR_GetBlendModeFlag(spr->blendmode) | occlusion;
+			if (!occlusion)
+				use_linkdraw_hack = true;
 		}
 
 		if (HWR_UseShader())
@@ -4433,19 +4358,14 @@ static inline void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
 		HWR_Lighting(&Surf, lightlevel, colormap);
 	}
 
-	if (spr->mobj->frame & FF_TRANSMASK)
+	if (spr->translucent)
 	{
-		INT32 trans = (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT;
-		blend = HWR_SurfaceBlend(AST_TRANSLUCENT, trans, &Surf);
+		blend = HWR_SurfaceBlend(spr->blendmode, spr->alpha, &Surf);
 	}
 	else
 	{
-		// BP: i agree that is little better in environement but it don't
-		//     work properly under glide nor with fogcolor to ffffff :(
-		// Hurdler: PF_Environement would be cool, but we need to fix
-		//          the issue with the fog before
 		Surf.PolyColor.s.alpha = 0xFF;
-		blend = HWR_GetBlendModeFlag(spr->mobj->blendmode)|PF_Occlude;
+		blend = HWR_GetBlendModeFlag(spr->blendmode);
 	}
 
 	if (HWR_UseShader())
@@ -4999,6 +4919,9 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	boolean vflip = (!(thing->eflags & MFE_VERTICALFLIP) != !R_ThingVerticallyFlipped(thing));
 	boolean mirrored = thing->mirrored;
 	boolean hflip = (!R_ThingHorizontallyFlipped(thing) != !mirrored);
+	INT32 blendmode, alpha = 255;
+	boolean translucent = false;
+	UINT32 trans;
 	INT32 dispoffset;
 
 	angle_t ang;
@@ -5020,22 +4943,32 @@ static void HWR_ProjectSprite(mobj_t *thing)
 	if (!thing)
 		return;
 
-	INT32 blendmode;
+	// Get the blend mode
 	if (thing->frame & FF_BLENDMASK)
 		blendmode = ((thing->frame & FF_BLENDMASK) >> FF_BLENDSHIFT) + 1;
 	else
-		blendmode = thing->blendmode;
+		blendmode = min(max(AST_COPY, thing->blendmode), AST_OVERLAY);
 
-	// Visibility check by the blend mode.
-	if (thing->frame & FF_TRANSMASK)
+	// Determine the translucency value.
+	if (thing->flags2 & MF2_SHADOW) // actually only the player should use this (temporary invisibility)
+		trans = tr_trans80; // because now the translucency is set through FF_TRANSMASK
+	else if (thing->frame & FF_TRANSMASK)
+		trans = (thing->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
+	else
+		trans = 0;
+
+	if (cv_translucency.value && blendmode != AST_COPY && blendmode != AST_OVERLAY)
 	{
-		if (!R_BlendLevelVisible(blendmode, (thing->frame & FF_TRANSMASK)>>FF_TRANSSHIFT))
+		alpha = thing->alpha - (0xFF - R_BlendModeTransnumToAlpha(blendmode, trans));
+
+		if (!R_BlendLevelVisible(blendmode, alpha))
 			return;
+
+		translucent = true;
 	}
 
 	dispoffset = thing->dispoffset;
 
-
 	if (R_UsingFrameInterpolation() && !paused)
 	{
 		R_InterpolateMobjState(thing, rendertimefrac, &interp);
@@ -5261,12 +5194,22 @@ static void HWR_ProjectSprite(mobj_t *thing)
 			shadowheight = FIXED_TO_FLOAT(floordiff);
 			shadowscale = FIXED_TO_FLOAT(FixedMul(FRACUNIT - floordiff/640, casterinterp.scale));
 
+			if (translucent)
+			{
+				alpha -= ((INT32)(shadowheight / 4.0f)) + 75;
+
+				if (!R_BlendLevelVisible(blendmode, alpha))
+					return;
+			}
+
 			if (splat)
 				spritexscale *= shadowscale;
 			spriteyscale *= shadowscale;
 		}
 	}
 
+	translucent = !(blendmode == AST_TRANSLUCENT && alpha >= 255);
+
 	this_xscale = spritexscale * this_scale;
 	this_yscale = spriteyscale * this_scale;
 
@@ -5289,18 +5232,6 @@ static void HWR_ProjectSprite(mobj_t *thing)
 			x2 = (FIXED_TO_FLOAT(spr_width - spr_offset) * this_xscale);
 		}
 
-		// test if too close
-	/*
-		if (papersprite)
-		{
-			z1 = tz - x1 * angle_scalez;
-			z2 = tz + x2 * angle_scalez;
-
-			if (max(z1, z2) < ZCLIP_PLANE)
-				return;
-		}
-	*/
-
 		z1 = tr_y + x1 * rightsin;
 		z2 = tr_y - x2 * rightsin;
 		x1 = tr_x + x1 * rightcos;
@@ -5473,6 +5404,9 @@ static void HWR_ProjectSprite(mobj_t *thing)
 
 	vis->precip = false;
 
+	vis->translucent = translucent;
+	vis->blendmode = blendmode;
+	vis->alpha = alpha;
 	vis->angle = interp.angle;
 }
 
@@ -5491,15 +5425,33 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing)
 	size_t lumpoff;
 	unsigned rot = 0;
 	UINT8 flip;
+	INT32 blendmode, alpha = 255;
+	boolean translucent = false;
+	UINT32 trans;
 
 	if (!thing)
 		return;
 
-	// Visibility check by the blend mode.
+	// Get the blend mode
+	if (thing->frame & FF_BLENDMASK)
+		blendmode = ((thing->frame & FF_BLENDMASK) >> FF_BLENDSHIFT) + 1;
+	else
+		blendmode = min(max(AST_COPY, thing->blendmode), AST_OVERLAY);
+
+	// Determine the translucency value.
 	if (thing->frame & FF_TRANSMASK)
+		trans = (thing->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
+	else
+		trans = 0;
+
+	if (cv_translucency.value && blendmode != AST_COPY && blendmode != AST_OVERLAY)
 	{
-		if (!R_BlendLevelVisible(thing->blendmode, (thing->frame & FF_TRANSMASK)>>FF_TRANSSHIFT))
+		alpha = thing->alpha - (0xFF - R_BlendModeTransnumToAlpha(blendmode, trans));
+
+		if (!R_BlendLevelVisible(blendmode, alpha))
 			return;
+
+		translucent = !(blendmode == AST_TRANSLUCENT && alpha >= 255);
 	}
 
 	// uncapped/interpolation
@@ -5595,6 +5547,10 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing)
 
 	vis->precip = true;
 
+	vis->translucent = translucent;
+	vis->blendmode = blendmode;
+	vis->alpha = alpha;
+
 	// okay... this is a hack, but weather isn't networked, so it should be ok
 	if (!(thing->precipflags & PCF_THUNK))
 	{

src/hardware/hw_main.h

@@ -42,7 +42,7 @@ void HWR_SetViewSize(void);
 void HWR_DrawPatch(patch_t *gpatch, INT32 x, INT32 y, INT32 option);
 void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap);
 void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, fixed_t sx, fixed_t sy, fixed_t w, fixed_t h);
-void HWR_MakePatch(const patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipmap, boolean makebitmap);
+void HWR_MakePatch(patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipmap, boolean makebitmap);
 void HWR_CreatePlanePolygons(INT32 bspnum);
 void HWR_CreateStaticLightmaps(INT32 bspnum);
 void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color);
@@ -70,9 +70,8 @@ void HWR_DrawScreenFinalTexture(int width, int height);
 void HWR_Lighting(FSurfaceInfo *Surface, INT32 light_level, extracolormap_t *colormap);
 UINT8 HWR_FogBlockAlpha(INT32 light, extracolormap_t *colormap); // Let's see if this can work
 
-UINT8 HWR_GetTranstableAlpha(INT32 transtablenum);
 FBITFIELD HWR_GetBlendModeFlag(INT32 style);
-FBITFIELD HWR_SurfaceBlend(INT32 style, INT32 transtablenum, FSurfaceInfo *pSurf);
+FBITFIELD HWR_SurfaceBlend(INT32 style, INT32 alpha, FSurfaceInfo *pSurf);
 FBITFIELD HWR_TranstableToAlpha(INT32 transtablenum, FSurfaceInfo *pSurf);
 
 boolean HWR_CompileShaders(void);

src/hardware/hw_md2.c

@@ -415,7 +415,7 @@ static void md2_loadTexture(md2_t *model)
 		size = w*h;
 		while (size--)
 		{
-			V_CubeApply(&image->s.red, &image->s.green, &image->s.blue);
+			ColorCube_Apply(&image->s.red, &image->s.green, &image->s.blue);
 			image++;
 		}
 	}

src/hu_stuff.c

@@ -2095,7 +2095,7 @@ void HU_Erase(void)
 		return;
 
 	// software mode copies view border pattern & beveled edges from the backbuffer
-	if (rendermode == render_soft)
+	if (VID_InSoftwareRenderer())
 	{
 		topline = 0;
 		for (y = topline, yoffset = y*vid.width; y < bottomline; y++, yoffset += vid.width)

src/i_video.h

@@ -22,14 +22,15 @@
 
 typedef enum
 {
-	/// Software
-	render_soft = 1,
+	// Software renderers
+	render_software = 1,
+	render_software_truecolor,
 
-	/// OpenGL
-	render_opengl = 2,
+	// OpenGL
+	render_opengl,
 
-	/// Dedicated
-	render_none = 3  // for dedicated server
+	// Dedicated mode
+	render_none,
 } rendermode_t;
 
 /**	\brief current render mode
@@ -44,6 +45,10 @@ extern rendermode_t chosenrendermode;
 */
 extern boolean highcolor;
 
+/**	\brief use truecolor modes if true
+*/
+extern boolean truecolor;
+
 /**	\brief setup video mode
 */
 void I_StartupGraphics(void);
@@ -101,6 +106,15 @@ void VID_StartupOpenGL(void);
 */
 void VID_CheckGLLoaded(rendermode_t oldrender);
 
+/**	\brief Returns true if mode is a Software renderer.
+	\param mode A render mode.
+*/
+boolean VID_IsASoftwareRenderer(rendermode_t mode);
+
+/**	\brief Returns true if the current rendermode.
+*/
+boolean VID_InSoftwareRenderer(void);
+
 /**	\brief	The VID_GetModeName function
 
 	\param	modenum	video mode number

src/lua_baselib.c

@@ -452,7 +452,7 @@ static int lib_pAproxDistance(lua_State *L)
 	fixed_t dx = luaL_checkfixed(L, 1);
 	fixed_t dy = luaL_checkfixed(L, 2);
 	//HUDSAFE
-	lua_pushfixed(L, P_AproxDistance(dx, dy));
+	lua_pushfixed(L, R_PointToDist2(0, 0, dx, dy));
 	return 1;
 }
 

src/lua_hudlib.c

@@ -1226,11 +1226,24 @@ static int libd_dupy(lua_State *L)
 static int libd_renderer(lua_State *L)
 {
 	HUDONLY
-	switch (rendermode) {
-		case render_opengl: lua_pushliteral(L, "opengl");   break; // OpenGL renderer
-		case render_soft:   lua_pushliteral(L, "software"); break; // Software renderer
-		default:            lua_pushliteral(L, "none");     break; // render_none (for dedicated), in case there's any reason this should be run
+
+	switch (rendermode)
+	{
+		// Software renderers
+		case render_software:
+		case render_software_truecolor:
+			lua_pushliteral(L, "software");
+			break;
+		// OpenGL renderer
+		case render_opengl:
+			lua_pushliteral(L, "opengl");
+			break;
+		// render_none (for dedicated), in case there's any reason this should be run
+		default:
+			lua_pushliteral(L, "none");
+			break;
 	}
+
 	return 1;
 }
 

src/lua_mobjlib.c

@@ -63,6 +63,7 @@ enum mobj_e {
 	mobj_renderflags,
 	mobj_skin,
 	mobj_color,
+	mobj_alpha,
 	mobj_blendmode,
 	mobj_bnext,
 	mobj_bprev,
@@ -140,6 +141,7 @@ static const char *const mobj_opt[] = {
 	"renderflags",
 	"skin",
 	"color",
+	"alpha",
 	"blendmode",
 	"bnext",
 	"bprev",
@@ -320,6 +322,9 @@ static int mobj_get(lua_State *L)
 	case mobj_color:
 		lua_pushinteger(L, mo->color);
 		break;
+	case mobj_alpha:
+		lua_pushinteger(L, mo->alpha);
+		break;
 	case mobj_blendmode:
 		lua_pushinteger(L, mo->blendmode);
 		break;
@@ -661,6 +666,14 @@ static int mobj_set(lua_State *L)
 		mo->color = newcolor;
 		break;
 	}
+	case mobj_alpha:
+	{
+		INT32 newalpha = (INT32)luaL_checkinteger(L,3);
+		if (newalpha < 0 || newalpha > 255)
+			return luaL_error(L, "mobj.alpha %d out of range (0 - 255).", newalpha);
+		mo->alpha = newalpha;
+		break;
+	}
 	case mobj_blendmode:
 	{
 		INT32 blendmode = (INT32)luaL_checkinteger(L, 3);

src/m_anigif.c

@@ -508,11 +508,11 @@ static size_t gifframe_size = 8192;
 #ifdef HWRENDER
 static colorlookup_t gif_colorlookup;
 
-static void GIF_rgbconvert(UINT8 *linear, UINT8 *scr)
+static void GIF_rgbconvert(UINT8 *linear, UINT8 *scr, size_t bpp)
 {
 	UINT8 r, g, b;
 	size_t src = 0, dest = 0;
-	size_t size = (vid.width * vid.height * 3);
+	size_t size = (vid.width * vid.height * bpp);
 
 	InitColorLUT(&gif_colorlookup, (gif_localcolortable) ? gif_framepalette : gif_headerpalette, true);
 
@@ -522,11 +522,10 @@ static void GIF_rgbconvert(UINT8 *linear, UINT8 *scr)
 		g = (UINT8)linear[src + 1];
 		b = (UINT8)linear[src + 2];
 		scr[dest] = GetColorLUTDirect(&gif_colorlookup, r, g, b);
-		src += (3 * scrbuf_downscaleamt);
+		src += (bpp * scrbuf_downscaleamt);
 		dest += scrbuf_downscaleamt;
 	}
 }
-#endif
 
 //
 // GIF_framewrite
@@ -561,17 +560,31 @@ static void GIF_framewrite(void)
 	{
 		// before blit movie_screen points to last frame, cur_screen points to this frame
 		UINT8 *cur_screen = screens[0];
+#ifdef TRUECOLOR
+		if (VID_InSoftwareRenderer() && truecolor)
+		{
+			cur_screen = screens[2] + (vid.width * vid.height);
+			GIF_rgbconvert(screens[0], cur_screen, 4);
+		}
+#endif
 		GIF_optimizeregion(cur_screen, movie_screen, &blitx, &blity, &blitw, &blith);
 
 		// blit to temp screen
-		if (rendermode == render_soft)
-			I_ReadScreen(movie_screen);
+		if (VID_InSoftwareRenderer())
+		{
+#ifdef TRUECOLOR
+			if (truecolor)
+				GIF_rgbconvert(screens[0], movie_screen, 4);
+			else
+#endif
+				I_ReadScreen(movie_screen);
+		}
 #ifdef HWRENDER
 		else if (rendermode == render_opengl)
 		{
-			UINT8 *linear = HWR_GetScreenshot();
-			GIF_rgbconvert(linear, movie_screen);
-			free(linear);
+			UINT8 *sshot = HWR_GetScreenshot();
+			GIF_rgbconvert(sshot, movie_screen, 3);
+			free(sshot);
 		}
 #endif
 	}
@@ -581,22 +594,43 @@ static void GIF_framewrite(void)
 		blitw = vid.width;
 		blith = vid.height;
 
-#ifdef HWRENDER
-		// Copy the current OpenGL frame into the base screen
-		if (rendermode == render_opengl)
+		if (gif_frames == 0)
 		{
-			UINT8 *linear = HWR_GetScreenshot();
-			GIF_rgbconvert(linear, screens[0]);
-			free(linear);
+#ifdef HWRENDER
+			if (rendermode == render_opengl)
+			{
+				UINT8 *sshot = HWR_GetScreenshot();
+				GIF_rgbconvert(sshot, screens[0], 3);
+				free(sshot);
+			}
+			else
+#endif
+			if (VID_InSoftwareRenderer())
+			{
+#ifdef TRUECOLOR
+				if (truecolor)
+					GIF_rgbconvert(screens[0], movie_screen, 4);
+				else
+#endif
+					I_ReadScreen(movie_screen);
+			}
 		}
 #endif
 
 		// Copy the first frame into the movie screen
 		// OpenGL already does the same above.
-		if (gif_frames == 0 && rendermode == render_soft)
+		if (gif_frames == 0 && VID_InSoftwareRenderer())
 			I_ReadScreen(movie_screen);
 
 		movie_screen = screens[0];
+#ifdef TRUECOLOR
+		if (VID_InSoftwareRenderer() && truecolor)
+		{
+			UINT8 *blit = screens[2] + (vid.width * vid.height);
+			GIF_rgbconvert(screens[0], blit, 4);
+			movie_screen = blit;
+		}
+#endif
 	}
 
 	// screen regions are handled in GIF_lzw