Strife: add true color support

src/doom/r_things.c

@@ -544,7 +544,7 @@ R_DrawVisSprite
 
     colfunc = basecolfunc;
 #ifdef CRISPY_TRUECOLOR
-    blendfunc = I_BlendOver;
+    blendfunc = I_BlendOverTranmap;
 #endif
 }
 
@@ -817,7 +817,7 @@ void R_ProjectSprite (mobj_t* thing)
     // [crispy] translucent sprites
     if (thing->flags & MF_TRANSLUCENT)
     {
-	vis->blendfunc = (thing->frame & FF_FULLBRIGHT) ? I_BlendAdd : I_BlendOver;
+	vis->blendfunc = (thing->frame & FF_FULLBRIGHT) ? I_BlendAdd : I_BlendOverTranmap;
     }
 #endif
 }
@@ -1079,7 +1079,7 @@ void R_DrawPSprite (pspdef_t* psp, psprnum_t psprnum) // [crispy] differentiate
     {
         vis->mobjflags |= MF_TRANSLUCENT;
 #ifdef CRISPY_TRUECOLOR
-        vis->blendfunc = I_BlendOver; // I_BlendAdd;
+        vis->blendfunc = I_BlendOverTranmap; // I_BlendAdd;
 #endif
     }
 

src/i_video.c

@@ -103,9 +103,6 @@ static SDL_Texture *graypane = NULL;
 static SDL_Texture *orngpane = NULL;
 static int pane_alpha;
 static unsigned int rmask, gmask, bmask, amask; // [crispy] moved up here
-static const uint8_t blend_alpha = 0xa8;
-static const uint8_t blend_alpha_tinttab = 0x60; // 96
-static const uint8_t blend_alpha_alttinttab = 0x8E; // 142
 extern pixel_t* pal_color; // [crispy] evil hack to get FPS dots working as in Vanilla
 #else
 static SDL_Color palette[256];
@@ -2136,36 +2133,47 @@ const pixel_t I_BlendDark (const pixel_t bg, const int d)
 	return amask | sag | srb;
 }
 
-const pixel_t I_BlendOver (const pixel_t bg, const pixel_t fg)
+// [crispy] Main overlay blending function
+const pixel_t I_BlendOver (const pixel_t bg, const pixel_t fg, const int amount)
 {
-	const uint32_t r = ((blend_alpha * (fg & rmask) + (0xff - blend_alpha) * (bg & rmask)) >> 8) & rmask;
-	const uint32_t g = ((blend_alpha * (fg & gmask) + (0xff - blend_alpha) * (bg & gmask)) >> 8) & gmask;
-	const uint32_t b = ((blend_alpha * (fg & bmask) + (0xff - blend_alpha) * (bg & bmask)) >> 8) & bmask;
+	const uint32_t r = ((amount * (fg & rmask) + (0xff - amount) * (bg & rmask)) >> 8) & rmask;
+	const uint32_t g = ((amount * (fg & gmask) + (0xff - amount) * (bg & gmask)) >> 8) & gmask;
+	const uint32_t b = ((amount * (fg & bmask) + (0xff - amount) * (bg & bmask)) >> 8) & bmask;
 
 	return amask | r | g | b;
 }
 
