Port RR´s gamma correction + split gamma and brightness
port of https://gitlab.com/kart-krew-dev/ring-racers/-/commit/e27506c660933e19dbcfe9ec776caf7819952e30 not cherry picked since it differs too much it would be hellish to untangle (sry!) Gamma is split from brightness since both do somewhat different things in the context here
This commit is contained in:
1 parent
28685ea658
commit
8cc73bc482
7 files changed
+141
-110
No files matched your search
@@ -458,8 +458,8 @@ void HWR_Lighting(FSurfaceInfo *Surface, INT32 light_level, extracolormap_t *col
|
||||
// in palette rendering mode, this is not needed since it properly takes the changes to the palette itself
|
||||
if (!HWR_ShouldUsePaletteRendering())
|
||||
{
|
||||
V_CubeApply(&tint_color.s.red, &tint_color.s.green, &tint_color.s.blue);
|
||||
V_CubeApply(&fade_color.s.red, &fade_color.s.green, &fade_color.s.blue);
|
||||
V_CubeApply(&tint_color);
|
||||
V_CubeApply(&fade_color);
|
||||
}
|
||||
|
||||
Surface->PolyColor.rgba = poly_color.rgba;
|
||||
@@ -5962,7 +5962,7 @@ static void HWR_DoPostProcessor(player_t *player)
|
||||
|
||||
Surf.PolyColor.s.alpha = 0xc0; // match software mode
|
||||
|
||||
V_CubeApply(&Surf.PolyColor.s.red, &Surf.PolyColor.s.green, &Surf.PolyColor.s.blue);
|
||||
V_CubeApply(&Surf.PolyColor);
|
||||
|
||||
GL_DrawPolygon(&Surf, v, 4, PF_Modulated|PF_Translucent|PF_NoTexture|PF_NoDepthTest);
|
||||
}
|
||||
|
||||
@@ -417,7 +417,7 @@ static void md2_loadTexture(md2_t *model)
|
||||
size = w*h;
|
||||
while (size--)
|
||||
{
|
||||
V_CubeApply(&image->s.red, &image->s.green, &image->s.blue);
|
||||
V_CubeApply(image);
|
||||
image++;
|
||||
}
|
||||
}
|
||||
|
||||
+28
-22
@@ -818,26 +818,31 @@ static menuitem_t OP_VideoOptionsMenu[] =
|
||||
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
|
||||
{IT_STRING|IT_CVAR, NULL, "Fullscreen", &cv_fullscreen, 20},
|
||||
#endif
|
||||
#ifdef BACKWARDSCOMPATCORRECTION
|
||||
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
|
||||
NULL, "Brightness", &cv_globalgamma, 30},
|
||||
|
||||
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
|
||||
NULL, "Saturation", &cv_globalsaturation , 40},
|
||||
|
||||
{IT_SUBMENU|IT_STRING, NULL, "Advanced Color Settings...", &OP_ColorOptionsDef, 50},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Draw Distance", &cv_drawdist, 65},
|
||||
{IT_STRING | IT_CVAR, NULL, "Weather Draw Distance", &cv_drawdist_precip, 75},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Show FPS", &cv_ticrate, 95},
|
||||
{IT_STRING | IT_CVAR, NULL, "Vertical Sync", &cv_vidwait, 105},
|
||||
{IT_STRING | IT_CVAR, NULL, "FPS Cap", &cv_fpscap, 115},
|
||||
{IT_STRING | IT_CVAR, NULL, "Drift spark pulse size", &cv_driftsparkpulse, 125},
|
||||
{IT_STRING | IT_CVAR, NULL, "VHS effect", &cv_vhseffect, 135},
|
||||
#ifdef HWRENDER
|
||||
{IT_SUBMENU|IT_STRING, NULL, "OpenGL Options...", &OP_OpenGLOptionsDef, 145},
|
||||
NULL, "Gamma", &cv_globalgamma, 30},
|
||||
#endif
|
||||
{IT_SUBMENU|IT_STRING, NULL, "Advanced Video Options...", &OP_ExpOptionsDef, 155},
|
||||
|
||||
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
|
||||
NULL, "Brightness", &cv_globalbrightness, 40},
|
||||
|
||||
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
|
||||
NULL, "Saturation", &cv_globalsaturation , 50},
|
||||
|
||||
{IT_SUBMENU|IT_STRING, NULL, "Advanced Color Settings...", &OP_ColorOptionsDef, 60},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Draw Distance", &cv_drawdist, 75},
|
||||
{IT_STRING | IT_CVAR, NULL, "Weather Draw Distance", &cv_drawdist_precip, 85},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Show FPS", &cv_ticrate, 105},
|
||||
{IT_STRING | IT_CVAR, NULL, "Vertical Sync", &cv_vidwait, 115},
|
||||
{IT_STRING | IT_CVAR, NULL, "FPS Cap", &cv_fpscap, 125},
|
||||
{IT_STRING | IT_CVAR, NULL, "Drift spark pulse size", &cv_driftsparkpulse, 135},
|
||||
{IT_STRING | IT_CVAR, NULL, "VHS effect", &cv_vhseffect, 145},
|
||||
#ifdef HWRENDER
|
||||
{IT_SUBMENU|IT_STRING, NULL, "OpenGL Options...", &OP_OpenGLOptionsDef, 155},
|
||||
#endif
|
||||
{IT_SUBMENU|IT_STRING, NULL, "Advanced Video Options...", &OP_ExpOptionsDef, 165},
|
||||
};
|
||||
|
||||
static const char* OP_VideoTooltips[] =
|
||||
@@ -846,11 +851,12 @@ static const char* OP_VideoTooltips[] =
|
||||
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
|
||||
"Enable fullscreen.",
|
||||
#endif
|
||||
"Gamma (brightness) of the game.",
|
||||
"Saturation of the game.",
|
||||
"Increase the gamma of the displayed image.",
|
||||
"Increase or decrease the brightness of the displayed image.",
|
||||
"Reduce the saturation of the displayed image.",
|
||||
"Advanced color settings of the game.",
|
||||
"How far away objects are drawn.",
|
||||
"How far away weather is drawn.",
|
||||
"How far objects can be drawn.",
|
||||
"Affects how far weather visuals can be drawn.",
|
||||
"Show current game framerate and select the style.",
|
||||
"Sync game framerate to refresh rate of monitor.",
|
||||
"Set manual framerate cap.",
|
||||
|
||||
+17
-6
@@ -113,6 +113,7 @@ CV_PossibleValue_t Color_cons_t[MAXSKINCOLORS+1];
|
||||
struct GenerateBlendTables_State
|
||||
{
|
||||
RGBA_t *LocalPalette;
|
||||
RGBA_t *gammaCorrectedPalette;
|
||||
};
|
||||
|
||||
static void R_GenerateBlendTables_Core(struct GenerateBlendTables_State *state);
|
||||
@@ -126,6 +127,7 @@ static void R_GenerateBlendTables_Thread(void *userdata)
|
||||
R_GenerateBlendTables_Core(state);
|
||||
|
||||
free(state->LocalPalette);
|
||||
free(state->gammaCorrectedPalette);
|
||||
free(state);
|
||||
}
|
||||
#endif
|
||||
@@ -154,26 +156,33 @@ void R_InitTranslucencyTables(void)
|
||||
}
|
||||
|
||||
static colorlookup_t transtab_lut;
|
||||
static colorlookup_t transtab_lut_corrected;
|
||||
|
||||
static void BlendTab_Translucent(UINT8 *table, int style, UINT8 blendamt)
|
||||
{
|
||||
INT16 bg, fg;
|
||||
RGBA_t backrgba, frontrgba, result;
|
||||
|
||||
if (table == NULL)
|
||||
I_Error("BlendTab_Translucent: input table was NULL!");
|
||||
|
||||
for (bg = 0; bg < 0x100; bg++)
|
||||
{
|
||||
backrgba = pGammaCorrectedPalette[bg];
|
||||
|
||||
for (fg = 0; fg < 0x100; fg++)
|
||||
{
|
||||
RGBA_t backrgba = V_GetColor(bg);
|
||||
RGBA_t frontrgba = V_GetColor(fg);
|
||||
RGBA_t result;
|
||||
frontrgba = pGammaCorrectedPalette[fg];
|
||||
|
||||
#if 0 // perfect implementation
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
|
||||
result.rgba = ASTBlendPixel(result, frontrgba, AST_TRANSLUCENT, blendamt);
|
||||
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut, result.s.red, result.s.green, result.s.blue);
|
||||
#else // performance scrabbler
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
|
||||
result.rgba = ASTBlendPixel(result, frontrgba, AST_TRANSLUCENT, blendamt);
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut_corrected, result.s.red, result.s.green, result.s.blue); // pGammaCorrectedPalette
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -224,7 +233,7 @@ static void BlendTab_Modulative(UINT8 *table)
|
||||
RGBA_t frontrgba = V_GetColor(fg);
|
||||
RGBA_t result;
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, AST_MODULATE, 0);
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut, result.s.red, result.s.green, result.s.blue);
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut_corrected, result.s.red, result.s.green, result.s.blue);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -278,11 +287,12 @@ void R_GenerateBlendTables(void)
|
||||
size_t palsize = 256 * sizeof(RGBA_t);
|
||||
|
||||
state->LocalPalette = static_cast<RGBA_t *>(memcpy(malloc(palsize), pLocalPalette, palsize));
|
||||
state->gammaCorrectedPalette = static_cast<RGBA_t *>(memcpy(malloc(palsize), pGammaCorrectedPalette, palsize));
|
||||
|
||||
I_spawn_thread("blend-tables",
|
||||
R_GenerateBlendTables_Thread, state);
|
||||
#else
|
||||
struct GenerateBlendTables_State state = {pLocalPalette};
|
||||
struct GenerateBlendTables_State state = {pLocalPalette, pGammaCorrectedPalette};
|
||||
R_GenerateBlendTables_Core(&state);
|
||||
#endif
|
||||
}
|
||||
@@ -290,6 +300,7 @@ void R_GenerateBlendTables(void)
|
||||
static void R_GenerateBlendTables_Core(struct GenerateBlendTables_State *state)
|
||||
{
|
||||
InitColorLUT(&transtab_lut, state->LocalPalette, false);
|
||||
InitColorLUT(&transtab_lut_corrected, state->gammaCorrectedPalette, false);
|
||||
|
||||
// Additive
|
||||
BlendTab_GenerateMaps(blendtab_add, AST_ADD, BlendTab_Translucent);
|
||||
|
||||
@@ -215,7 +215,10 @@ void SCR_Startup(void)
|
||||
CV_RegisterVar(&cv_menucaps);
|
||||
CV_RegisterVar(&cv_constextsize);
|
||||
|
||||
#ifdef BACKWARDSCOMPATCORRECTION
|
||||
CV_RegisterVar(&cv_globalgamma);
|
||||
#endif
|
||||
CV_RegisterVar(&cv_globalbrightness);
|
||||
CV_RegisterVar(&cv_globalsaturation);
|
||||
|
||||
CV_RegisterVar(&cv_rhue);
|
||||
|
||||
+79
-76
@@ -43,8 +43,13 @@ static void CV_palette_OnChange(void);
|
||||
consvar_t cv_palette = {"palette", "", CV_CALL|CV_NOINIT, NULL, CV_palette_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_palettenum = {"palettenum", "0", CV_CALL|CV_NOINIT, CV_Unsigned, CV_palette_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t gamma_cons_t[] = {{-15, "MIN"}, {4, "MAX"}, {0, NULL}};
|
||||
#ifdef BACKWARDSCOMPATCORRECTION
|
||||
static CV_PossibleValue_t gamma_cons_t[] = {{0, "MIN"}, {4, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_globalgamma = {"gamma", "0", CV_SAVE|CV_CALL, gamma_cons_t, CV_palette_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
#endif
|
||||
|
||||
static CV_PossibleValue_t brightness_cons_t[] = {{-15, "MIN"}, {5, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_globalbrightness = {"brightness", "0", CV_SAVE|CV_CALL, brightness_cons_t, CV_palette_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t saturation_cons_t[] = {{0, "MIN"}, {10, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_globalsaturation = {"saturation", "10", CV_SAVE|CV_CALL, saturation_cons_t, CV_palette_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
@@ -85,6 +90,7 @@ consvar_t cv_menucaps = {"menucaps", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NUL
|
||||
|
||||
// local copy of the palette for V_GetColor()
|
||||
RGBA_t *pLocalPalette = NULL;
|
||||
RGBA_t *pGammaCorrectedPalette = NULL;
|
||||
|
||||
static size_t currentPaletteSize;
|
||||
|
||||
@@ -138,15 +144,11 @@ static boolean InitCube(void)
|
||||
#define diffconsgamma(cv) (cv.value != 0)
|
||||
#define diffconssat(cv) (cv.value != 10)
|
||||
|
||||
#ifdef BACKWARDSCOMPATCORRECTION
|
||||
doinggamma = (cv_globalgamma.value < 0); //dont mess up gamma when raising brightness pls
|
||||
#else
|
||||
doinggamma = diffcons(cv_globalgamma);
|
||||
#endif
|
||||
doinggamma = diffcons(cv_globalbrightness);
|
||||
|
||||
#define gammascale 8
|
||||
globalgammamul = (cv_globalgamma.value ? ((255.0f - (gammascale*abs(cv_globalgamma.value))) / 255.0f) : 1.0f);
|
||||
globalgammaoffs = ((cv_globalgamma.value > 0) ? ((gammascale*cv_globalgamma.value) / 255.0f) : 0.0f);
|
||||
globalgammamul = (cv_globalbrightness.value ? ((255.0f - (gammascale*abs(cv_globalbrightness.value))) / 255.0f) : 1.0f);
|
||||
globalgammaoffs = ((cv_globalbrightness.value > 0) ? ((gammascale*cv_globalbrightness.value) / 255.0f) : 0.0f);
|
||||
desatur[0] = desatur[1] = desatur[2] = globalgammaoffs + (0.33f * globalgammamul);
|
||||
|
||||
if (doinggamma
|
||||
@@ -302,24 +304,6 @@ same, I'm not gonna be the one to remove this base modification.
|
||||
toast 20/04/17
|
||||
... welp yes i am (27/07/19, see the ifdef around it)
|
||||
*/
|
||||
const UINT8 correctiontable[256] =
|
||||
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
|
||||
17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
|
||||
33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,
|
||||
49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,
|
||||
65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,
|
||||
81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,
|
||||
97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
|
||||
113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,
|
||||
128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
|
||||
144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
|
||||
160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
|
||||
176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
|
||||
192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
|
||||
208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
|
||||
224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
|
||||
240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255};
|
||||
|
||||
const UINT8 gammatable[5][256] =
|
||||
{
|
||||
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
|
||||
@@ -405,6 +389,26 @@ const UINT8 gammatable[5][256] =
|
||||
};
|
||||
#endif
|
||||
|
||||
UINT32 V_GammaCorrect(UINT32 input, double power)
|
||||
{
|
||||
RGBA_t result;
|
||||
double linear;
|
||||
|
||||
result.rgba = input;
|
||||
|
||||
linear = ((double)result.s.red)/255.0f;
|
||||
linear = pow(linear, power)*255.0f;
|
||||
result.s.red = (UINT8)(linear);
|
||||
linear = ((double)result.s.green)/255.0f;
|
||||
linear = pow(linear, power)*255.0f;
|
||||
result.s.green = (UINT8)(linear);
|
||||
linear = ((double)result.s.blue)/255.0f;
|
||||
linear = pow(linear, power)*255.0f;
|
||||
result.s.blue = (UINT8)(linear);
|
||||
|
||||
return result.rgba;
|
||||
}
|
||||
|
||||
// keep a copy of the palette so that we can get the RGB value for a color index at any time.
|
||||
static void LoadPalette(const char *lumpname)
|
||||
{
|
||||
@@ -413,7 +417,7 @@ static void LoadPalette(const char *lumpname)
|
||||
lumpnum_t lumpnum;
|
||||
|
||||
#ifdef BACKWARDSCOMPATCORRECTION
|
||||
const UINT8 *usegamma = gammatable[min(max(cv_globalgamma.value, 0), 4)];
|
||||
const UINT8 *usegamma = gammatable[cv_globalgamma.value];
|
||||
#endif
|
||||
Cubeapply = InitCube();
|
||||
|
||||
@@ -423,25 +427,18 @@ static void LoadPalette(const char *lumpname)
|
||||
palsize = currentPaletteSize / 3;
|
||||
|
||||
Z_Free(pLocalPalette);
|
||||
Z_Free(pGammaCorrectedPalette);
|
||||
|
||||
pLocalPalette = Z_Malloc(sizeof (*pLocalPalette)*palsize, PU_STATIC, NULL);
|
||||
pGammaCorrectedPalette = Z_Malloc(sizeof (*pGammaCorrectedPalette)*palsize, PU_STATIC, NULL);
|
||||
|
||||
pal = W_CacheLumpNum(lumpnum, PU_CACHE);
|
||||
for (i = 0; i < palsize; i++)
|
||||
{
|
||||
#ifdef BACKWARDSCOMPATCORRECTION
|
||||
if (cv_globalgamma.value >= 0 && cv_globalgamma.value <= 4)
|
||||
{
|
||||
pLocalPalette[i].s.red = usegamma[*pal++];
|
||||
pLocalPalette[i].s.green = usegamma[*pal++];
|
||||
pLocalPalette[i].s.blue = usegamma[*pal++];
|
||||
}
|
||||
else
|
||||
{
|
||||
pLocalPalette[i].s.red = correctiontable[*pal++];
|
||||
pLocalPalette[i].s.green = correctiontable[*pal++];
|
||||
pLocalPalette[i].s.blue = correctiontable[*pal++];
|
||||
}
|
||||
pLocalPalette[i].s.red = usegamma[*pal++];
|
||||
pLocalPalette[i].s.green = usegamma[*pal++];
|
||||
pLocalPalette[i].s.blue = usegamma[*pal++];
|
||||
#else
|
||||
pLocalPalette[i].s.red = *pal++;
|
||||
pLocalPalette[i].s.green = *pal++;
|
||||
@@ -449,15 +446,17 @@ static void LoadPalette(const char *lumpname)
|
||||
#endif
|
||||
pLocalPalette[i].s.alpha = 0xFF;
|
||||
|
||||
pGammaCorrectedPalette[i].rgba = V_GammaDecode(pLocalPalette[i].rgba);
|
||||
|
||||
if (!Cubeapply)
|
||||
continue;
|
||||
|
||||
// lerp of colour cubing! if you want, make it smoother yourself
|
||||
V_CubeApply(&pLocalPalette[i].s.red, &pLocalPalette[i].s.green, &pLocalPalette[i].s.blue);
|
||||
V_CubeApply(&pGammaCorrectedPalette[i]);
|
||||
pLocalPalette[i].rgba = V_GammaEncode(pGammaCorrectedPalette[i].rgba);
|
||||
}
|
||||
}
|
||||
|
||||
void V_CubeApply(UINT8 *red, UINT8 *green, UINT8 *blue)
|
||||
void V_CubeApply(RGBA_t *input)
|
||||
{
|
||||
float working[4][3];
|
||||
float linear;
|
||||
@@ -466,7 +465,7 @@ void V_CubeApply(UINT8 *red, UINT8 *green, UINT8 *blue)
|
||||
if (!Cubeapply)
|
||||
return;
|
||||
|
||||
linear = (*red/255.0f);
|
||||
linear = ((*input).s.red/255.0);
|
||||
#define dolerp(e1, e2) ((1 - linear)*e1 + linear*e2)
|
||||
for (q = 0; q < 3; q++)
|
||||
{
|
||||
@@ -475,13 +474,15 @@ void V_CubeApply(UINT8 *red, UINT8 *green, UINT8 *blue)
|
||||
working[2][q] = dolerp(Cubepal[0][0][1][q], Cubepal[1][0][1][q]);
|
||||
working[3][q] = dolerp(Cubepal[0][1][1][q], Cubepal[1][1][1][q]);
|
||||
}
|
||||
linear = (*green/255.0f);
|
||||
|
||||
linear = ((*input).s.green/255.0);
|
||||
for (q = 0; q < 3; q++)
|
||||
{
|
||||
working[0][q] = dolerp(working[0][q], working[1][q]);
|
||||
working[1][q] = dolerp(working[2][q], working[3][q]);
|
||||
}
|
||||
linear = (*blue/255.0f);
|
||||
|
||||
linear = ((*input).s.blue/255.0);
|
||||
for (q = 0; q < 3; q++)
|
||||
{
|
||||
working[0][q] = 255*dolerp(working[0][q], working[1][q]);
|
||||
@@ -492,9 +493,9 @@ void V_CubeApply(UINT8 *red, UINT8 *green, UINT8 *blue)
|
||||
}
|
||||
#undef dolerp
|
||||
|
||||
*red = (UINT8)(working[0][0]);
|
||||
*green = (UINT8)(working[0][1]);
|
||||
*blue = (UINT8)(working[0][2]);
|
||||
(*input).s.red = (UINT8)(working[0][0]);
|
||||
(*input).s.green = (UINT8)(working[0][1]);
|
||||
(*input).s.blue = (UINT8)(working[0][2]);
|
||||
}
|
||||
|
||||
const char *R_GetPalname(UINT16 num)
|
||||
@@ -1329,37 +1330,37 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
|
||||
// This is now a function since it's otherwise repeated 2 times and honestly looks retarded:
|
||||
static UINT32 V_GetHWConsBackColor(void)
|
||||
{
|
||||
UINT8 r, g, b;
|
||||
RGBA_t output;
|
||||
|
||||
switch (cons_backcolor.value)
|
||||
{
|
||||
case 0: r = 0xff; g = 0xff; b = 0xff; break; // White
|
||||
case 1: r = 0x80; g = 0x80; b = 0x80; break; // Black
|
||||
case 2: r = 0xde; g = 0xb8; b = 0x87; break; // Sepia
|
||||
case 3: r = 0x40; g = 0x20; b = 0x10; break; // Brown
|
||||
case 4: r = 0xfa; g = 0x80; b = 0x72; break; // Pink
|
||||
case 5: r = 0xff; g = 0x69; b = 0xb4; break; // Raspberry
|
||||
case 6: r = 0xff; g = 0x00; b = 0x00; break; // Red
|
||||
case 7: r = 0xff; g = 0xd6; b = 0x83; break; // Creamsicle
|
||||
case 8: r = 0xff; g = 0x80; b = 0x00; break; // Orange
|
||||
case 9: r = 0xda; g = 0xa5; b = 0x20; break; // Gold
|
||||
case 10: r = 0x80; g = 0x80; b = 0x00; break; // Yellow
|
||||
case 11: r = 0x00; g = 0xff; b = 0x00; break; // Emerald
|
||||
case 12: r = 0x00; g = 0x80; b = 0x00; break; // Green
|
||||
case 13: r = 0x40; g = 0x80; b = 0xff; break; // Cyan
|
||||
case 14: r = 0x46; g = 0x82; b = 0xb4; break; // Steel
|
||||
case 15: r = 0x1e; g = 0x90; b = 0xff; break; // Periwinkle
|
||||
case 16: r = 0x00; g = 0x00; b = 0xff; break; // Blue
|
||||
case 17: r = 0xff; g = 0x00; b = 0xff; break; // Purple
|
||||
case 18: r = 0xee; g = 0x82; b = 0xee; break; // Lavender
|
||||
case 0: output.s.red = 0xff; output.s.green = 0xff; output.s.blue = 0xff; break; // White
|
||||
case 1: output.s.red = 0x80; output.s.green = 0x80; output.s.blue = 0x80; break; // Black
|
||||
case 2: output.s.red = 0xde; output.s.green = 0xb8; output.s.blue = 0x87; break; // Sepia
|
||||
case 3: output.s.red = 0x40; output.s.green = 0x20; output.s.blue = 0x10; break; // Brown
|
||||
case 4: output.s.red = 0xfa; output.s.green = 0x80; output.s.blue = 0x72; break; // Pink
|
||||
case 5: output.s.red = 0xff; output.s.green = 0x69; output.s.blue = 0xb4; break; // Raspberry
|
||||
case 6: output.s.red = 0xff; output.s.green = 0x00; output.s.blue = 0x00; break; // Red
|
||||
case 7: output.s.red = 0xff; output.s.green = 0xd6; output.s.blue = 0x83; break; // Creamsicle
|
||||
case 8: output.s.red = 0xff; output.s.green = 0x80; output.s.blue = 0x00; break; // Orange
|
||||
case 9: output.s.red = 0xda; output.s.green = 0xa5; output.s.blue = 0x20; break; // Gold
|
||||
case 10: output.s.red = 0x80; output.s.green = 0x80; output.s.blue = 0x00; break; // Yellow
|
||||
case 11: output.s.red = 0x00; output.s.green = 0xff; output.s.blue = 0x00; break; // Emerald
|
||||
case 12: output.s.red = 0x00; output.s.green = 0x80; output.s.blue = 0x00; break; // Green
|
||||
case 13: output.s.red = 0x40; output.s.green = 0x80; output.s.blue = 0xff; break; // Cyan
|
||||
case 14: output.s.red = 0x46; output.s.green = 0x82; output.s.blue = 0xb4; break; // Steel
|
||||
case 15: output.s.red = 0x1e; output.s.green = 0x90; output.s.blue = 0xff; break; // Periwinkle
|
||||
case 16: output.s.red = 0x00; output.s.green = 0x00; output.s.blue = 0xff; break; // Blue
|
||||
case 17: output.s.red = 0xff; output.s.green = 0x00; output.s.blue = 0xff; break; // Purple
|
||||
case 18: output.s.red = 0xee; output.s.green = 0x82; output.s.blue = 0xee; break; // Lavender
|
||||
// Default green
|
||||
default: r = 0x00; g = 0x80; b = 0x00; break;
|
||||
default: output.s.red = 0x00; output.s.green = 0x80; output.s.blue = 0x00; break;
|
||||
}
|
||||
|
||||
if (!HWR_ShouldUsePaletteRendering())
|
||||
V_CubeApply(&r, &g, &b);
|
||||
V_CubeApply(&output);
|
||||
|
||||
return (r << 24) | (g << 16) | (b << 8);
|
||||
return (output.s.red << 24) | (output.s.green << 16) | (output.s.blue << 8);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -3808,12 +3809,14 @@ void InitColorLUT(colorlookup_t *lut, RGBA_t *palette, boolean makecolors)
|
||||
UINT8 r, g, b;
|
||||
|
||||
for (r = 0; r < 0xFF; r++)
|
||||
for (g = 0; g < 0xFF; g++)
|
||||
for (b = 0; b < 0xFF; b++)
|
||||
{
|
||||
i = CLUTINDEX(r, g, b);
|
||||
if (lut->table[i] == 0xFFFF)
|
||||
lut->table[i] = NearestPaletteColor(r, g, b, palette);
|
||||
for (g = 0; g < 0xFF; g++)
|
||||
{
|
||||
for (b = 0; b < 0xFF; b++)
|
||||
{
|
||||
lut->table[i] = GetColorLUT(lut, r, g, b);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+10
-2
@@ -40,7 +40,10 @@ extern "C" {
|
||||
//
|
||||
|
||||
extern consvar_t cv_ticrate, cv_accuratefps, cv_allcaps, cv_constextsize, cv_menucaps,
|
||||
cv_globalgamma, cv_globalsaturation,
|
||||
#ifdef BACKWARDSCOMPATCORRECTION
|
||||
cv_globalgamma,
|
||||
#endif
|
||||
cv_globalbrightness, cv_globalsaturation,
|
||||
cv_rhue, cv_yhue, cv_ghue, cv_chue, cv_bhue, cv_mhue,
|
||||
cv_rgamma, cv_ygamma, cv_ggamma, cv_cgamma, cv_bgamma, cv_mgamma,
|
||||
cv_rsaturation, cv_ysaturation, cv_gsaturation, cv_csaturation, cv_bsaturation, cv_msaturation,
|
||||
@@ -78,10 +81,15 @@ const char *R_GetPalname(UINT16 num);
|
||||
const char *GetPalette(void);
|
||||
|
||||
extern RGBA_t *pLocalPalette;
|
||||
extern RGBA_t *pGammaCorrectedPalette;
|
||||
|
||||
extern UINT8 hudtrans;
|
||||
|
||||
void V_CubeApply(UINT8 *red, UINT8 *green, UINT8 *blue);
|
||||
UINT32 V_GammaCorrect(UINT32 input, double power);
|
||||
#define V_GammaDecode(input) V_GammaCorrect(input, 2.2f)
|
||||
#define V_GammaEncode(input) V_GammaCorrect(input, (1/2.2f))
|
||||
|
||||
void V_CubeApply(RGBA_t *input);
|
||||
|
||||
// Retrieve the ARGB value from a palette color index
|
||||
#define V_GetColor(color) (pLocalPalette[color&0xFF])
|
||||
|
||||
Reference in new issue
Block a user