+// [crispy] TRANMAP blending emulation, used for Doom
+const pixel_t I_BlendOverTranmap (const pixel_t bg, const pixel_t fg)
+{
+	return I_BlendOver(bg, fg, 224); // 168 (66% opacity)
+}
+
 // [crispy] TINTTAB blending emulation, used for Heretic and Hexen
 const pixel_t I_BlendOverTinttab (const pixel_t bg, const pixel_t fg)
 {
-	const uint32_t r = ((blend_alpha_tinttab * (fg & rmask) + (0xff - blend_alpha_tinttab) * (bg & rmask)) >> 8) & rmask;
-	const uint32_t g = ((blend_alpha_tinttab * (fg & gmask) + (0xff - blend_alpha_tinttab) * (bg & gmask)) >> 8) & gmask;
-	const uint32_t b = ((blend_alpha_tinttab * (fg & bmask) + (0xff - blend_alpha_tinttab) * (bg & bmask)) >> 8) & bmask;
-
-	return amask | r | g | b;
+	return I_BlendOver(bg, fg, 0x60); // 96 (38% opacity)
 }
 
 // [crispy] More opaque ("Alt") TINTTAB blending emulation, used for Hexen's MF_ALTSHADOW drawing
 const pixel_t I_BlendOverAltTinttab (const pixel_t bg, const pixel_t fg)
 {
-	const uint32_t r = ((blend_alpha_alttinttab * (fg & rmask) + (0xff - blend_alpha_alttinttab) * (bg & rmask)) >> 8) & rmask;
-	const uint32_t g = ((blend_alpha_alttinttab * (fg & gmask) + (0xff - blend_alpha_alttinttab) * (bg & gmask)) >> 8) & gmask;
-	const uint32_t b = ((blend_alpha_alttinttab * (fg & bmask) + (0xff - blend_alpha_alttinttab) * (bg & bmask)) >> 8) & bmask;
+	return I_BlendOver(bg, fg, 0x8E); // 142 (56% opacity)
+}
 
-	return amask | r | g | b;
+// [crispy] More opaque XLATAB blending emulation, used for Strife
+const pixel_t I_BlendOverXlatab (const pixel_t bg, const pixel_t fg)
+{
+	return I_BlendOver(bg, fg, 0xC0); // 192 (75% opacity)
+}
+
+// [crispy] Less opaque ("Alt") XLATAB blending emulation, used for Strife
+const pixel_t I_BlendOverAltXlatab (const pixel_t bg, const pixel_t fg)
+{
+	return I_BlendOver(bg, fg, 0x40); // 64 (25% opacity)
 }
 
-const pixel_t (*blendfunc) (const pixel_t fg, const pixel_t bg) = I_BlendOver;
+const pixel_t (*blendfunc) (const pixel_t fg, const pixel_t bg) = I_BlendOverTranmap;
 
 const pixel_t I_MapRGB (const uint8_t r, const uint8_t g, const uint8_t b)
 {

src/strife/am_map.c

@@ -1235,7 +1235,12 @@ AM_drawFline_Vanilla
 	return;
     }
 
-#define PUTDOT(xx,yy,cc) fb[(yy)*f_w+(xx)]=(cc)
+#define PUTDOT_RAW(xx,yy,cc) fb[(yy)*f_w+(xx)]=(cc)
+#ifndef CRISPY_TRUECOLOR
+#define PUTDOT(xx,yy,cc) PUTDOT_RAW(xx,yy,cc)
+#else
+#define PUTDOT(xx,yy,cc) PUTDOT_RAW(xx,yy,(pal_color[(cc)]))
+#endif
 
     dx = fl->b.x - fl->a.x;
     ax = 2 * (dx<0 ? -dx : dx);
@@ -1307,7 +1312,7 @@ static void AM_drawFline_Smooth(fline_t* fl, int color)
        the line and so needs no weighting */
     /* Always write the raw color value because we've already performed the necessary lookup
      * into colormap */
-    PUTDOT(X0, Y0, BaseColor[0]);
+    PUTDOT_RAW(X0, Y0, BaseColor[0]);
 
     if ((DeltaX = X1 - X0) >= 0)
     {
@@ -1327,7 +1332,7 @@ static void AM_drawFline_Smooth(fline_t* fl, int color)
         while (DeltaX-- != 0)
         {
             X0 += XDir;
-            PUTDOT(X0, Y0, BaseColor[0]);
+            PUTDOT_RAW(X0, Y0, BaseColor[0]);
         }
         return;
     }
@@ -1337,7 +1342,7 @@ static void AM_drawFline_Smooth(fline_t* fl, int color)
         do
         {
             Y0++;
-            PUTDOT(X0, Y0, BaseColor[0]);
+            PUTDOT_RAW(X0, Y0, BaseColor[0]);
         }
         while (--DeltaY != 0);
         return;
@@ -1349,7 +1354,7 @@ static void AM_drawFline_Smooth(fline_t* fl, int color)
         {
             X0 += XDir;
             Y0++;
-            PUTDOT(X0, Y0, BaseColor[0]);
+            PUTDOT_RAW(X0, Y0, BaseColor[0]);
         }
         while (--DeltaY != 0);
         return;
@@ -1383,12 +1388,12 @@ static void AM_drawFline_Smooth(fline_t* fl, int color)
                intensity weighting for this pixel, and the complement of the
                weighting for the paired pixel */
             Weighting = ErrorAcc >> IntensityShift;
-            PUTDOT(X0, Y0, BaseColor[Weighting]);
-            PUTDOT(X0 + XDir, Y0, BaseColor[(Weighting ^ WeightingComplementMask)]);
+            PUTDOT_RAW(X0, Y0, BaseColor[Weighting]);
+            PUTDOT_RAW(X0 + XDir, Y0, BaseColor[(Weighting ^ WeightingComplementMask)]);
         }
         /* Draw the final pixel, which is always exactly intersected by the line
            and so needs no weighting */
-        PUTDOT(X1, Y1, BaseColor[0]);
+        PUTDOT_RAW(X1, Y1, BaseColor[0]);
         return;
     }
     /* It's an X-major line; calculate 16-bit fixed-point fractional part of a
@@ -1410,13 +1415,13 @@ static void AM_drawFline_Smooth(fline_t* fl, int color)
            intensity weighting for this pixel, and the complement of the
            weighting for the paired pixel */
         Weighting = ErrorAcc >> IntensityShift;
-        PUTDOT(X0, Y0, BaseColor[Weighting]);
-        PUTDOT(X0, Y0 + 1, BaseColor[(Weighting ^ WeightingComplementMask)]);
+        PUTDOT_RAW(X0, Y0, BaseColor[Weighting]);
+        PUTDOT_RAW(X0, Y0 + 1, BaseColor[(Weighting ^ WeightingComplementMask)]);
 
     }
     /* Draw the final pixel, which is always exactly intersected by the line
        and so needs no weighting */
-    PUTDOT(X1, Y1, BaseColor[0]);
+    PUTDOT_RAW(X1, Y1, BaseColor[0]);
 }
 
 //
@@ -1885,7 +1890,11 @@ void AM_Drawer (void)
 
     if (!crispy->automapoverlay)
     {
+#ifndef CRISPY_TRUECOLOR
         AM_clearFB(BACKGROUND);
+#else
+        AM_clearFB(pal_color[BACKGROUND]);
+#endif
         pspr_interp = false; // [crispy] interpolate weapon bobbing
     }
 

src/strife/d_main.c

@@ -292,7 +292,11 @@ void D_Display (void)
 
     // clean up border stuff
     if (gamestate != oldgamestate && gamestate != GS_LEVEL)
+#ifndef CRISPY_TRUECOLOR
         I_SetPalette (W_CacheLumpName (DEH_String("PLAYPAL"),PU_CACHE));
+#else
+        I_SetPalette (0);
+#endif
 
     // see if the border needs to be initially drawn
     if (gamestate == GS_LEVEL && oldgamestate != GS_LEVEL)
@@ -537,6 +541,9 @@ void D_BindVariables(void)
     M_BindIntVariable("crispy_soundfix",        &crispy->soundfix);
     M_BindIntVariable("crispy_soundfull",       &crispy->soundfull);
     M_BindIntVariable("crispy_soundmono",       &crispy->soundmono);
+#ifdef CRISPY_TRUECOLOR
+    M_BindIntVariable("crispy_truecolor",       &crispy->truecolor);
+#endif
     M_BindIntVariable("crispy_uncapped",        &crispy->uncapped);
     M_BindIntVariable("crispy_vsync",           &crispy->vsync);
     M_BindIntVariable("crispy_widescreen",      &crispy->widescreen);
@@ -2024,6 +2031,11 @@ void D_DoomMain (void)
 
     I_GraphicsCheckCommandLine();
 
+    // [crispy] Initialize and generate gamma-correction levels and
+    // colormaps/pal_color arrays before introduction sequence.
+    I_SetGammaTable();
+    R_InitColormaps();
+
     // haleyjd 20110206 [STRIFE] Startup the introduction sequence
     D_InitIntroSequence();