thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-12-29 19:22:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch '22mergaintranswork' into '22-merge-again'

Browse source 
(22mergain) Transparency and Blend Modes

See merge request KartKrew/Kart!408
This commit is contained in:
SteelT 2021-04-01 20:18:15 -04:00
commit e9f85c0992
41 changed files with 701 additions and 695 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

91
src/deh_tables.c
View file

@ -22,7 +22,7 @@
#include "v_video.h" // video flags (for lua)
#include "i_sound.h" // musictype_t (for lua)
#include "g_state.h" // gamestate_t (for lua)
#include "r_data.h" // patchalphastyle
#include "r_data.h" // patchalphastyle_t
#include "deh_tables.h"
@ -6416,10 +6416,19 @@ struct int_const_s const INT_CONST[] = {
{"FF_RANDOMANIM",FF_RANDOMANIM},
{"FF_GLOBALANIM",FF_GLOBALANIM},
{"FF_FULLBRIGHT",FF_FULLBRIGHT},
{"FF_FULLDARK",FF_FULLDARK},
{"FF_SEMIBRIGHT",FF_SEMIBRIGHT},
{"FF_VERTICALFLIP",FF_VERTICALFLIP},
{"FF_HORIZONTALFLIP",FF_HORIZONTALFLIP},
{"FF_PAPERSPRITE",FF_PAPERSPRITE},
{"FF_FLOORSPRITE",FF_FLOORSPRITE},
{"FF_BLENDMASK",FF_BLENDMASK},
{"FF_BLENDSHIFT",FF_BLENDSHIFT},
{"FF_ADD",FF_ADD},
{"FF_SUBTRACT",FF_SUBTRACT},
{"FF_REVERSESUBTRACT",FF_REVERSESUBTRACT},
{"FF_MODULATE",FF_MODULATE},
{"FF_OVERLAY",FF_OVERLAY},
{"FF_TRANSMASK",FF_TRANSMASK},
{"FF_TRANSSHIFT",FF_TRANSSHIFT},
// new preshifted translucency (used in source)
@ -6432,8 +6441,9 @@ struct int_const_s const INT_CONST[] = {
{"FF_TRANS70",FF_TRANS70},
{"FF_TRANS80",FF_TRANS80},
{"FF_TRANS90",FF_TRANS90},
{"FF_TRANSADD",FF_TRANSADD},
{"FF_TRANSSUB",FF_TRANSSUB},
// temporary, for testing
{"FF_TRANSADD",FF_ADD},
{"FF_TRANSSUB",FF_SUBTRACT},
// compatibility
// Transparency for SOCs is pre-shifted
{"TR_TRANS10",tr_trans10<<FF_TRANSSHIFT},
@ -6445,8 +6455,6 @@ struct int_const_s const INT_CONST[] = {
{"TR_TRANS70",tr_trans70<<FF_TRANSSHIFT},
{"TR_TRANS80",tr_trans80<<FF_TRANSSHIFT},
{"TR_TRANS90",tr_trans90<<FF_TRANSSHIFT},
{"TR_TRANSADD",tr_transadd<<FF_TRANSSHIFT},
{"TR_TRANSSUB",tr_transsub<<FF_TRANSSHIFT},
// Transparency for Lua is not, unless capitalized as above.
{"tr_trans10",tr_trans10},
{"tr_trans20",tr_trans20},
@ -6458,13 +6466,10 @@ struct int_const_s const INT_CONST[] = {
{"tr_trans80",tr_trans80},
{"tr_trans90",tr_trans90},
{"NUMTRANSMAPS",NUMTRANSMAPS},
{"tr_transadd",tr_transadd},
{"tr_transsub",tr_transsub},
{"NUMEFFECTMAPS",NUMEFFECTMAPS},
// Alpha styles (blend modes)
{"AST_COPY",AST_COPY},
{"AST_TRANSLUCENT",AST_TRANSLUCENT},
//{"AST_COPY",AST_COPY}, -- not useful in lua
//{"AST_TRANSLUCENT",AST_TRANSLUCENT}, -- ditto
{"AST_ADD",AST_ADD},
{"AST_SUBTRACT",AST_SUBTRACT},
{"AST_REVERSESUBTRACT",AST_REVERSESUBTRACT},
@ -6481,9 +6486,10 @@ struct int_const_s const INT_CONST[] = {
{"RF_OBJECTSLOPESPLAT",RF_OBJECTSLOPESPLAT},
{"RF_NOSPLATBILLBOARD",RF_NOSPLATBILLBOARD},
{"RF_NOSPLATROLLANGLE",RF_NOSPLATROLLANGLE},
{"RF_BLENDMASK",RF_BLENDMASK},
{"RF_BRIGHTMASK",RF_BRIGHTMASK},
{"RF_FULLBRIGHT",RF_FULLBRIGHT},
{"RF_FULLDARK",RF_FULLDARK},
{"RF_SEMIBRIGHT",RF_SEMIBRIGHT},
{"RF_NOCOLORMAPS",RF_NOCOLORMAPS},
{"RF_SPRITETYPEMASK",RF_SPRITETYPEMASK},
{"RF_PAPERSPRITE",RF_PAPERSPRITE},
@ -6491,6 +6497,31 @@ struct int_const_s const INT_CONST[] = {
{"RF_SHADOWDRAW",RF_SHADOWDRAW},
{"RF_SHADOWEFFECTS",RF_SHADOWEFFECTS},
{"RF_DROPSHADOW",RF_DROPSHADOW},
{"RF_DONTDRAW",RF_DONTDRAW},
{"RF_DONTDRAWP1",RF_DONTDRAWP1},
{"RF_DONTDRAWP2",RF_DONTDRAWP2},
{"RF_DONTDRAWP3",RF_DONTDRAWP3},
{"RF_DONTDRAWP4",RF_DONTDRAWP4},
{"RF_BLENDMASK",RF_BLENDMASK},
{"RF_BLENDSHIFT",RF_BLENDSHIFT},
{"RF_ADD",RF_ADD},
{"RF_SUBTRACT",RF_SUBTRACT},
{"RF_REVERSESUBTRACT",RF_REVERSESUBTRACT},
{"RF_MODULATE",RF_MODULATE},
{"RF_OVERLAY",RF_OVERLAY},
{"RF_TRANSMASK",RF_TRANSMASK},
{"RF_TRANSSHIFT",RF_TRANSSHIFT},
{"RF_TRANS10",RF_TRANS10},
{"RF_TRANS20",RF_TRANS20},
{"RF_TRANS30",RF_TRANS30},
{"RF_TRANS40",RF_TRANS40},
{"RF_TRANS50",RF_TRANS50},
{"RF_TRANS60",RF_TRANS60},
{"RF_TRANS70",RF_TRANS70},
{"RF_TRANS80",RF_TRANS80},
{"RF_TRANS90",RF_TRANS90},
{"RF_GHOSTLY",RF_GHOSTLY},
{"RF_GHOSTLYMASK",RF_GHOSTLYMASK},
// Level flags
{"LF_SCRIPTISFILE",LF_SCRIPTISFILE},
@ -6886,20 +6917,21 @@ struct int_const_s const INT_CONST[] = {
{"V_70TRANS",V_70TRANS},
{"V_80TRANS",V_80TRANS},
{"V_90TRANS",V_90TRANS},
{"V_ADDTRANS",V_ADDTRANS},
{"V_SUBTRANS",V_SUBTRANS},
{"V_HUDTRANSHALF",V_HUDTRANSHALF},
{"V_HUDTRANS",V_HUDTRANS},
{"V_RETURN8",V_RETURN8},
{"V_OFFSET",V_OFFSET},
{"V_BLENDSHIFT",V_BLENDSHIFT},
{"V_BLENDMASK",V_BLENDMASK},
{"V_ADD",V_ADD},
{"V_SUBTRACT",V_SUBTRACT},
{"V_REVERSESUBTRACT",V_REVERSESUBTRACT},
{"V_MODULATE",V_MODULATE},
{"V_OVERLAY",V_OVERLAY},
{"V_ALLOWLOWERCASE",V_ALLOWLOWERCASE},
{"V_FLIP",V_FLIP},
{"V_SNAPTOTOP",V_SNAPTOTOP},
{"V_SNAPTOBOTTOM",V_SNAPTOBOTTOM},
{"V_SNAPTOLEFT",V_SNAPTOLEFT},
{"V_SNAPTORIGHT",V_SNAPTORIGHT},
{"V_WRAPX",V_WRAPX},
{"V_WRAPY",V_WRAPY},
{"V_NOSCALESTART",V_NOSCALESTART},
{"V_SPLITSCREEN",V_SPLITSCREEN},
{"V_SLIDEIN",V_SLIDEIN},
@ -6999,31 +7031,6 @@ struct int_const_s const INT_CONST[] = {
{"KSPIN_STUNG",KSPIN_STUNG},
{"KSPIN_EXPLOSION",KSPIN_EXPLOSION},
// MFD_ draw flag enum
{"MFD_DONTDRAWP1",MFD_DONTDRAWP1},
{"MFD_DONTDRAWP2",MFD_DONTDRAWP2},
{"MFD_DONTDRAWP3",MFD_DONTDRAWP3},
{"MFD_DONTDRAWP4",MFD_DONTDRAWP4},
{"MFD_TRANS10",MFD_TRANS10},
{"MFD_TRANS20",MFD_TRANS20},
{"MFD_TRANS30",MFD_TRANS30},
{"MFD_TRANS40",MFD_TRANS40},
{"MFD_TRANS50",MFD_TRANS50},
{"MFD_TRANS60",MFD_TRANS60},
{"MFD_TRANS70",MFD_TRANS70},
{"MFD_TRANS80",MFD_TRANS80},
{"MFD_TRANS90",MFD_TRANS90},
{"MFD_TRANSADD",MFD_TRANSADD},
{"MFD_TRANSSUB",MFD_TRANSSUB},
{"MFD_TRANSMASK",MFD_TRANSMASK},
{"MFD_FULLBRIGHT",MFD_FULLBRIGHT},
{"MFD_SEMIBRIGHT",MFD_SEMIBRIGHT},
{"MFD_NOBRIGHT",MFD_NOBRIGHT},
{"MFD_BRIGHTMASK",MFD_BRIGHTMASK},
{"MFD_DONTDRAW",MFD_DONTDRAW},
{"MFD_SHADOW",MFD_SHADOW},
{"MFD_TRANSSHIFT",MFD_TRANSSHIFT},
{NULL,0}
};

4
src/f_finale.c
View file

@ -1090,7 +1090,7 @@ void F_GameEvaluationTicker(void)
{
if (netgame || multiplayer) // modify this when we finally allow unlocking stuff in 2P
{
HU_SetCEchoFlags(V_YELLOWMAP|V_RETURN8);
HU_SetCEchoFlags(V_YELLOWMAP);
HU_SetCEchoDuration(6);
HU_DoCEcho("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\Multiplayer games can't unlock extras!");
S_StartSound(NULL, sfx_s3k68);
@ -1106,7 +1106,7 @@ void F_GameEvaluationTicker(void)
}
else
{
HU_SetCEchoFlags(V_YELLOWMAP|V_RETURN8);
HU_SetCEchoFlags(V_YELLOWMAP);
HU_SetCEchoDuration(6);
HU_DoCEcho("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\Modified games can't unlock extras!");
S_StartSound(NULL, sfx_s3k68);

12
src/g_demo.c
View file

@ -809,7 +809,7 @@ void G_WriteGhostTic(mobj_t *ghost, INT32 playernum)
ghostext[playernum].flags = 0;
}
if (ghost->player && ghost->player->followmobj&& !(ghost->player->followmobj->sprite == SPR_NULL || (ghost->player->followmobj->drawflags & MFD_DONTDRAW) == MFD_DONTDRAW)) // bloats tails runs but what can ya do
if (ghost->player && ghost->player->followmobj&& !(ghost->player->followmobj->sprite == SPR_NULL || (ghost->player->followmobj->renderflags & RF_DONTDRAW) == RF_DONTDRAW)) // bloats tails runs but what can ya do
{
fixed_t temp;
UINT8 *followtic_p = demo_p++;
@ -1153,7 +1153,7 @@ void G_GhostTicker(void)
if (g->fadein)
{
g->mo->frame += (((--g->fadein)/6)<<FF_TRANSSHIFT); // this calc never exceeds 9 unless g->fadein is bad, and it's only set once, so...
g->mo->drawflags &= ~MFD_DONTDRAW;
g->mo->renderflags &= ~RF_DONTDRAW;
}
g->mo->sprite2 = g->oldmo.sprite2;
@ -1433,7 +1433,7 @@ void G_PreviewRewind(tic_t previewtime)
if (!info->playerinfo[i].ingame || !info->playerinfo[i].player.mo)
{
if (players[i].mo)
players[i].mo->drawflags |= MFD_DONTDRAW;
players[i].mo->renderflags |= RF_DONTDRAW;
continue;
}
@ -1441,7 +1441,7 @@ void G_PreviewRewind(tic_t previewtime)
if (!players[i].mo)
continue; //@TODO spawn temp object to act as a player display
players[i].mo->drawflags &= ~MFD_DONTDRAW;
players[i].mo->renderflags &= ~RF_DONTDRAW;
P_UnsetThingPosition(players[i].mo);
#define TWEEN(pr) info->playerinfo[i].mobj.pr + FixedMul((INT32) (next_info->playerinfo[i].mobj.pr - info->playerinfo[i].mobj.pr), tweenvalue)
@ -1809,7 +1809,7 @@ void G_WriteMetalTic(mobj_t *metal)
ghostext[0].flags = 0;
}
if (metal->player && metal->player->followmobj && !(metal->player->followmobj->sprite == SPR_NULL || (metal->player->followmobj->drawflags & MFD_DONTDRAW) == MFD_DONTDRAW))
if (metal->player && metal->player->followmobj && !(metal->player->followmobj->sprite == SPR_NULL || (metal->player->followmobj->renderflags & RF_DONTDRAW) == RF_DONTDRAW))
{
fixed_t temp;
UINT8 *followtic_p = demo_p++;
@ -3322,7 +3322,7 @@ void G_AddGhost(char *defdemoname)
gh->mo->sprite = gh->mo->state->sprite;
gh->mo->sprite2 = (gh->mo->state->frame & FF_FRAMEMASK);
//gh->mo->frame = tr_trans30<<FF_TRANSSHIFT;
gh->mo->drawflags |= MFD_DONTDRAW;
gh->mo->renderflags |= RF_DONTDRAW;
gh->fadein = (9-3)*6; // fade from invisible to trans30 over as close to 35 tics as possible
gh->mo->tics = -1;

2
src/g_game.c
View file

@ -2044,7 +2044,7 @@ static inline void G_PlayerFinishLevel(INT32 player)
memset(p->powers, 0, sizeof (p->powers));
memset(p->kartstuff, 0, sizeof (p->kartstuff)); // SRB2kart
p->mo->drawflags &= ~(MFD_TRANSMASK|MFD_BRIGHTMASK); // cancel invisibility
p->mo->renderflags &= ~(RF_TRANSMASK|RF_BRIGHTMASK); // cancel invisibility
P_FlashPal(p, 0, 0); // Resets
p->starpostnum = 0;

73
src/hardware/hw_draw.c
View file

@ -120,10 +120,10 @@ void HWR_DrawPatch(patch_t *gpatch, INT32 x, INT32 y, INT32 option)
flags = PF_Translucent|PF_NoDepthTest;
if (option & V_WRAPX)
/*if (option & V_WRAPX)
flags |= PF_ForceWrapX;
if (option & V_WRAPY)
flags |= PF_ForceWrapY;
flags |= PF_ForceWrapY;*/
// clip it since it is used for bunny scroll in doom I
HWD.pfnDrawPolygon(NULL, v, 4, flags);
@ -135,7 +135,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
FBITFIELD flags;
float cx = FIXED_TO_FLOAT(x);
float cy = FIXED_TO_FLOAT(y);
UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
UINT32 alphalevel, blendmode;
GLPatch_t *hwrPatch;
// 3--2
@ -144,9 +144,6 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
// 0--1
float dupx, dupy, fscalew, fscaleh, fwidth, fheight;
if (alphalevel >= 12 && alphalevel < 13)
return;
// make patch ready in hardware cache
if (!colormap)
HWR_GetPatch(gpatch);
@ -190,15 +187,8 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
offsetx = (float)(gpatch->leftoffset) * fscalew;
// top offset
// TODO: make some kind of vertical version of V_FLIP, maybe by deprecating V_OFFSET in future?!?
offsety = (float)(gpatch->topoffset) * fscaleh;
if ((option & (V_NOSCALESTART|V_OFFSET)) == (V_NOSCALESTART|V_OFFSET)) // Multiply by dupx/dupy for crosshairs
{
offsetx *= dupx;
offsety *= dupy;
}
cx -= offsetx;
cy -= offsety;
}
@ -263,22 +253,30 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
flags = PF_Translucent|PF_NoDepthTest;
if (option & V_WRAPX)
/*if (option & V_WRAPX)
flags |= PF_ForceWrapX;
if (option & V_WRAPY)
flags |= PF_ForceWrapY;
flags |= PF_ForceWrapY;*/
// clip it since it is used for bunny scroll in doom I
if (alphalevel)
if ((blendmode = ((option & V_BLENDMASK) >> V_BLENDSHIFT)))
blendmode++; // realign to constants
if ((alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT)) || blendmode)
{
FSurfaceInfo Surf;
Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
if (alphalevel == 10) { flags &= ~PF_Translucent; flags |= PF_Additive; }
else if (alphalevel == 11) { flags &= ~PF_Translucent; flags |= PF_Subtractive; }
else if (alphalevel == 13) Surf.PolyColor.s.alpha = softwaretranstogl_lo[st_translucency];
else if (alphalevel == 14) Surf.PolyColor.s.alpha = softwaretranstogl[st_translucency];
else if (alphalevel == 15) Surf.PolyColor.s.alpha = softwaretranstogl_hi[st_translucency];
else Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel];
flags |= HWR_GetBlendModeFlag(blendmode);
if (alphalevel == 10)
Surf.PolyColor.s.alpha = softwaretranstogl_lo[st_translucency];
else if (alphalevel == 11)
Surf.PolyColor.s.alpha = softwaretranstogl[st_translucency];
else if (alphalevel == 12)
Surf.PolyColor.s.alpha = softwaretranstogl_hi[st_translucency];
else
Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel];
flags |= PF_Modulated;
HWD.pfnDrawPolygon(&Surf, v, 4, flags);
}
@ -292,7 +290,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
FBITFIELD flags;
float cx = FIXED_TO_FLOAT(x);
float cy = FIXED_TO_FLOAT(y);
UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
UINT32 alphalevel, blendmode;
GLPatch_t *hwrPatch;
// 3--2
@ -301,9 +299,6 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
// 0--1
float dupx, dupy, fscale, fwidth, fheight;
if (alphalevel >= 12 && alphalevel < 13)
return;
// make patch ready in hardware cache
HWR_GetPatch(gpatch);
hwrPatch = ((GLPatch_t *)gpatch->hardware);
@ -422,22 +417,30 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
flags = PF_Translucent|PF_NoDepthTest;
if (option & V_WRAPX)
/*if (option & V_WRAPX)
flags |= PF_ForceWrapX;
if (option & V_WRAPY)
flags |= PF_ForceWrapY;
flags |= PF_ForceWrapY;*/
// clip it since it is used for bunny scroll in doom I
if (alphalevel)
if ((blendmode = ((option & V_BLENDMASK) >> V_BLENDSHIFT)))
blendmode++; // realign to constants
if ((alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT)) || blendmode)
{
FSurfaceInfo Surf;
Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
if (alphalevel == 10) { flags &= ~PF_Translucent; flags |= PF_Additive; }
else if (alphalevel == 11) { flags &= ~PF_Translucent; flags |= PF_Subtractive; }
else if (alphalevel == 13) Surf.PolyColor.s.alpha = softwaretranstogl_lo[st_translucency];
else if (alphalevel == 14) Surf.PolyColor.s.alpha = softwaretranstogl[st_translucency];
else if (alphalevel == 15) Surf.PolyColor.s.alpha = softwaretranstogl_hi[st_translucency];
else Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel];
flags |= HWR_GetBlendModeFlag(blendmode);
if (alphalevel == 10)
Surf.PolyColor.s.alpha = softwaretranstogl_lo[st_translucency];
else if (alphalevel == 11)
Surf.PolyColor.s.alpha = softwaretranstogl[st_translucency];
else if (alphalevel == 12)
Surf.PolyColor.s.alpha = softwaretranstogl_hi[st_translucency];
else
Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel];
flags |= PF_Modulated;
HWD.pfnDrawPolygon(&Surf, v, 4, flags);
}

207
src/hardware/hw_main.c
View file

@ -1465,7 +1465,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
default:
{
transnum_t transtable = R_GetLinedefTransTable(gl_linedef);
if (transtable != NUMEFFECTMAPS)
if (transtable != NUMTRANSMAPS)
blendmode = HWR_TranstableToAlpha(transtable, &Surf);
else
blendmode = PF_Masked;
@ -1475,7 +1475,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if (gl_curline->polyseg && gl_curline->polyseg->translucency > 0)
{
if (gl_curline->polyseg->translucency >= NUMEFFECTMAPS) // wall not drawn
if (gl_curline->polyseg->translucency >= NUMTRANSMAPS) // wall not drawn
{
Surf.PolyColor.s.alpha = 0x00; // This shouldn't draw anything regardless of blendmode
blendmode = PF_Masked;
@ -1752,15 +1752,11 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if (rover->flags & FF_TRANSLUCENT)
{
if (rover->alpha < 256)
if (rover->alpha < 256 || rover->blend)
{
blendmode = PF_Translucent;
Surf.PolyColor.s.alpha = (UINT8)(rover->alpha-1 > 255 ? 255 : rover->alpha-1);
blendmode = HWR_GetBlendModeFlag(rover->blend);
Surf.PolyColor.s.alpha = (UINT8)(rover->alpha-1);
}
else if (rover->alpha == FFLOOR_ALPHA_SPECIAL_ADDITIVE)
blendmode = PF_Additive;
else if (rover->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)
blendmode = PF_Subtractive;
}
if (gl_frontsector->numlights)
@ -1871,15 +1867,11 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if (rover->flags & FF_TRANSLUCENT)
{
if (rover->alpha < 256)
if (rover->alpha < 256 || rover->blend)
{
blendmode = PF_Translucent;
Surf.PolyColor.s.alpha = (UINT8)(rover->alpha-1 > 255 ? 255 : rover->alpha-1);
blendmode = HWR_GetBlendModeFlag(rover->blend);
Surf.PolyColor.s.alpha = (UINT8)(rover->alpha-1);
}
else if (rover->alpha == FFLOOR_ALPHA_SPECIAL_ADDITIVE)
blendmode = PF_Additive;
else if (rover->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)
blendmode = PF_Subtractive;
}
if (gl_backsector->numlights)
@ -2903,7 +2895,7 @@ static void HWR_AddPolyObjectPlanes(void)
if (!(po_ptrs[i]->flags & POF_RENDERPLANES)) // Only render planes when you should
continue;
if (po_ptrs[i]->translucency >= NUMEFFECTMAPS)
if (po_ptrs[i]->translucency >= NUMTRANSMAPS)
continue;
if (polyobjsector->floorheight <= gl_frontsector->ceilingheight
@ -3152,14 +3144,9 @@ static void HWR_Subsector(size_t num)
true, rover->master->frontsector->extra_colormap);
}
else if (rover->flags & FF_TRANSLUCENT
&& (rover->alpha < 256
|| rover->alpha == FFLOOR_ALPHA_SPECIAL_ADDITIVE || rover->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)) // SoM: Flags are more efficient
&& (rover->alpha < 256 || rover->blend)) // SoM: Flags are more efficient
{
FBITFIELD blendmode = PF_Translucent | HWR_RippleBlend(gl_frontsector, rover, false);
if (rover->alpha == FFLOOR_ALPHA_SPECIAL_ADDITIVE)
blendmode = PF_Additive;
else if (rover->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)
blendmode = PF_Subtractive;
FBITFIELD blendmode = HWR_GetBlendModeFlag(rover->blend) | HWR_RippleBlend(gl_frontsector, rover, false);
light = R_GetPlaneLight(gl_frontsector, centerHeight, dup_viewz < cullHeight ? true : false);
@ -3168,7 +3155,7 @@ static void HWR_Subsector(size_t num)
false,
*rover->bottomheight,
*gl_frontsector->lightlist[light].lightlevel,
rover->alpha-1 > 255 ? 255 : rover->alpha-1, rover->master->frontsector, blendmode,
rover->alpha-1, rover->master->frontsector, blendmode,
false, *gl_frontsector->lightlist[light].extra_colormap);
}
else
@ -3205,14 +3192,9 @@ static void HWR_Subsector(size_t num)
true, rover->master->frontsector->extra_colormap);
}
else if (rover->flags & FF_TRANSLUCENT
&& (rover->alpha < 256
|| rover->alpha == FFLOOR_ALPHA_SPECIAL_ADDITIVE || rover->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)) // SoM: Flags are more efficient
&& (rover->alpha < 256 || rover->blend)) // SoM: Flags are more efficient
{
FBITFIELD blendmode = PF_Translucent | HWR_RippleBlend(gl_frontsector, rover, true);
if (rover->alpha == FFLOOR_ALPHA_SPECIAL_ADDITIVE)
blendmode = PF_Additive;
else if (rover->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)
blendmode = PF_Subtractive;
FBITFIELD blendmode = HWR_GetBlendModeFlag(rover->blend) | HWR_RippleBlend(gl_frontsector, rover, false);
light = R_GetPlaneLight(gl_frontsector, centerHeight, dup_viewz < cullHeight ? true : false);
@ -3221,7 +3203,7 @@ static void HWR_Subsector(size_t num)
true,
*rover->topheight,
*gl_frontsector->lightlist[light].lightlevel,
rover->alpha-1 > 255 ? 255 : rover->alpha-1, rover->master->frontsector, blendmode,
rover->alpha-1, rover->master->frontsector, blendmode,
false, *gl_frontsector->lightlist[light].extra_colormap);
}
else
@ -3882,26 +3864,35 @@ static void HWR_SplitSprite(gl_vissprite_t *spr)
else
occlusion = PF_Occlude;
if (spr->mobj->drawflags & MFD_TRANSMASK)
// Determine the blendmode and translucency value
{
blend = HWR_TranstableToAlpha((spr->mobj->drawflags & MFD_TRANSMASK)>>MFD_TRANSSHIFT, &Surf);
}
else if (spr->mobj->frame & FF_TRANSMASK)
{
INT32 trans = (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT;
if (spr->mobj->blendmode == AST_TRANSLUCENT && trans >= NUMTRANSMAPS)
return;
blend = HWR_SurfaceBlend(spr->mobj->blendmode, trans, &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)|occlusion;
if (!occlusion) use_linkdraw_hack = true;
UINT32 blendmode, trans;
if (spr->mobj->renderflags & RF_BLENDMASK)
blendmode = (spr->mobj->renderflags & RF_BLENDMASK) >> RF_BLENDSHIFT;
else
blendmode = (spr->mobj->frame & FF_BLENDMASK) >> FF_BLENDSHIFT;
if (blendmode)
blendmode++; // realign to constants
if (spr->mobj->renderflags & RF_TRANSMASK)
trans = (spr->mobj->renderflags & RF_TRANSMASK) >> RF_TRANSSHIFT;
else
trans = (spr->mobj->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
if (trans >= NUMTRANSMAPS)
return; // cap
if (trans)
blend = HWR_SurfaceBlend(blendmode, trans, &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;
}
}
alpha = Surf.PolyColor.s.alpha;
@ -4308,26 +4299,35 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
else
occlusion = PF_Occlude;
if (spr->mobj->drawflags & MFD_TRANSMASK)
// Determine the blendmode and translucency value
{
blend = HWR_TranstableToAlpha((spr->mobj->drawflags & MFD_TRANSMASK)>>MFD_TRANSSHIFT, &Surf);
}
else if (spr->mobj->frame & FF_TRANSMASK)
{
INT32 trans = (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT;
if (spr->mobj->blendmode == AST_TRANSLUCENT && trans >= NUMTRANSMAPS)
return;
blend = HWR_SurfaceBlend(spr->mobj->blendmode, trans, &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)|occlusion;
if (!occlusion) use_linkdraw_hack = true;
UINT32 blendmode, trans;
if (spr->mobj->renderflags & RF_BLENDMASK)
blendmode = (spr->mobj->renderflags & RF_BLENDMASK) >> RF_BLENDSHIFT;
else
blendmode = (spr->mobj->frame & FF_BLENDMASK) >> FF_BLENDSHIFT;
if (blendmode)
blendmode++; // realign to constants
if (spr->mobj->renderflags & RF_TRANSMASK)
trans = (spr->mobj->renderflags & RF_TRANSMASK) >> RF_TRANSSHIFT;
else
trans = (spr->mobj->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
if (trans >= NUMTRANSMAPS)
return; // cap
if (trans)
blend = HWR_SurfaceBlend(blendmode, trans, &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)
@ -4426,21 +4426,34 @@ static inline void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
HWR_Lighting(&Surf, lightlevel, colormap);
}
if (spr->mobj->frame & FF_TRANSMASK)
// Determine the blendmode and translucency value
{
INT32 trans = (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT;
if (spr->mobj->blendmode == AST_TRANSLUCENT && trans >= NUMTRANSMAPS)
return;
blend = HWR_SurfaceBlend(spr->mobj->blendmode, trans, &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;
UINT32 blendmode, trans;
if (spr->mobj->renderflags & RF_BLENDMASK)
blendmode = (spr->mobj->renderflags & RF_BLENDMASK) >> RF_BLENDSHIFT;
else
blendmode = (spr->mobj->frame & FF_BLENDMASK) >> FF_BLENDSHIFT;
if (blendmode)
blendmode++; // realign to constants
if (spr->mobj->renderflags & RF_TRANSMASK)
trans = (spr->mobj->renderflags & RF_TRANSMASK) >> RF_TRANSSHIFT;
else
trans = (spr->mobj->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
if (trans >= NUMTRANSMAPS)
return; // cap
if (trans)
blend = HWR_SurfaceBlend(blendmode, trans, &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)|PF_Occlude;
}
}
HWR_ProcessPolygon(&Surf, wallVerts, 4, blend|PF_Modulated, SHADER_SPRITE, false); // sprite shader
@ -4471,8 +4484,8 @@ static int CompareVisSprites(const void *p1, const void *p2)
int transparency1;
int transparency2;
int drawflags1;
int drawflags2;
int renderflags1;
int renderflags2;
int frame1;
int frame2;
@ -4489,46 +4502,46 @@ static int CompareVisSprites(const void *p1, const void *p2)
if (linkdraw1)
{
tz1 = spr1->tracertz;
drawflags1 = spr1->mobj->tracer->drawflags;
renderflags1 = spr1->mobj->tracer->renderflags;
frame1 = spr1->mobj->tracer->frame;
}
else
{
tz1 = spr1->tz;
drawflags1 = (spr1->precip ? 0 : spr1->mobj->drawflags);
renderflags1 = spr1->mobj->renderflags;
frame1 = spr1->mobj->frame;
}
if (linkdraw2)
{
tz2 = spr2->tracertz;
drawflags2 = spr2->mobj->tracer->drawflags;
renderflags2 = spr2->mobj->tracer->renderflags;
frame2 = spr2->mobj->tracer->frame;
}
else
{
tz2 = spr2->tz;
drawflags2 = (spr2->precip ? 0 : spr2->mobj->drawflags);
renderflags2 = spr2->mobj->renderflags;
frame2 = spr2->mobj->frame;
}
}
else
{
tz1 = spr1->tz;
drawflags1 = (spr1->precip ? 0 : spr1->mobj->drawflags);
renderflags1 = (spr1->precip ? 0 : spr1->mobj->renderflags);
frame1 = spr1->mobj->frame;
tz2 = spr2->tz;
drawflags2 = (spr2->precip ? 0 : spr2->mobj->drawflags);
renderflags2 = (spr2->precip ? 0 : spr2->mobj->renderflags);
frame2 = spr2->mobj->frame;
}
// first compare transparency flags, then compare tz, then compare dispoffset
transparency1 = (drawflags1 & FF_TRANSMASK) ?
((drawflags1 & FF_TRANSMASK)>>MFD_TRANSSHIFT) :
transparency1 = (renderflags1 & RF_TRANSMASK) ?
((renderflags1 & RF_TRANSMASK)>>RF_TRANSSHIFT) :
((frame1 & FF_TRANSMASK)>>FF_TRANSSHIFT);
transparency2 = (drawflags2 & FF_TRANSMASK) ?
((drawflags2 & FF_TRANSMASK)>>MFD_TRANSSHIFT) :
transparency2 = (renderflags2 & RF_TRANSMASK) ?
((renderflags2 & RF_TRANSMASK)>>RF_TRANSSHIFT) :
((frame2 & FF_TRANSMASK)>>FF_TRANSSHIFT);
idiff = transparency1 - transparency2;

30
src/hardware/hw_md2.c
View file

@ -418,7 +418,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++;
}
}
@ -1384,12 +1384,30 @@ boolean HWR_DrawModel(gl_vissprite_t *spr)
//if (tics > durs)
//durs = tics;
if (spr->mobj->frame & FF_TRANSMASK)
Surf.PolyFlags = HWR_SurfaceBlend(spr->mobj->blendmode, (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT, &Surf);
else
// Determine the blendmode and translucency value
{
Surf.PolyColor.s.alpha = 0xff;
Surf.PolyFlags = HWR_GetBlendModeFlag(spr->mobj->blendmode);
UINT32 blendmode, trans;
if (spr->mobj->renderflags & RF_BLENDMASK)
blendmode = (spr->mobj->renderflags & RF_BLENDMASK) >> RF_BLENDSHIFT;
else
blendmode = (spr->mobj->frame & FF_BLENDMASK) >> FF_BLENDSHIFT;
if (blendmode)
blendmode++; // realign to constants
if (spr->mobj->renderflags & RF_TRANSMASK)
trans = (spr->mobj->renderflags & RF_TRANSMASK) >> RF_TRANSSHIFT;
else
trans = (spr->mobj->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
if (trans >= NUMTRANSMAPS)
return false; // cap
if (trans)
Surf.PolyFlags = HWR_SurfaceBlend(blendmode, trans, &Surf);
else
{
Surf.PolyColor.s.alpha = 0xff;
Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
}
}
// don't forget to enable the depth test because we can't do this

4
src/hu_stuff.c
View file

@ -1835,7 +1835,7 @@ static void HU_DrawCEcho(void)
if (cechotext[i] == '\\')
pnumlines++;
y -= (pnumlines-1)*((realflags & V_RETURN8) ? 4 : 6);
y -= (pnumlines-1)*6;
// Prevent crashing because I'm sick of this
if (y < 0)
@ -1858,7 +1858,7 @@ static void HU_DrawCEcho(void)
*line = '\0';
V_DrawCenteredString(BASEVIDWIDTH/2, y, realflags, echoptr);
y += ((realflags & V_RETURN8) ? 8 : 12);
y += 12;
echoptr = line;
echoptr++;

18
src/info.c
View file

@ -1953,8 +1953,8 @@ state_t states[NUMSTATES] =
{SPR_EMBM, 25, -1, {NULL}, 0, 0, S_NULL}, // S_EMBLEM26
// Chaos Emeralds
{SPR_EMRC, FF_SEMIBRIGHT, 1, {NULL}, 0, 0, S_CHAOSEMERALD2}, // S_CHAOSEMERALD1
{SPR_EMRC, FF_FULLBRIGHT|FF_TRANSADD, 1, {NULL}, 0, 0, S_CHAOSEMERALD1}, // S_CHAOSEMERALD2
{SPR_EMRC, FF_SEMIBRIGHT, 1, {NULL}, 0, 0, S_CHAOSEMERALD2}, // S_CHAOSEMERALD1
{SPR_EMRC, FF_FULLBRIGHT|FF_ADD, 1, {NULL}, 0, 0, S_CHAOSEMERALD1}, // S_CHAOSEMERALD2
{SPR_EMRC, FF_FULLBRIGHT|1, -1, {NULL}, 1, 0, S_NULL}, // S_CHAOSEMERALD_UNDER
{SPR_ESPK, FF_FULLBRIGHT, 3, {NULL}, 0, 0, S_EMERALDSPARK2}, // S_EMERALDSPARK1
@ -2330,9 +2330,9 @@ state_t states[NUMSTATES] =
{SPR_CHAN, 0, -1, {NULL}, 0, 0, S_NULL}, // S_CEZCHAIN
// Flame
{SPR_FLAM, FF_FULLBRIGHT|FF_ANIMATE|FF_TRANSADD, 3*8, {A_FlameParticle}, 7, 3, S_FLAME}, // S_FLAME
{SPR_FLAM, FF_FULLBRIGHT|FF_ANIMATE|FF_TRANSADD|8, TICRATE, {NULL}, 3, 3, S_NULL}, // S_FLAMEPARTICLE
{SPR_FLAM, FF_FULLBRIGHT|FF_ANIMATE|FF_TRANSADD, -1, {NULL}, 7, 3, S_NULL}, // S_FLAMEREST
{SPR_FLAM, FF_FULLBRIGHT|FF_ANIMATE|FF_ADD, 3*8, {A_FlameParticle}, 7, 3, S_FLAME}, // S_FLAME
{SPR_FLAM, FF_FULLBRIGHT|FF_ANIMATE|FF_ADD|8, TICRATE, {NULL}, 3, 3, S_NULL}, // S_FLAMEPARTICLE
{SPR_FLAM, FF_FULLBRIGHT|FF_ANIMATE|FF_ADD, -1, {NULL}, 7, 3, S_NULL}, // S_FLAMEREST
// Eggman statue
{SPR_ESTA, 0, -1, {NULL}, 0, 0, S_NULL}, // S_EGGSTATUE1
@ -4523,10 +4523,10 @@ state_t states[NUMSTATES] =
{SPR_AUDI, 4|FF_ANIMATE, -1, {NULL}, 1, 17, S_NULL}, // S_AUDIENCE_CHAO_LOSE
{SPR_FLAM, FF_FULLBRIGHT|FF_TRANSADD|0, 3, {NULL}, 0, 0, S_FLAYM2}, // S_FLAYM1,
{SPR_FLAM, FF_FULLBRIGHT|FF_TRANSADD|1, 3, {NULL}, 0, 0, S_FLAYM3}, // S_FLAYM2,
{SPR_FLAM, FF_FULLBRIGHT|FF_TRANSADD|2, 3, {NULL}, 0, 0, S_FLAYM4}, // S_FLAYM3,
{SPR_FLAM, FF_FULLBRIGHT|FF_TRANSADD|3, 3, {NULL}, 0, 0, S_FLAYM1}, // S_FLAYM4,
{SPR_FLAM, FF_FULLBRIGHT|FF_ADD|0, 3, {NULL}, 0, 0, S_FLAYM2}, // S_FLAYM1,
{SPR_FLAM, FF_FULLBRIGHT|FF_ADD|1, 3, {NULL}, 0, 0, S_FLAYM3}, // S_FLAYM2,
{SPR_FLAM, FF_FULLBRIGHT|FF_ADD|2, 3, {NULL}, 0, 0, S_FLAYM4}, // S_FLAYM3,
{SPR_FLAM, FF_FULLBRIGHT|FF_ADD|3, 3, {NULL}, 0, 0, S_FLAYM1}, // S_FLAYM4,
{SPR_DECO, 0, -1, {NULL}, 0, 0, S_NULL}, // S_DEVIL,
{SPR_DECO, 1, -1, {NULL}, 0, 0, S_NULL}, // S_ANGEL,

4
src/k_battle.c
View file

@ -633,7 +633,7 @@ static void K_SpawnOvertimeLaser(fixed_t x, fixed_t y, fixed_t scale)
}
mo->angle = R_PointToAngle2(mo->x, mo->y, battleovertime.x, battleovertime.y) + ANGLE_90;
mo->drawflags |= (MFD_DONTDRAW & ~(K_GetPlayerDontDrawFlag(player)));
mo->renderflags |= (RF_DONTDRAW & ~(K_GetPlayerDontDrawFlag(player)));
P_SetScale(mo, scale);
@ -660,7 +660,7 @@ static void K_SpawnOvertimeLaser(fixed_t x, fixed_t y, fixed_t scale)
zpos += 346 * mo->scale * flip;
if (battleovertime.enabled < 10*TICRATE)
mo->drawflags |= MFD_TRANS50;
mo->renderflags |= RF_TRANS50;
break;
case 2:
P_SetMobjState(mo, S_OVERTIME_BULB2);

14
src/k_hud.c
View file

@ -1562,14 +1562,14 @@ static void K_DrawKartPositionNum(INT32 num)
fixed_t scale = FRACUNIT;
patch_t *localpatch = kp_positionnum[0][0];
INT32 fx = 0, fy = 0, fflags = 0;
INT32 addOrSub = V_ADDTRANS;
INT32 addOrSub = V_ADD;
boolean flipdraw = false; // flip the order we draw it in for MORE splitscreen bs. fun.
boolean flipvdraw = false; // used only for 2p splitscreen so overtaking doesn't make 1P's position fly off the screen.
boolean overtake = false;
if ((mapheaderinfo[gamemap - 1]->levelflags & LF_SUBTRACTNUM) == LF_SUBTRACTNUM)
{
addOrSub = V_SUBTRANS;
addOrSub = V_SUBTRACT;
}
if (stplyr->kartstuff[k_positiondelay] || stplyr->exiting)
@ -1645,7 +1645,7 @@ static void K_DrawKartPositionNum(INT32 num)
{
boolean useRedNums = K_IsPlayerLosing(stplyr);
if (addOrSub == V_SUBTRANS)
if (addOrSub == V_SUBTRACT)
{
// Subtracting RED will look BLUE, and vice versa.
useRedNums = !useRedNums;
@ -2807,7 +2807,7 @@ static void K_drawKartNameTags(void)
continue;
}
if (ntplayer->mo->drawflags & K_GetPlayerDontDrawFlag(stplyr))
if (ntplayer->mo->renderflags & K_GetPlayerDontDrawFlag(stplyr))
{
// Invisible on this screen
continue;
@ -3645,7 +3645,7 @@ static void K_drawKartFirstPerson(void)
UINT8 *colmap = NULL;
ticcmd_t *cmd = &stplyr->cmd;
if (stplyr->spectator || !stplyr->mo || (stplyr->mo->drawflags & MFD_DONTDRAW))
if (stplyr->spectator || !stplyr->mo || (stplyr->mo->renderflags & RF_DONTDRAW))
return;
if (stplyr == &players[displayplayers[1]] && r_splitscreen)
@ -3668,8 +3668,8 @@ static void K_drawKartFirstPerson(void)
if (stplyr->speed < (20*stplyr->mo->scale) && (leveltime & 1) && !r_splitscreen)
y++;
if (stplyr->mo->drawflags & MFD_TRANSMASK)
splitflags |= ((stplyr->mo->drawflags & MFD_TRANSMASK) >> MFD_TRANSSHIFT) << FF_TRANSSHIFT;
if (stplyr->mo->renderflags & RF_TRANSMASK)
splitflags |= ((stplyr->mo->renderflags & RF_TRANSMASK) >> RF_TRANSSHIFT) << FF_TRANSSHIFT;
else if (stplyr->mo->frame & FF_TRANSMASK)
splitflags |= (stplyr->mo->frame & FF_TRANSMASK);
}

46
src/k_kart.c
View file

@ -100,18 +100,18 @@ void K_TimerInit(void)
K_SpawnBattleCapsules();
}
UINT16 K_GetPlayerDontDrawFlag(player_t *player)
UINT32 K_GetPlayerDontDrawFlag(player_t *player)
{
UINT16 flag = 0;
UINT32 flag = 0;
if (player == &players[displayplayers[0]])
flag = MFD_DONTDRAWP1;
flag = RF_DONTDRAWP1;
else if (r_splitscreen >= 1 && player == &players[displayplayers[1]])
flag = MFD_DONTDRAWP2;
flag = RF_DONTDRAWP2;
else if (r_splitscreen >= 2 && player == &players[displayplayers[2]])
flag = MFD_DONTDRAWP3;
flag = RF_DONTDRAWP3;
else if (r_splitscreen >= 3 && player == &players[displayplayers[3]])
flag = MFD_DONTDRAWP4;
flag = RF_DONTDRAWP4;
return flag;
}
@ -1436,9 +1436,9 @@ static void K_DrawDraftCombiring(player_t *player, player_t *victim, fixed_t cur
band->fuse = 2;
if (transparent)
band->drawflags |= MFD_SHADOW;
band->renderflags |= RF_GHOSTLY;
band->drawflags |= MFD_DONTDRAW & ~(K_GetPlayerDontDrawFlag(player) | K_GetPlayerDontDrawFlag(victim));
band->renderflags |= RF_DONTDRAW & ~(K_GetPlayerDontDrawFlag(player) | K_GetPlayerDontDrawFlag(victim));
}
curx += stepx;
@ -1670,7 +1670,7 @@ void K_MatchGenericExtraFlags(mobj_t *mo, mobj_t *master)
K_FlipFromObject(mo, master);
// visibility (usually for hyudoro)
mo->drawflags = (master->drawflags & MFD_DONTDRAW);
mo->renderflags = (master->renderflags & RF_DONTDRAW);
}
// same as above, but does not adjust Z height when flipping
@ -1681,7 +1681,7 @@ void K_GenericExtraFlagsNoZAdjust(mobj_t *mo, mobj_t *master)
mo->flags2 = (mo->flags2 & ~MF2_OBJECTFLIP)|(master->flags2 & MF2_OBJECTFLIP);
// visibility (usually for hyudoro)
mo->drawflags = (master->drawflags & MFD_DONTDRAW);
mo->renderflags = (master->renderflags & RF_DONTDRAW);
}
@ -1741,7 +1741,7 @@ static void K_SpawnBrakeDriftSparks(player_t *player) // Be sure to update the m
P_SetTarget(&sparks->target, player->mo);
P_SetScale(sparks, (sparks->destscale = player->mo->scale));
K_MatchGenericExtraFlags(sparks, player->mo);
sparks->drawflags |= MFD_DONTDRAW;
sparks->renderflags |= RF_DONTDRAW;
}
static fixed_t K_RandomFlip(fixed_t f)
@ -3813,7 +3813,7 @@ void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
}
if (translucent)
dust->drawflags |= MFD_SHADOW;
dust->renderflags |= RF_GHOSTLY;
}
void K_SpawnDraftDust(mobj_t *mo)
@ -5039,7 +5039,7 @@ void K_DropRocketSneaker(player_t *player)
if (shoe->type != MT_ROCKETSNEAKER)
return; //woah, not a rocketsneaker, bail! safeguard in case this gets used when you're holding non-rocketsneakers
shoe->drawflags &= ~MFD_DONTDRAW;
shoe->renderflags &= ~RF_DONTDRAW;
shoe->flags &= ~MF_NOGRAVITY;
shoe->angle += ANGLE_45;
@ -5473,9 +5473,9 @@ static void K_MoveHeldObjects(player_t *player)
cur->flags &= ~MF_NOCLIPTHING;
if (player->kartstuff[k_rocketsneakertimer] <= TICRATE && (leveltime & 1))
cur->drawflags |= MFD_DONTDRAW;
cur->renderflags |= RF_DONTDRAW;
else
cur->drawflags &= ~MFD_DONTDRAW;
cur->renderflags &= ~RF_DONTDRAW;
if (num & 1)
P_SetMobjStateNF(cur, (vibrate ? S_ROCKETSNEAKER_LVIBRATE : S_ROCKETSNEAKER_L));
@ -6075,7 +6075,7 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
//ghost->momy = (3*player->mo->momy)/4;
//ghost->momz = (3*player->mo->momz)/4;
if (leveltime & 1)
ghost->drawflags |= MFD_DONTDRAW;
ghost->renderflags |= RF_DONTDRAW;
}
if (P_IsObjectOnGround(player->mo))
@ -6115,7 +6115,7 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
debtflag->color = player->skincolor;
debtflag->fuse = 2;
debtflag->drawflags = K_GetPlayerDontDrawFlag(player);
debtflag->renderflags = K_GetPlayerDontDrawFlag(player);
}
if (player->kartstuff[k_springstars] && (leveltime & 1))
@ -8468,33 +8468,33 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
if (leveltime & 1)
{
player->mo->drawflags |= MFD_DONTDRAW;
player->mo->renderflags |= RF_DONTDRAW;
}
else
{
if (player->kartstuff[k_hyudorotimer] >= (TICRATE/2) && player->kartstuff[k_hyudorotimer] <= hyu-(TICRATE/2))
player->mo->drawflags &= ~K_GetPlayerDontDrawFlag(player);
player->mo->renderflags &= ~K_GetPlayerDontDrawFlag(player);
else
player->mo->drawflags &= ~MFD_DONTDRAW;
player->mo->renderflags &= ~RF_DONTDRAW;
}
player->powers[pw_flashing] = player->kartstuff[k_hyudorotimer]; // We'll do this for now, let's people know about the invisible people through subtle hints
}
else if (player->kartstuff[k_hyudorotimer] == 0)
{
player->mo->drawflags &= ~MFD_DONTDRAW;
player->mo->renderflags &= ~RF_DONTDRAW;
}
if (gametype == GT_BATTLE && player->bumpers <= 0) // dead in match? you da bomb
{
K_DropItems(player); //K_StripItems(player);
K_StripOther(player);
player->mo->drawflags |= MFD_SHADOW;
player->mo->renderflags |= RF_GHOSTLY;
player->powers[pw_flashing] = player->karmadelay;
}
else if (gametype == GT_RACE || player->bumpers > 0)
{
player->mo->drawflags &= ~(MFD_TRANSMASK|MFD_BRIGHTMASK);
player->mo->renderflags &= ~(RF_TRANSMASK|RF_BRIGHTMASK);
}
if (player->trickpanel == 1)

2
src/k_kart.h
View file

@ -19,7 +19,7 @@ void K_RegisterKartStuff(void);
void K_TimerReset(void);
void K_TimerInit(void);
UINT16 K_GetPlayerDontDrawFlag(player_t *player);
UINT32 K_GetPlayerDontDrawFlag(player_t *player);
boolean K_IsPlayerLosing(player_t *player);
fixed_t K_GetKartGameSpeedScalar(SINT8 value);

6
src/k_race.c
View file

@ -304,7 +304,7 @@ static void K_DrawFinishLineBeamForLine(fixed_t offset, angle_t aiming, line_t *
P_SetMobjState(beam, S_FINISHBEAM1 + spriteframe);
beam->colorized = true;
beam->drawflags = MFD_DONTDRAW & ~K_GetPlayerDontDrawFlag(&players[displayplayers[i]]);
beam->renderflags = RF_DONTDRAW & ~K_GetPlayerDontDrawFlag(&players[displayplayers[i]]);
if (reverse)
{
@ -369,7 +369,7 @@ static void K_DrawFinishLineBeamForLine(fixed_t offset, angle_t aiming, line_t *
);
P_SetMobjState(end1, S_FINISHBEAMEND1);
end1->drawflags = MFD_DONTDRAW & ~K_GetPlayerDontDrawFlag(&players[displayplayers[i]]);
end1->renderflags = RF_DONTDRAW & ~K_GetPlayerDontDrawFlag(&players[displayplayers[i]]);
end1->angle = lineangle;
end2 = P_SpawnMobj(
@ -380,7 +380,7 @@ static void K_DrawFinishLineBeamForLine(fixed_t offset, angle_t aiming, line_t *
);
P_SetMobjState(end2, S_FINISHBEAMEND2);
end2->drawflags = MFD_DONTDRAW & ~K_GetPlayerDontDrawFlag(&players[displayplayers[i]]);
end2->renderflags = RF_DONTDRAW & ~K_GetPlayerDontDrawFlag(&players[displayplayers[i]]);
end2->angle = lineangle;
P_SetTarget(&end2->tracer, end1);

2
src/lua_baselib.c
View file

@ -687,7 +687,7 @@ static int lib_pSpawnLockOn(lua_State *L)
{
mobj_t *visual = P_SpawnMobj(lockon->x, lockon->y, lockon->z, MT_LOCKON); // positioning, flip handled in P_SceneryThinker
P_SetTarget(&visual->target, lockon);
visual->drawflags |= MFD_DONTDRAW;
visual->renderflags |= RF_DONTDRAW;
P_SetMobjStateNF(visual, state);
}
return 0;

8
src/lua_maplib.c
View file

@ -196,6 +196,7 @@ enum ffloor_e {
ffloor_next,
ffloor_prev,
ffloor_alpha,
ffloor_blend,
};
static const char *const ffloor_opt[] = {
@ -214,6 +215,7 @@ static const char *const ffloor_opt[] = {
"next",
"prev",
"alpha",
"blend",
NULL};
#ifdef HAVE_LUA_SEGS
@ -1796,6 +1798,9 @@ static int ffloor_get(lua_State *L)
case ffloor_alpha:
lua_pushinteger(L, ffloor->alpha);
return 1;
case ffloor_blend:
lua_pushinteger(L, ffloor->blend);
return 1;
}
return 0;
}
@ -1874,6 +1879,9 @@ static int ffloor_set(lua_State *L)
case ffloor_alpha:
ffloor->alpha = (INT32)luaL_checkinteger(L, 3);
break;
case ffloor_blend:
ffloor->blend = (INT32)luaL_checkinteger(L, 3);
break;
}
return 0;
}

16
src/lua_mobjlib.c
View file

@ -59,11 +59,9 @@ enum mobj_e {
mobj_flags,
mobj_flags2,
mobj_eflags,
mobj_drawflags,
mobj_renderflags,
mobj_skin,
mobj_color,
mobj_blendmode,
mobj_bnext,
mobj_bprev,
mobj_hnext,
@ -141,11 +139,9 @@ static const char *const mobj_opt[] = {
"flags",
"flags2",
"eflags",
"drawflags",
"renderflags",
"skin",
"color",
"blendmode",
"bnext",
"bprev",
"hnext",
@ -316,9 +312,6 @@ static int mobj_get(lua_State *L)
case mobj_eflags:
lua_pushinteger(L, mo->eflags);
break;
case mobj_drawflags:
lua_pushinteger(L, mo->drawflags);
break;
case mobj_renderflags:
lua_pushinteger(L, mo->renderflags);
break;
@ -330,9 +323,6 @@ static int mobj_get(lua_State *L)
case mobj_color:
lua_pushinteger(L, mo->color);
break;
case mobj_blendmode:
lua_pushinteger(L, mo->blendmode);
break;
case mobj_bnext:
LUA_PushUserdata(L, mo->bnext, META_MOBJ);
break;
@ -660,9 +650,6 @@ static int mobj_set(lua_State *L)
case mobj_eflags:
mo->eflags = (UINT16)luaL_checkinteger(L, 3);
break;
case mobj_drawflags:
mo->drawflags = (UINT16)luaL_checkinteger(L, 3);
break;
case mobj_renderflags:
mo->renderflags = (UINT32)luaL_checkinteger(L, 3);
break;
@ -689,9 +676,6 @@ static int mobj_set(lua_State *L)
mo->color = newcolor;
break;
}
case mobj_blendmode:
mo->blendmode = (INT32)luaL_checkinteger(L, 3);
break;
case mobj_bnext:
return NOSETPOS;
case mobj_bprev:

2
src/m_cheat.c
View file

@ -1192,7 +1192,7 @@ void Command_ObjectPlace_f(void)
if (! silent)
{
HU_SetCEchoFlags(V_RETURN8|V_MONOSPACE);
HU_SetCEchoFlags(V_MONOSPACE);
HU_SetCEchoDuration(10);
HU_DoCEcho(va(M_GetText(
"\\\\\\\\\\\\\\\\\\\\\\\\\x82"

2
src/m_cond.c
View file

@ -226,7 +226,7 @@ UINT8 M_UpdateUnlockablesAndExtraEmblems(void)
strcat(slashed, cechoText);
HU_SetCEchoFlags(V_YELLOWMAP|V_RETURN8);
HU_SetCEchoFlags(V_YELLOWMAP);
HU_SetCEchoDuration(6);
HU_DoCEcho(slashed);
return true;

12
src/m_menu.c
View file

@ -3627,7 +3627,7 @@ static void M_DrawThermo(INT32 x, INT32 y, consvar_t *cv)
xx += SHORT(p->width) - SHORT(p->leftoffset);
for (i = 0; i < 16; i++)
{
V_DrawScaledPatch(xx, y, V_WRAPX, W_CachePatchNum(centerlump[i & 1], PU_CACHE));
V_DrawScaledPatch(xx, y, 0, W_CachePatchNum(centerlump[i & 1], PU_CACHE));
xx += 8;
}
V_DrawScaledPatch(xx, y, 0, W_CachePatchNum(rightlump, PU_CACHE));
@ -3731,8 +3731,8 @@ void M_DrawTextBox(INT32 x, INT32 y, INT32 width, INT32 boxlines)
cy = y;
while (width > 0)
{
V_DrawScaledPatch(cx, cy, V_WRAPX, W_CachePatchNum(viewborderlump[BRDR_T], PU_CACHE));
V_DrawScaledPatch(cx, y + boff + boxlines*step, V_WRAPX, W_CachePatchNum(viewborderlump[BRDR_B], PU_CACHE));
V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_T], PU_CACHE));
V_DrawScaledPatch(cx, y + boff + boxlines*step, 0, W_CachePatchNum(viewborderlump[BRDR_B], PU_CACHE));
width--;
cx += step;
}
@ -6493,7 +6493,7 @@ static void M_DrawChecklist(void)
++line;
secretname = M_CreateSecretMenuOption(unlockables[i].name);
V_DrawString(8, (line*8), V_RETURN8|(unlockables[i].unlocked ? recommendedflags : warningflags), (secret ? secretname : unlockables[i].name));
V_DrawString(8, (line*8), (unlockables[i].unlocked ? recommendedflags : warningflags), (secret ? secretname : unlockables[i].name));
if (conditionSets[unlockables[i].conditionset - 1].numconditions)
{
@ -6574,7 +6574,7 @@ static void M_DrawEmblemHints(void)
else
hint = M_GetText("No hints available.");
hint = V_WordWrap(40, BASEVIDWIDTH-12, 0, hint);
V_DrawString(40, 8+(28*j), V_RETURN8|V_ALLOWLOWERCASE|collected, hint);
V_DrawString(40, 8+(28*j), V_ALLOWLOWERCASE|collected, hint);
if (++j >= NUMHINTS)
break;
@ -7423,7 +7423,7 @@ static void M_DrawSetupChoosePlayerMenu(void)
M_DrawTextBox(136, my, 21, 20);
if (!char_notes)
char_notes = V_WordWrap(0, 21*8, V_ALLOWLOWERCASE, description[itemOn].notes);
V_DrawString(146, my + 9, V_RETURN8|V_ALLOWLOWERCASE, char_notes);
V_DrawString(146, my + 9, V_ALLOWLOWERCASE, char_notes);
}
// Chose the player you want to use Tails 03-02-2002

16
src/p_enemy.c
View file

@ -4000,10 +4000,10 @@ void A_BubbleSpawn(mobj_t *actor)
if (!(actor->eflags & MFE_UNDERWATER))
{
// Don't draw or spawn bubbles above water
actor->drawflags |= MFD_DONTDRAW;
actor->renderflags |= RF_DONTDRAW;
return;
}
actor->drawflags &= ~MFD_DONTDRAW;
actor->renderflags &= ~RF_DONTDRAW;
if (!(actor->flags2 & MF2_AMBUSH))
{
@ -4133,9 +4133,9 @@ void A_BubbleCheck(mobj_t *actor)
return;
if (actor->eflags & MFE_UNDERWATER)
actor->drawflags &= ~MFD_DONTDRAW; // underwater so draw
actor->renderflags &= ~RF_DONTDRAW; // underwater so draw
else
actor->drawflags |= MFD_DONTDRAW; // above water so don't draw
actor->renderflags |= RF_DONTDRAW; // above water so don't draw
}
// Function: A_AttractChase
@ -4236,9 +4236,9 @@ void A_AttractChase(mobj_t *actor)
// Rings flicker before disappearing
if (actor->fuse && actor->fuse < 5*TICRATE && (leveltime & 1))
actor->drawflags |= MFD_DONTDRAW;
actor->renderflags |= RF_DONTDRAW;
else
actor->drawflags &= ~MFD_DONTDRAW;
actor->renderflags &= ~RF_DONTDRAW;
// spilled rings get capped to a certain speed
if (actor->type == (mobjtype_t)actor->info->reactiontime)
@ -13264,7 +13264,7 @@ void A_RolloutRock(mobj_t *actor)
if (!(actor->flags & MF_PUSHABLE) || (actor->movecount != 1)) // if being ridden or haven't moved, don't disappear
actor->fuse = actor->info->painchance;
else if (actor->fuse < 2*TICRATE)
actor->drawflags ^= MFD_DONTDRAW;
actor->renderflags ^= RF_DONTDRAW;
}
@ -14406,7 +14406,7 @@ void A_RandomShadowFrame(mobj_t *actor)
fake->destscale = FRACUNIT*3/2;
fake->angle = actor->angle;
fake->tics = -1;
actor->drawflags |= MFD_DONTDRAW;
actor->renderflags |= RF_DONTDRAW;
actor->extravalue1 = 1;
}

6
src/p_inter.c
View file

@ -1147,7 +1147,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
if (metalrecording) // Ack! Metal Sonic shouldn't die! Cut the tape, end recording!
G_StopMetalRecording(true);
target->drawflags &= ~MFD_DONTDRAW;
target->renderflags &= ~RF_DONTDRAW;
}
// if killed by a player
@ -1776,7 +1776,7 @@ static boolean P_KillPlayer(player_t *player, mobj_t *inflictor, mobj_t *source,
if (player->spectator == false)
{
player->mo->drawflags &= ~MFD_DONTDRAW;
player->mo->renderflags &= ~RF_DONTDRAW;
}
P_SetPlayerMobjState(player->mo, player->mo->info->deathstate);
@ -1788,7 +1788,7 @@ static boolean P_KillPlayer(player_t *player, mobj_t *inflictor, mobj_t *source,
mobj_t *boom;
player->mo->flags |= (MF_NOGRAVITY|MF_NOCLIP);
player->mo->drawflags |= MFD_DONTDRAW;
player->mo->renderflags |= RF_DONTDRAW;
boom = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_FZEROBOOM);
boom->scale = player->mo->scale;

137
src/p_mobj.c
View file

@ -2286,7 +2286,7 @@ boolean P_ZMovement(mobj_t *mo)
S_StartSound(mo, sfx_tink);
}
else
mo->flags2 ^= MFD_DONTDRAW;
mo->flags2 ^= RF_DONTDRAW;
}
else if (mo->type == MT_DEBTSPIKE)
{
@ -3740,16 +3740,16 @@ static void P_RingThinker(mobj_t *mobj)
if (mobj->fuse < TICRATE*3)
{
if (leveltime & 1)
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
else
mobj->drawflags &= ~MFD_DONTDRAW;
mobj->renderflags &= ~RF_DONTDRAW;
}
if (!mobj->fuse)
{
if (!LUAh_MobjFuse(mobj))
{
mobj->drawflags &= ~MFD_DONTDRAW;
mobj->renderflags &= ~RF_DONTDRAW;
spark = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_SIGNSPARKLE); // Spawn a fancy sparkle
K_MatchGenericExtraFlags(spark, mobj);
spark->colorized = true;
@ -4415,7 +4415,7 @@ void P_MaceRotate(mobj_t *center, INT32 baserot, INT32 baseprevrot)
#if 0 // toaster's testing flashie!
if (!(mobj->movecount & 1) && !(leveltime & TICRATE)) // I had a brainfart and the flashing isn't exactly what I expected it to be, but it's actually much more useful.
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
#endif
P_SetThingPosition(mobj);
@ -4486,14 +4486,14 @@ static boolean P_ShieldLook(mobj_t *thing, shieldtype_t shield)
if (thing->info->painstate)
P_SetMobjState(thing,thing->info->painstate);
else
thing->drawflags |= MFD_SHADOW;
thing->renderflags |= RF_GHOSTLY;
}
else
{
if (thing->info->painstate)
P_SetMobjState(thing,thing->info->spawnstate);
else
thing->drawflags &= ~(MFD_TRANSMASK|MFD_BRIGHTMASK);
thing->renderflags &= ~(RF_TRANSMASK|RF_BRIGHTMASK);
}
}
@ -4781,7 +4781,7 @@ static void P_MobjScaleThink(mobj_t *mobj)
{
if (mobj->scale <= 1)
{
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
}
}
else
@ -4825,9 +4825,9 @@ static void P_MaceSceneryThink(mobj_t *mobj)
{
ref->eflags = (((ref->flags & MF_NOTHINK) ? 0 : 1)
| ((ref->flags & MF_NOCLIPTHING) ? 0 : 2)
| ((ref->drawflags & MFD_DONTDRAW) ? 0 : 4)); // oh my god this is nasty.
| ((ref->renderflags & RF_DONTDRAW) ? 0 : 4)); // oh my god this is nasty.
ref->flags |= MF_NOTHINK|MF_NOCLIPTHING;
ref->drawflags |= MFD_DONTDRAW;
ref->renderflags |= RF_DONTDRAW;
ref->momx = ref->momy = ref->momz = 0;
}
@ -4847,7 +4847,7 @@ static void P_MaceSceneryThink(mobj_t *mobj)
if (ref->eflags & 2)
ref->flags &= ~MF_NOCLIPTHING;
if (ref->eflags & 4)
ref->drawflags &= ~MFD_DONTDRAW;
ref->renderflags &= ~RF_DONTDRAW;
ref->eflags = 0; // le sign
}
@ -5009,7 +5009,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
switch (mobj->type)
{
case MT_BOSSJUNK:
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
break;
case MT_MACEPOINT:
case MT_CHAINMACEPOINT:
@ -5229,7 +5229,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
return;
}
mobj->drawflags &= ~MFD_DONTDRAW;
mobj->renderflags &= ~RF_DONTDRAW;
mobj->x = mobj->target->x;
mobj->y = mobj->target->y;
@ -5526,7 +5526,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
offz = mobj->target->height / 5;
}
mobj->drawflags = (mobj->target->drawflags & MFD_DONTDRAW);
mobj->renderflags = (mobj->target->renderflags & RF_DONTDRAW);
if (mobj->target->eflags & MFE_VERTICALFLIP)
{
@ -5585,7 +5585,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
case MT_BATTLEBUMPER_DEBRIS:
if (mobj->state == states + S_BATTLEBUMPER_EXDEBRIS2)
{
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
}
break;
@ -5604,7 +5604,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
|| (P_IsDisplayPlayer(mobj->target->player))
#endif
)
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
P_UnsetThingPosition(mobj);
mobj->x = mobj->target->x;
@ -5654,7 +5654,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
mobj->tracer->colorized = false;
}
if (!(mobj->drawflags & MFD_DONTDRAW))
if (!(mobj->renderflags & RF_DONTDRAW))
{
const INT32 numberdisplaymin = ((mobj->target->player->kartstuff[k_itemtype] == KITEM_ORBINAUT) ? 5 : 2);
@ -5664,7 +5664,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
P_SetMobjState(mobj, S_PLAYERARROW_BOX);
mobj->tracer->sprite = SPR_ITEM;
mobj->tracer->frame = FF_FULLBRIGHT|(((mobj->target->player->kartstuff[k_itemroulette] % (13*3)) / 3) + 1);
mobj->tracer->drawflags &= ~MFD_DONTDRAW;
mobj->tracer->renderflags &= ~RF_DONTDRAW;
}
else if (mobj->target->player->kartstuff[k_stolentimer] > 0)
{
@ -5672,16 +5672,16 @@ static void P_MobjSceneryThink(mobj_t *mobj)
mobj->tracer->sprite = SPR_ITEM;
mobj->tracer->frame = FF_FULLBRIGHT|KITEM_HYUDORO;
if (leveltime & 2)
mobj->tracer->drawflags &= ~MFD_DONTDRAW;
mobj->tracer->renderflags &= ~RF_DONTDRAW;
else
mobj->tracer->drawflags |= MFD_DONTDRAW;
mobj->tracer->renderflags |= RF_DONTDRAW;
}
else if ((mobj->target->player->kartstuff[k_stealingtimer] > 0) && (leveltime & 2))
{
P_SetMobjState(mobj, S_PLAYERARROW_BOX);
mobj->tracer->sprite = SPR_ITEM;
mobj->tracer->frame = FF_FULLBRIGHT|KITEM_HYUDORO;
mobj->tracer->drawflags &= ~MFD_DONTDRAW;
mobj->tracer->renderflags &= ~RF_DONTDRAW;
}
else if (mobj->target->player->kartstuff[k_eggmanexplode] > 1)
{
@ -5689,9 +5689,9 @@ static void P_MobjSceneryThink(mobj_t *mobj)
mobj->tracer->sprite = SPR_ITEM;
mobj->tracer->frame = FF_FULLBRIGHT|KITEM_EGGMAN;
if (leveltime & 1)
mobj->tracer->drawflags &= ~MFD_DONTDRAW;
mobj->tracer->renderflags &= ~RF_DONTDRAW;
else
mobj->tracer->drawflags |= MFD_DONTDRAW;
mobj->tracer->renderflags |= RF_DONTDRAW;
}
else if (mobj->target->player->kartstuff[k_rocketsneakertimer] > 1)
{
@ -5700,9 +5700,9 @@ static void P_MobjSceneryThink(mobj_t *mobj)
mobj->tracer->sprite = SPR_ITEM;
mobj->tracer->frame = FF_FULLBRIGHT|KITEM_ROCKETSNEAKER;
if (leveltime & 1)
mobj->tracer->drawflags &= ~MFD_DONTDRAW;
mobj->tracer->renderflags &= ~RF_DONTDRAW;
else
mobj->tracer->drawflags |= MFD_DONTDRAW;
mobj->tracer->renderflags |= RF_DONTDRAW;
}
else if (mobj->target->player->kartstuff[k_itemtype] && mobj->target->player->kartstuff[k_itemamount] > 0)
{
@ -5731,12 +5731,12 @@ static void P_MobjSceneryThink(mobj_t *mobj)
if (mobj->target->player->kartstuff[k_itemheld])
{
if (leveltime & 1)
mobj->tracer->drawflags &= ~MFD_DONTDRAW;
mobj->tracer->renderflags &= ~RF_DONTDRAW;
else
mobj->tracer->drawflags |= MFD_DONTDRAW;
mobj->tracer->renderflags |= RF_DONTDRAW;
}
else
mobj->tracer->drawflags &= ~MFD_DONTDRAW;
mobj->tracer->renderflags &= ~RF_DONTDRAW;
}
else
{
@ -5777,7 +5777,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
mobj->movecount = 0;
}
else
mobj->tracer->drawflags |= MFD_DONTDRAW;
mobj->tracer->renderflags |= RF_DONTDRAW;
}
else if (mobj->health > 0)
{
@ -5800,10 +5800,10 @@ static void P_MobjSceneryThink(mobj_t *mobj)
return;
}
if (mobj->tracer->drawflags & MFD_DONTDRAW)
mobj->drawflags |= MFD_DONTDRAW;
if (mobj->tracer->renderflags & RF_DONTDRAW)
mobj->renderflags |= RF_DONTDRAW;
else
mobj->drawflags &= ~MFD_DONTDRAW;
mobj->renderflags &= ~RF_DONTDRAW;
P_UnsetThingPosition(mobj);
mobj->x = mobj->target->x;
@ -5854,10 +5854,10 @@ static void P_MobjSceneryThink(mobj_t *mobj)
mobj->eflags |= MFE_VERTICALFLIP;
if (mobj->tics > 0)
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
break;
case MT_SPINDASHWIND:
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
break;
case MT_VWREF:
case MT_VWREB:
@ -5949,7 +5949,7 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
if (mobj->player)
{
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
}
else // safe to remove, nobody's going to complain!
{
@ -5991,7 +5991,7 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
case MT_ORBINAUT_SHIELD:
case MT_BANANA_SHIELD:
case MT_EGGMANITEM_SHIELD:
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
break;
case MT_JAWZ:
case MT_JAWZ_DUD:
@ -5999,7 +5999,7 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
P_SetMobjState(mobj, mobj->info->xdeathstate);
/* FALLTHRU */
case MT_JAWZ_SHIELD:
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
break;
case MT_SSMINE:
case MT_SPBEXPLOSION:
@ -6019,7 +6019,7 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
return false;
case MT_CDUFO:
if (mobj->fuse > TICRATE)
mobj->drawflags ^= MFD_DONTDRAW; // only by good fortune does this end with it having MFD_DONTDRAW... don't touch!
mobj->renderflags ^= RF_DONTDRAW; // only by good fortune does this end with it having RF_DONTDRAW... don't touch!
break;
case MT_SMK_PIPE:
if (mobj->flags2 & MF2_AMBUSH)
@ -6028,7 +6028,7 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
P_SetMobjStateNF(mobj, mobj->info->spawnstate);
/* FALLTHRU */
case MT_SMK_MOLE:
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
if (P_IsObjectOnGround(mobj))
{
P_RemoveMobj(mobj);
@ -6049,7 +6049,7 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
mobj->frame &= (~FF_FULLBRIGHT);
}
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
if (P_IsObjectOnGround(mobj))
{
P_RemoveMobj(mobj);
@ -6724,7 +6724,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
{
mobj->color = SKINCOLOR_KETCHUP;
/* don't draw papersprite frames after blue boost */
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
}
else if (mobj->fuse <= 32)
mobj->color = SKINCOLOR_SAPPHIRE;
@ -6869,7 +6869,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
K_MatchGenericExtraFlags(mobj, mobj->target);
if (leveltime & 1)
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
}
break;
case MT_PLAYERRETICULE:
@ -6881,7 +6881,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
P_TeleportMove(mobj, mobj->target->x, mobj->target->y, mobj->target->z);
break;
case MT_INSTASHIELDB:
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
K_MatchGenericExtraFlags(mobj, mobj->target);
/* FALLTHRU */
case MT_INSTASHIELDA:
@ -6991,14 +6991,14 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
mobj->angle = ang;
if (leveltime & 1)
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
if (trans >= NUMTRANSMAPS)
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
else if (trans == 0)
mobj->drawflags = (mobj->drawflags & ~MFD_TRANSMASK);
mobj->renderflags = (mobj->renderflags & ~RF_TRANSMASK);
else
mobj->drawflags = (mobj->drawflags & ~MFD_TRANSMASK)|(trans << MFD_TRANSSHIFT);
mobj->renderflags = (mobj->renderflags & ~RF_TRANSMASK)|(trans << RF_TRANSSHIFT);
}
break;
case MT_THUNDERSHIELD:
@ -7065,7 +7065,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
P_SetMobjState(mobj, S_BUBBLESHIELDBLOWUP);
mobj->angle += ANGLE_22h;
mobj->drawflags &= ~MFD_SHADOW;
mobj->renderflags &= ~RF_GHOSTLYMASK;
scale += (blow * (3*scale)) / bubbletime;
mobj->frame = (states[S_BUBBLESHIELDBLOWUP].frame + mobj->extravalue1);
@ -7135,9 +7135,9 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
else
{
if (mobj->target->player->kartstuff[k_bubblecool] && ((curstate-S_BUBBLESHIELD1) & 1))
mobj->drawflags |= MFD_SHADOW;
mobj->renderflags |= RF_GHOSTLY;
else
mobj->drawflags &= ~MFD_SHADOW;
mobj->renderflags &= ~RF_GHOSTLYMASK;
}
}
@ -7336,9 +7336,9 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
if (state < S_PLAYERBOMB1 || state > S_PLAYERBOMB20)
P_SetMobjState(mobj, S_PLAYERBOMB1);
if (mobj->target->player->karmadelay < TICRATE && (leveltime & 1))
mobj->drawflags &= ~MFD_DONTDRAW;
mobj->renderflags &= ~RF_DONTDRAW;
else
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
}
else
{
@ -7353,9 +7353,9 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
P_SetMobjState(mobj, S_PLAYERFAKE1);
if (mobj->target->player->powers[pw_flashing] && (leveltime & 1))
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
else
mobj->drawflags &= ~MFD_DONTDRAW;
mobj->renderflags &= ~RF_DONTDRAW;
}
// Update mobj antigravity status:
@ -7385,10 +7385,10 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
cur->colorized = true;
K_FlipFromObject(cur, mobj->target);
if (mobj->drawflags & MFD_DONTDRAW)
cur->drawflags |= MFD_DONTDRAW;
if (mobj->renderflags & RF_DONTDRAW)
cur->renderflags |= RF_DONTDRAW;
else
cur->drawflags &= ~MFD_DONTDRAW;
cur->renderflags &= ~RF_DONTDRAW;
cur = cur->hnext;
}
@ -8564,10 +8564,10 @@ for (i = ((mobj->flags2 & MF2_STRONGBOX) ? strongboxamt : weakboxamt); i; --i) s
static boolean P_FuseThink(mobj_t *mobj)
{
if (mobj->type == MT_SNAPPER_HEAD || mobj->type == MT_SNAPPER_LEG || mobj->type == MT_MINECARTSEG)
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
if (mobj->fuse <= TICRATE && ((mobj->type == MT_RANDOMITEM && mobj->threshold == 69) || mobj->type == MT_EGGMANITEM || mobj->type == MT_FALLINGROCK))
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
mobj->fuse--;
@ -9075,13 +9075,13 @@ void P_SceneryThinker(mobj_t *mobj)
&& mobj->extravalue1 > 0 && mobj->extravalue2 >= 2)
{
if (mobj->extravalue2 == 2) // I don't know why the normal logic doesn't work for this.
mobj->drawflags ^= MFD_DONTDRAW;
mobj->renderflags ^= RF_DONTDRAW;
else
{
if (mobj->fuse == mobj->extravalue2)
mobj->drawflags &= ~MFD_DONTDRAW;
mobj->renderflags &= ~RF_DONTDRAW;
else
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
}
}
@ -9162,7 +9162,7 @@ void P_SceneryThinker(mobj_t *mobj)
static void P_DefaultMobjShadowScale(mobj_t *thing)
{
thing->shadowscale = 0;
thing->whiteshadow = (thing->frame & FF_FULLBRIGHT);
thing->whiteshadow = ((thing->frame & FF_BRIGHTMASK) == FF_FULLBRIGHT);
switch (thing->type)
{
@ -9284,7 +9284,6 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
}
// Sprite rendering
mobj->blendmode = AST_TRANSLUCENT;
mobj->spritexscale = mobj->spriteyscale = mobj->scale;
mobj->spritexoffset = mobj->spriteyoffset = 0;
mobj->floorspriteslope = NULL;
@ -10505,7 +10504,7 @@ void P_SpawnPlayer(INT32 playernum)
{
mobj_t *overheadarrow = P_SpawnMobj(mobj->x, mobj->y, mobj->z + mobj->height + 16*FRACUNIT, MT_PLAYERARROW);
P_SetTarget(&overheadarrow->target, mobj);
overheadarrow->drawflags |= MFD_DONTDRAW;
overheadarrow->renderflags |= RF_DONTDRAW;
P_SetScale(overheadarrow, mobj->destscale);
if (p->spectator)
@ -10536,10 +10535,10 @@ void P_SpawnPlayer(INT32 playernum)
P_SetTarget(&mo->target, mobj);
mo->angle = (diff * (i-1));
mo->color = mobj->color;
if (mobj->drawflags & MFD_DONTDRAW)
mo->drawflags |= MFD_DONTDRAW;
if (mobj->renderflags & RF_DONTDRAW)
mo->renderflags |= RF_DONTDRAW;
else
mo->drawflags &= ~MFD_DONTDRAW;
mo->renderflags &= ~RF_DONTDRAW;
}
}
}
@ -12110,7 +12109,7 @@ static mobj_t *P_SpawnMobjFromMapThing(mapthing_t *mthing, fixed_t x, fixed_t y,
// Final set of not being able to draw nightsitems.
if (mobj->flags & MF_NIGHTSITEM)
mobj->drawflags |= MFD_DONTDRAW;
mobj->renderflags |= RF_DONTDRAW;
return mobj;
}

39
src/p_mobj.h
View file

@ -250,42 +250,6 @@ typedef enum
// free: to and including 1<<15
} mobjeflag_t;
//
// Mobj drawing flags
// Set by hex, to make masking shenanigans easier to keep track of.
//
typedef enum
{
// Don't generate a vissprite for individual screens
MFD_DONTDRAWP1 = 0x0001,
MFD_DONTDRAWP2 = 0x0002,
MFD_DONTDRAWP3 = 0x0004,
MFD_DONTDRAWP4 = 0x0008,
// Transparency override flags
MFD_TRANS10 = 0x0010,
MFD_TRANS20 = 0x0020,
MFD_TRANS30 = 0x0030,
MFD_TRANS40 = 0x0040,
MFD_TRANS50 = 0x0050,
MFD_TRANS60 = 0x0060,
MFD_TRANS70 = 0x0070,
MFD_TRANS80 = 0x0080,
MFD_TRANS90 = 0x0090,
MFD_TRANSADD = 0x00A0,
MFD_TRANSSUB = 0x00B0,
MFD_TRANSMASK = 0x00F0,
// Brightness override flags
MFD_FULLBRIGHT = 0x0100,
MFD_SEMIBRIGHT = 0x0200,
MFD_NOBRIGHT = 0x0300,
MFD_BRIGHTMASK = 0x0F00,
// Shortcuts
MFD_DONTDRAW = MFD_DONTDRAWP1|MFD_DONTDRAWP2|MFD_DONTDRAWP3|MFD_DONTDRAWP4,
MFD_SHADOW = MFD_TRANS80|MFD_FULLBRIGHT,
MFD_TRANSSHIFT = 4,
// free: to and including 0x8000
} mobjdflag_t;
//
// PRECIPITATION flags ?! ?! ?!
//
@ -323,7 +287,6 @@ typedef struct mobj_s
UINT16 anim_duration; // for FF_ANIMATE states
UINT32 renderflags; // render flags
INT32 blendmode; // blend mode
fixed_t spritexscale, spriteyscale;
fixed_t spritexoffset, spriteyoffset;
struct pslope_s *floorspriteslope; // The slope that the floorsprite is rotated by
@ -353,7 +316,6 @@ typedef struct mobj_s
UINT32 flags; // flags from mobjinfo tables
UINT32 flags2; // MF2_ flags
UINT16 eflags; // extra flags
UINT16 drawflags; // Rendering-related flags. These should not be used for game logic.
void *skin; // overrides 'sprite' when non-NULL (for player bodies to 'remember' the skin)
// Player and mobj sprites in multiplayer modes are modified
@ -462,7 +424,6 @@ typedef struct precipmobj_s
UINT16 anim_duration; // for FF_ANIMATE states
UINT32 renderflags; // render flags
INT32 blendmode; // blend mode
fixed_t spritexscale, spriteyscale;
fixed_t spritexoffset, spriteyoffset;
struct pslope_s *floorspriteslope; // The slope that the floorsprite is rotated by

2
src/p_polyobj.c
View file

@ -212,7 +212,7 @@ static void Polyobj_GetInfo(polyobj_t *po, line_t *line)
if (po->parent == po->id) // do not allow a self-reference
po->parent = -1;
po->translucency = max(min(line->args[2], NUMEFFECTMAPS), 0);
po->translucency = max(min(line->args[2], NUMTRANSMAPS), 0);
po->flags = POF_SOLID|POF_TESTHEIGHT|POF_RENDERSIDES|POF_RENDERPLANES;

45
src/p_pspr.h
View file

@ -41,9 +41,20 @@
/// \brief Frame flags - SPR2: Super sprite2
#define FF_SPR2SUPER 0x80
/// \brief Frame flags - SPR2: A change of state at the end of Sprite2 animation
#define FF_SPR2ENDSTATE 0x1000
#define FF_SPR2ENDSTATE 0x100
/// \brief Frame flags - SPR2: 50% of starting in middle of Sprite2 animation
#define FF_SPR2MIDSTART 0x2000
#define FF_SPR2MIDSTART 0x200
/// \brief Frame flags: blend types
#define FF_BLENDMASK 0x7000
/// \brief shift for FF_BLENDMASK
#define FF_BLENDSHIFT 12
/// \brief preshifted blend flags minus 1 as effects don't distinguish between AST_COPY and AST_TRANSLUCENT
#define FF_ADD ((AST_ADD-1)<<FF_BLENDSHIFT)
#define FF_SUBTRACT ((AST_SUBTRACT-1)<<FF_BLENDSHIFT)
#define FF_REVERSESUBTRACT ((AST_REVERSESUBTRACT-1)<<FF_BLENDSHIFT)
#define FF_MODULATE ((AST_MODULATE-1)<<FF_BLENDSHIFT)
#define FF_OVERLAY ((AST_OVERLAY-1)<<FF_BLENDSHIFT)
/// \brief Frame flags: 0 = no trans(opaque), 1-15 = transl. table
#define FF_TRANSMASK 0xf0000
@ -59,27 +70,32 @@
#define FF_TRANS70 (tr_trans70<<FF_TRANSSHIFT)
#define FF_TRANS80 (tr_trans80<<FF_TRANSSHIFT)
#define FF_TRANS90 (tr_trans90<<FF_TRANSSHIFT)
#define FF_TRANSADD (tr_transadd<<FF_TRANSSHIFT)
#define FF_TRANSSUB (tr_transsub<<FF_TRANSSHIFT)
/// \brief Frame flags: frame always appears full bright (mutually exclusive with below, currently takes priority)
#define FF_FULLBRIGHT 0x00100000
/// \brief Frame flags: frame appears with moderate brightness (mutually exclusive with above)
#define FF_SEMIBRIGHT 0x00200000
/// \brief Frame flags: brightness mask
#define FF_BRIGHTMASK 0x00300000
/// \brief Frame flags: frame always appears full bright
#define FF_FULLBRIGHT 0x00100000
/// \brief Frame flags: frame always appears full darkness
#define FF_FULLDARK 0x00200000
/// \brief Frame flags: frame appears between sector bright and full bright
#define FF_SEMIBRIGHT (FF_FULLBRIGHT|FF_FULLDARK)
/// \brief Frame flags: Thin, paper-like sprite (for collision equivalent, see MF_PAPERCOLLISION)
#define FF_PAPERSPRITE 0x00400000
/// \brief Frame flags: Splat!
#define FF_FLOORSPRITE 0x00800000
/// \brief Frame flags: Flip sprite vertically (relative to what it should be for its gravity)
#define FF_VERTICALFLIP 0x00800000
#define FF_VERTICALFLIP 0x01000000
/// \brief Frame flags: Flip sprite horizontally
#define FF_HORIZONTALFLIP 0x01000000
#define FF_HORIZONTALFLIP 0x02000000
/// \brief Frame flags - Animate: Simple stateless animation
#define FF_ANIMATE 0x02000000
#define FF_ANIMATE 0x10000000
/// \brief Frame flags - Animate: Sync animation to global timer (mutually exclusive with below, currently takes priority)
#define FF_GLOBALANIM 0x04000000
#define FF_GLOBALANIM 0x20000000
/// \brief Frame flags - Animate: Start at a random place in the animation (mutually exclusive with above)
#define FF_RANDOMANIM 0x08000000
#define FF_RANDOMANIM 0x40000000
/** \brief translucency tables
@ -102,9 +118,6 @@ typedef enum
tr_trans80,
tr_trans90,
NUMTRANSMAPS,
tr_transadd = NUMTRANSMAPS,
tr_transsub,
NUMEFFECTMAPS,
} transnum_t;
#endif

41
src/p_saveg.c
View file

@ -1444,13 +1444,13 @@ typedef enum
MD2_ROLLANGLE = 1<<14,
MD2_SHADOWSCALE = 1<<15,
MD2_RENDERFLAGS = 1<<16,
MD2_BLENDMODE = 1<<17,
// 1<<17 was taken out, maybe reuse later
MD2_SPRITEXSCALE = 1<<18,
MD2_SPRITEYSCALE = 1<<19,
MD2_SPRITEXOFFSET = 1<<20,
MD2_SPRITEYOFFSET = 1<<21,
MD2_FLOORSPRITESLOPE = 1<<22,
MD2_DRAWFLAGS = 1<<23,
// 1<<23 was taken out, maybe reuse later
MD2_HITLAG = 1<<24,
MD2_WAYPOINTCAP = 1<<25,
MD2_KITEMCAP = 1<<26,
@ -1669,8 +1669,6 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
diff2 |= MD2_SHADOWSCALE;
if (mobj->renderflags)
diff2 |= MD2_RENDERFLAGS;
if (mobj->blendmode != AST_TRANSLUCENT)
diff2 |= MD2_BLENDMODE;
if (mobj->spritexscale != FRACUNIT)
diff2 |= MD2_SPRITEXSCALE;
if (mobj->spriteyscale != FRACUNIT)
@ -1689,8 +1687,6 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
|| (slope->normal.z != FRACUNIT))
diff2 |= MD2_FLOORSPRITESLOPE;
}
if (mobj->drawflags)
diff2 |= MD2_DRAWFLAGS;
if (mobj->hitlag)
diff2 |= MD2_HITLAG;
if (mobj == waypointcap)
@ -1849,8 +1845,20 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
}
if (diff2 & MD2_RENDERFLAGS)
WRITEUINT32(save_p, mobj->renderflags);
if (diff2 & MD2_BLENDMODE)
WRITEINT32(save_p, mobj->blendmode);
if (diff2 & MD2_RENDERFLAGS)
{
UINT32 rf = mobj->renderflags;
UINT32 q = rf & RF_DONTDRAW;
if (q != RF_DONTDRAW // visible for more than one local player
&& q != (RF_DONTDRAWP1|RF_DONTDRAWP2|RF_DONTDRAWP3)
&& q != (RF_DONTDRAWP4|RF_DONTDRAWP1|RF_DONTDRAWP2)
&& q != (RF_DONTDRAWP4|RF_DONTDRAWP1|RF_DONTDRAWP3)
&& q != (RF_DONTDRAWP4|RF_DONTDRAWP2|RF_DONTDRAWP3))
rf &= ~q;
WRITEUINT32(save_p, rf);
}
if (diff2 & MD2_SPRITEXSCALE)
WRITEFIXED(save_p, mobj->spritexscale);
if (diff2 & MD2_SPRITEYSCALE)
@ -1878,17 +1886,6 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
WRITEFIXED(save_p, slope->normal.y);
WRITEFIXED(save_p, slope->normal.z);
}
if (diff2 & MD2_DRAWFLAGS)
{
UINT16 df = mobj->drawflags;
if ((mobj->drawflags & MFD_DONTDRAW) != MFD_DONTDRAW)
{
df = (mobj->drawflags & ~MFD_DONTDRAW);
}
WRITEUINT16(save_p, df);
}
if (diff2 & MD2_HITLAG)
WRITEINT32(save_p, mobj->hitlag);
@ -2950,10 +2947,6 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
}
if (diff2 & MD2_RENDERFLAGS)
mobj->renderflags = READUINT32(save_p);
if (diff2 & MD2_BLENDMODE)
mobj->blendmode = READINT32(save_p);
else
mobj->blendmode = AST_TRANSLUCENT;
if (diff2 & MD2_SPRITEXSCALE)
mobj->spritexscale = READFIXED(save_p);
else
@ -2985,8 +2978,6 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
slope->normal.y = READFIXED(save_p);
slope->normal.z = READFIXED(save_p);
}
if (diff2 & MD2_DRAWFLAGS)
mobj->drawflags = READUINT16(save_p);
if (diff2 & MD2_HITLAG)
mobj->hitlag = READINT32(save_p);

7
src/p_setup.c
View file

@ -1337,8 +1337,11 @@ static void P_LoadSidedefs(UINT8 *data)
if (msd->toptexture[0] == '#')
{
char *col = msd->toptexture;
sd->toptexture = sd->bottomtexture =
((col[1]-'0')*100 + (col[2]-'0')*10 + col[3]-'0') + 1;
sd->toptexture =
((col[1]-'0')*100 + (col[2]-'0')*10 + col[3]-'0')+1;
if (col[4]) // extra num for blendmode
sd->toptexture += (col[4]-'0')*1000;
sd->bottomtexture = sd->toptexture;
sd->midtexture = R_TextureNumForName(msd->midtexture);
}
else

23
src/p_spec.c
View file

@ -1127,7 +1127,7 @@ static void PolyTranslucency(line_t *line)
else
po->translucency = value;
po->translucency = max(min(po->translucency, NUMEFFECTMAPS), 0);
po->translucency = max(min(po->translucency, NUMTRANSMAPS), 0);
}
// Makes a polyobject translucency fade and applies tangibility
@ -5380,7 +5380,26 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
if (flags & FF_TRANSLUCENT)
{
if (sides[master->sidenum[0]].toptexture > 0)
fflr->alpha = sides[master->sidenum[0]].toptexture; // for future reference, "#0" is 1, and "#255" is 256. Be warned
{
// for future reference, "#0" is 1, and "#255" is 256. Be warned
fflr->alpha = sides[master->sidenum[0]].toptexture;
if (fflr->alpha == 901) // additive special
{
fflr->blend = AST_ADD;
fflr->alpha = 0xff;
}
else if (fflr->alpha == 902) // subtractive special
{
fflr->blend = AST_SUBTRACT;
fflr->alpha = 0xff;
}
else if (fflr->alpha >= 1001) // fourth digit
{
fflr->blend = (fflr->alpha/1000)+1; // becomes an AST
fflr->alpha %= 1000;
}
}
else
fflr->alpha = 0x80;
}

28
src/p_user.c
View file

@ -351,7 +351,7 @@ void P_GiveEmerald(boolean spawnObj)
if (i == pnum)
continue;
emmo->flags2 |= MFD_DONTDRAW;
emmo->flags2 |= RF_DONTDRAW;
}
}
}
@ -1213,7 +1213,7 @@ void P_SpawnShieldOrb(player_t *player)
if (shieldobj->info->painstate)
P_SetMobjState(shieldobj,shieldobj->info->painstate);
else
shieldobj->drawflags |= MFD_SHADOW;
shieldobj->renderflags |= RF_GHOSTLY;
}
}
}
@ -1296,7 +1296,7 @@ mobj_t *P_SpawnGhostMobj(mobj_t *mobj)
ghost->sprite2 = mobj->sprite2;
ghost->frame = mobj->frame;
ghost->tics = -1;
ghost->drawflags |= tr_trans50 << MFD_TRANSSHIFT;
ghost->renderflags |= tr_trans50 << RF_TRANSSHIFT;
ghost->fuse = ghost->info->damage;
ghost->skin = mobj->skin;
ghost->standingslope = mobj->standingslope;
@ -2645,7 +2645,7 @@ static void P_DeathThink(player_t *player)
if (player->mo)
{
player->mo->flags |= (MF_NOGRAVITY|MF_NOCLIP);
player->mo->drawflags |= MFD_DONTDRAW;
player->mo->renderflags |= RF_DONTDRAW;
}
}
else
@ -2975,7 +2975,7 @@ void P_DemoCameraMovement(camera_t *cam)
awayviewmobj_hack = P_SpawnMobj(cam->x, cam->y, cam->z, MT_THOK);
awayviewmobj_hack->tics = 2;
awayviewmobj_hack->drawflags |= MFD_DONTDRAW;
awayviewmobj_hack->renderflags |= RF_DONTDRAW;
democam.soundmobj = awayviewmobj_hack;
@ -4139,11 +4139,11 @@ static void P_HandleFollower(player_t *player)
K_GenericExtraFlagsNoZAdjust(player->follower, player->mo); // Not K_MatchGenericExtraFlag because the Z adjust it has only works properly if master & mo have the same Z height.
// Match how the player is being drawn
player->follower->drawflags = player->mo->drawflags;
player->follower->renderflags = player->mo->renderflags;
// Make the follower invisible if we no contest'd rather than removing it. No one will notice the diff seriously.
if (player->pflags & PF_GAMETYPEOVER)
player->follower->drawflags |= MFD_DONTDRAW;
player->follower->renderflags |= RF_DONTDRAW;
if (player->speed && (player->follower->momx || player->follower->momy))
player->follower->angle = K_MomentumAngle(player->follower);
@ -4164,7 +4164,7 @@ static void P_HandleFollower(player_t *player)
P_SetScale(bmobj, FixedMul(bubble, player->mo->scale));
K_GenericExtraFlagsNoZAdjust(bmobj, player->follower);
bmobj->drawflags = player->mo->drawflags;
bmobj->renderflags = player->mo->renderflags;
if (player->follower->threshold) // threshold means the follower was "despawned" with S_NULL (is actually just set to S_INVISIBLE)
P_SetMobjState(bmobj, S_INVISIBLE); // sooooo... let's do the same!
@ -4416,9 +4416,9 @@ void P_PlayerThink(player_t *player)
if (player->playerstate == PST_DEAD)
{
if (player->spectator)
player->mo->drawflags |= MFD_SHADOW;
player->mo->renderflags |= RF_GHOSTLY;
else
player->mo->drawflags &= ~(MFD_TRANSMASK|MFD_BRIGHTMASK);
player->mo->renderflags &= ~RF_GHOSTLYMASK;
P_DeathThink(player);
LUAh_PlayerThink(player);
return;
@ -4547,7 +4547,7 @@ void P_PlayerThink(player_t *player)
{
if (player == &players[displayplayers[i]] && !camera[i].chase)
{
gmobj->drawflags |= MFD_DONTDRAW;
gmobj->renderflags |= RF_DONTDRAW;
break;
}
}
@ -4596,9 +4596,9 @@ void P_PlayerThink(player_t *player)
{
if (player->powers[pw_flashing] > 0 && player->powers[pw_flashing] < K_GetKartFlashing(player)
&& (leveltime & 1))
player->mo->drawflags |= MFD_DONTDRAW;
player->mo->renderflags |= RF_DONTDRAW;
else
player->mo->drawflags &= ~MFD_DONTDRAW;
player->mo->renderflags &= ~RF_DONTDRAW;
}
if (cmd->flags & TICCMD_TYPING)
@ -4738,7 +4738,7 @@ void P_PlayerAfterThink(player_t *player)
// spectator invisibility and nogravity.
if ((netgame || multiplayer) && player->spectator)
{
player->mo->drawflags |= MFD_DONTDRAW;
player->mo->renderflags |= RF_DONTDRAW;
player->mo->flags |= MF_NOGRAVITY;
}

2
src/r_data.c
View file

@ -98,7 +98,7 @@ UINT32 ASTBlendPixel(RGBA_t background, RGBA_t foreground, int style, UINT8 alph
#define clamp(c) max(min(c, 0xFF), 0x00);
else
{
float falpha = ((float)alpha / 256.0f);
float falpha = ((float)alpha / 255.0f);
float fr = ((float)foreground.s.red * falpha);
float fg = ((float)foreground.s.green * falpha);
float fb = ((float)foreground.s.blue * falpha);

3
src/r_data.h
View file

@ -30,9 +30,6 @@ typedef struct
size_t numlumps;
} lumplist_t;
// Possible alpha types for a patch.
enum patchalphastyle {AST_COPY, AST_TRANSLUCENT, AST_ADD, AST_SUBTRACT, AST_REVERSESUBTRACT, AST_MODULATE, AST_OVERLAY};
UINT32 ASTBlendPixel(RGBA_t background, RGBA_t foreground, int style, UINT8 alpha);
UINT32 ASTBlendTexturePixel(RGBA_t background, RGBA_t foreground, int style, UINT8 alpha);
UINT8 ASTBlendPaletteIndexes(UINT8 background, UINT8 foreground, int style, UINT8 alpha);

51
src/r_defs.h
View file

@ -154,9 +154,6 @@ typedef enum
FF_GOOWATER = FF_SHATTERBOTTOM, ///< Used with ::FF_SWIMMABLE. Makes thick bouncey goop.
} ffloortype_e;
#define FFLOOR_ALPHA_SPECIAL_ADDITIVE (901)
#define FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE (902)
typedef struct ffloor_s
{
fixed_t *topheight;
@ -187,6 +184,7 @@ typedef struct ffloor_s
INT32 lastlight;
INT32 alpha;
UINT8 blend;
tic_t norender; // for culling
// these are saved for netgames, so do not let Lua touch these!
@ -729,6 +727,9 @@ typedef struct
#pragma pack()
#endif
// Possible alpha types for a patch.
typedef enum {AST_COPY, AST_TRANSLUCENT, AST_ADD, AST_SUBTRACT, AST_REVERSESUBTRACT, AST_MODULATE, AST_OVERLAY} patchalphastyle_t;
typedef enum
{
RF_HORIZONTALFLIP = 0x00000001, // Flip sprite horizontally
@ -742,19 +743,49 @@ typedef enum
RF_NOSPLATBILLBOARD = 0x00000040, // Don't billboard floor sprites (faces forward from the view angle)
RF_NOSPLATROLLANGLE = 0x00000080, // Don't rotate floor sprites by the object's rollangle (uses rotated patches instead)
RF_BLENDMASK = 0x00000F00, // --Blending modes
RF_BRIGHTMASK = 0x00000300, // --Bright modes
RF_FULLBRIGHT = 0x00000100, // Sprite is drawn at full brightness
RF_SEMIBRIGHT = 0x00000200, // Sprite is drawn between sector brightness & full brightness
RF_FULLDARK = 0x00000400, // Sprite is drawn completely dark
RF_NOCOLORMAPS = 0x00000800, // Sprite is not drawn with colormaps
RF_FULLDARK = 0x00000200, // Sprite is drawn completely dark
RF_SEMIBRIGHT = (RF_FULLBRIGHT | RF_FULLDARK), // between sector bright and full bright
RF_SPRITETYPEMASK = 0x00007000, // ---Different sprite types
RF_NOCOLORMAPS = 0x00000400, // Sprite is not drawn with colormaps
RF_SPRITETYPEMASK = 0x00003000, // --Different sprite types
RF_PAPERSPRITE = 0x00001000, // Paper sprite
RF_FLOORSPRITE = 0x00002000, // Floor sprite
RF_SHADOWDRAW = 0x00010000, // Stretches and skews the sprite like a shadow.
RF_SHADOWEFFECTS = 0x00020000, // Scales and becomes transparent like a shadow.
RF_SHADOWDRAW = 0x00004000, // Stretches and skews the sprite like a shadow.
RF_SHADOWEFFECTS = 0x00008000, // Scales and becomes transparent like a shadow.
RF_DROPSHADOW = (RF_SHADOWDRAW | RF_SHADOWEFFECTS | RF_FULLDARK),
RF_DONTDRAW = 0x00F00000, // --Don't generate a vissprite
RF_DONTDRAWP1 = 0x00100000, // No P1
RF_DONTDRAWP2 = 0x00200000, // No P2
RF_DONTDRAWP3 = 0x00400000, // No P3
RF_DONTDRAWP4 = 0x00800000, // No P4
RF_BLENDMASK = 0x07000000, // --Blending override - see patchalphastyle_t
RF_BLENDSHIFT = (6*4),
// minus 1 as effects don't distinguish between AST_COPY and AST_TRANSLUCENT
RF_ADD = ((AST_ADD-1)<<RF_BLENDSHIFT),
RF_SUBTRACT = ((AST_SUBTRACT-1)<<RF_BLENDSHIFT),
RF_REVERSESUBTRACT = ((AST_REVERSESUBTRACT-1)<<RF_BLENDSHIFT),
RF_MODULATE = ((AST_MODULATE-1)<<RF_BLENDSHIFT),
RF_OVERLAY = ((AST_OVERLAY-1)<<RF_BLENDSHIFT),
RF_TRANSMASK = 0xF0000000, // --Transparency override
RF_TRANSSHIFT = (7*4),
RF_TRANS10 = (1<<RF_TRANSSHIFT), // 10%
RF_TRANS20 = (2<<RF_TRANSSHIFT), // 20%
RF_TRANS30 = (3<<RF_TRANSSHIFT), // 30%
RF_TRANS40 = (4<<RF_TRANSSHIFT), // 40%
RF_TRANS50 = (5<<RF_TRANSSHIFT), // 50%
RF_TRANS60 = (6<<RF_TRANSSHIFT), // 60%
RF_TRANS70 = (7<<RF_TRANSSHIFT), // 70%
RF_TRANS80 = (8<<RF_TRANSSHIFT), // 80%
RF_TRANS90 = (9<<RF_TRANSSHIFT), // 90%
RF_GHOSTLY = (RF_TRANS80 | RF_FULLBRIGHT),
RF_GHOSTLYMASK = (RF_TRANSMASK | RF_FULLBRIGHT),
} renderflags_t;
typedef enum

33
src/r_draw.c
View file

@ -152,7 +152,7 @@ UINT8 skincolor_modified[MAXSKINCOLORS];
CV_PossibleValue_t Color_cons_t[MAXSKINCOLORS+1];
CV_PossibleValue_t Followercolor_cons_t[MAXSKINCOLORS+3]; // +3 to account for "Match", "Opposite" & NULL
#define TRANSTAB_AMTMUL10 (256.0f / 10.0f)
#define TRANSTAB_AMTMUL10 (255.0f / 10.0f)
/** \brief Initializes the translucency tables used by the Software renderer.
*/
@ -174,9 +174,6 @@ void R_InitTranslucencyTables(void)
W_ReadLump(W_GetNumForName("TRANS80"), transtables+0x70000);
W_ReadLump(W_GetNumForName("TRANS90"), transtables+0x80000);
W_ReadLump(W_GetNumForName("TRANSADD"),transtables+0x90000);
W_ReadLump(W_GetNumForName("TRANSSUB"),transtables+0xA0000);
R_GenerateBlendTables();
}
@ -194,7 +191,7 @@ void R_GenerateBlendTables(void)
for (i = 0; i <= 9; i++)
{
const size_t offs = (0x10000 * i);
const UINT8 alpha = TRANSTAB_AMTMUL10 * i;
const UINT8 alpha = (TRANSTAB_AMTMUL10 * ((float)(10-i)));
R_GenerateTranslucencyTable(blendtables[blendtab_add] + offs, AST_ADD, alpha);
R_GenerateTranslucencyTable(blendtables[blendtab_subtract] + offs, AST_SUBTRACT, alpha);
@ -206,27 +203,28 @@ void R_GenerateBlendTables(void)
R_GenerateTranslucencyTable(blendtables[blendtab_modulate], AST_MODULATE, 0);
}
static colorlookup_t transtab_lut;
void R_GenerateTranslucencyTable(UINT8 *table, int style, UINT8 blendamt)
{
INT16 bg, fg;
RGBA_t backrgba, frontrgba, result;
if (table == NULL)
I_Error("R_GenerateTranslucencyTable: input table was NULL!");
InitColorLUT(&transtab_lut, pMasterPalette, false);
for (bg = 0; bg < 0xFF; bg++)
for (bg = 0; bg <= 0xFF; bg++)
{
for (fg = 0; fg < 0xFF; fg++)
backrgba = pGammaCorrectedPalette[bg];
for (fg = 0; fg <= 0xFF; fg++)
{
RGBA_t backrgba = V_GetMasterColor(bg);
RGBA_t frontrgba = V_GetMasterColor(fg);
RGBA_t result;
frontrgba = pGammaCorrectedPalette[fg];
#if 0 // perfect implementation
result.rgba = V_GammaEncode(ASTBlendPixel(backrgba, frontrgba, style, blendamt));
table[((fg * 0x100) + bg)] = NearestPaletteColor(result.s.red, result.s.green, result.s.blue, pMasterPalette);
#else // performance scrabbler
result.rgba = ASTBlendPixel(backrgba, frontrgba, style, blendamt);
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut, result.s.red, result.s.green, result.s.blue);
table[((fg * 0x100) + bg)] = NearestPaletteColor(result.s.red, result.s.green, result.s.blue, pGammaCorrectedPalette);
#endif
}
}
}
@ -259,10 +257,9 @@ UINT8 *R_GetBlendTable(int style, INT32 alphalevel)
}
// Return a normal translucency table
if (--alphalevel >= 0)
return transtables + (ClipTransLevel(alphalevel) << FF_TRANSSHIFT);
else
if (--alphalevel < 0)
return NULL;
return transtables + (ClipTransLevel(alphalevel) << FF_TRANSSHIFT);
}
/** \brief Retrieves a translation colormap from the cache.

36
src/r_plane.c
View file

@ -820,7 +820,7 @@ void R_DrawSinglePlane(visplane_t *pl)
if (pl->polyobj)
{
// Hacked up support for alpha value in software mode Tails 09-24-2002 (sidenote: ported to polys 10-15-2014, there was no time travel involved -Red)
if (pl->polyobj->translucency >= NUMEFFECTMAPS)
if (pl->polyobj->translucency >= NUMTRANSMAPS)
return; // Don't even draw it
else if (pl->polyobj->translucency > 0)
{
@ -861,32 +861,14 @@ void R_DrawSinglePlane(visplane_t *pl)
spanfunctype = (pl->ffloor->master->flags & ML_EFFECT6) ? SPANDRAWFUNC_TRANSSPLAT : SPANDRAWFUNC_TRANS;
// Hacked up support for alpha value in software mode Tails 09-24-2002
if (pl->ffloor->alpha < 12)
return; // Don't even draw it
else if (pl->ffloor->alpha < 38)
ds_transmap = R_GetTranslucencyTable(tr_trans90);
else if (pl->ffloor->alpha < 64)
ds_transmap = R_GetTranslucencyTable(tr_trans80);
else if (pl->ffloor->alpha < 89)
ds_transmap = R_GetTranslucencyTable(tr_trans70);
else if (pl->ffloor->alpha < 115)
ds_transmap = R_GetTranslucencyTable(tr_trans60);
else if (pl->ffloor->alpha < 140)
ds_transmap = R_GetTranslucencyTable(tr_trans50);
else if (pl->ffloor->alpha < 166)
ds_transmap = R_GetTranslucencyTable(tr_trans40);
else if (pl->ffloor->alpha < 192)
ds_transmap = R_GetTranslucencyTable(tr_trans30);
else if (pl->ffloor->alpha < 217)
ds_transmap = R_GetTranslucencyTable(tr_trans20);
else if (pl->ffloor->alpha < 243)
ds_transmap = R_GetTranslucencyTable(tr_trans10);
else if (pl->ffloor->alpha == FFLOOR_ALPHA_SPECIAL_ADDITIVE)
ds_transmap = transtables + ((tr_transadd-1)<<FF_TRANSSHIFT);
else if (pl->ffloor->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)
ds_transmap = transtables + ((tr_transsub-1)<<FF_TRANSSHIFT);
else // Opaque, but allow transparent flat pixels
spanfunctype = SPANDRAWFUNC_SPLAT;
// ...unhacked by toaster 04-01-2021
{
INT32 trans = (10*((256+12) - pl->ffloor->alpha))/255;
if (trans >= 10)
return; // Don't even draw it
if (!(ds_transmap = R_GetBlendTable(pl->ffloor->blend, trans)))
spanfunctype = SPANDRAWFUNC_SPLAT; // Opaque, but allow transparent flat pixels
}
if ((spanfunctype == SPANDRAWFUNC_SPLAT) || (pl->extra_colormap && (pl->extra_colormap->flags & CMF_FOG)))
light = (pl->lightlevel >> LIGHTSEGSHIFT);

80
src/r_segs.c
View file

@ -122,20 +122,10 @@ static void R_Render2sidedMultiPatchColumn(column_t *column)
transnum_t R_GetLinedefTransTable(line_t *ldef)
{
transnum_t transnum = NUMEFFECTMAPS; // Send back NUMEFFECTMAPS for none
transnum_t transnum = NUMTRANSMAPS; // Send back NUMTRANSMAPS for none
fixed_t alpha = ldef->alpha;
if (alpha > 0 && alpha < FRACUNIT)
transnum = (20*(FRACUNIT - alpha - 1) + FRACUNIT) >> (FRACBITS+1);
else
{
switch (ldef->special)
{
case 910: transnum = tr_transadd; break;
case 911: transnum = tr_transsub; break;
default: transnum = NUMEFFECTMAPS; break;
}
}
return transnum;
}
@ -153,7 +143,8 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
INT32 times, repeats;
INT64 overflow_test;
INT32 range;
transnum_t transtable = NUMEFFECTMAPS;
transnum_t transtable = NUMTRANSMAPS;
patchalphastyle_t blendmode = 0;
// Calculate light table.
// Use different light tables
@ -171,12 +162,33 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
return;
transtable = R_GetLinedefTransTable(ldef);
if (transtable != NUMEFFECTMAPS)
if (ldef->special == 910)
{
dc_transmap = transtables + ((transtable - 1) << FF_TRANSSHIFT);
//dc_transmap = R_GetTranslucencyTable(R_GetLinedefTransTable(ldef->alpha));
if (transtable == NUMTRANSMAPS)
transtable = 0;
blendmode = AST_ADD;
}
else if (ldef->special == 911)
{
if (transtable == NUMTRANSMAPS)
transtable = 0;
blendmode = AST_SUBTRACT;
}
else if (ldef->special == 912)
{
if (transtable == NUMTRANSMAPS)
transtable = 0;
blendmode = AST_REVERSESUBTRACT;
}
else if (ldef->special == 913)
{
transtable = 0;
blendmode = AST_MODULATE;
}
if (transtable != NUMTRANSMAPS)
{
dc_transmap = R_GetBlendTable(blendmode, transtable);
colfunc = colfuncs[COLDRAWFUNC_FUZZY];
}
else if (ldef->special == 909)
{
@ -189,7 +201,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
if (curline->polyseg && curline->polyseg->translucency > 0)
{
if (curline->polyseg->translucency >= NUMEFFECTMAPS)
if (curline->polyseg->translucency >= NUMTRANSMAPS)
return;
dc_transmap = R_GetTranslucencyTable(curline->polyseg->translucency);
@ -619,32 +631,14 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
boolean fuzzy = true;
// Hacked up support for alpha value in software mode Tails 09-24-2002
if (pfloor->alpha < 12)
return; // Don't even draw it
else if (pfloor->alpha < 38)
dc_transmap = R_GetTranslucencyTable(tr_trans90);
else if (pfloor->alpha < 64)
dc_transmap = R_GetTranslucencyTable(tr_trans80);
else if (pfloor->alpha < 89)
dc_transmap = R_GetTranslucencyTable(tr_trans70);
else if (pfloor->alpha < 115)
dc_transmap = R_GetTranslucencyTable(tr_trans60);
else if (pfloor->alpha < 140)
dc_transmap = R_GetTranslucencyTable(tr_trans50);
else if (pfloor->alpha < 166)
dc_transmap = R_GetTranslucencyTable(tr_trans40);
else if (pfloor->alpha < 192)
dc_transmap = R_GetTranslucencyTable(tr_trans30);
else if (pfloor->alpha < 217)
dc_transmap = R_GetTranslucencyTable(tr_trans20);
else if (pfloor->alpha < 243)
dc_transmap = R_GetTranslucencyTable(tr_trans10);
else if (pfloor->alpha == FFLOOR_ALPHA_SPECIAL_ADDITIVE)
dc_transmap = transtables + ((tr_transadd-1)<<FF_TRANSSHIFT);
else if (pfloor->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)
dc_transmap = transtables + ((tr_transsub-1)<<FF_TRANSSHIFT);
else
fuzzy = false; // Opaque
// ...unhacked by toaster 04-01-2021
{
INT32 trans = (10*((256+12) - pfloor->alpha))/255;
if (trans >= 10)
return; // Don't even draw it
if (!(dc_transmap = R_GetBlendTable(pfloor->blend, trans)))
fuzzy = false; // Opaque
}
if (fuzzy)
colfunc = colfuncs[COLDRAWFUNC_FUZZY];

2
src/r_textures.c
View file

@ -1077,7 +1077,7 @@ static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
INT16 patchYPos;
UINT8 flip = 0;
UINT8 alpha = 255;
enum patchalphastyle style = AST_COPY;
patchalphastyle_t style = AST_COPY;
texpatch_t *resultPatch = NULL;
lumpnum_t patchLumpNum;

2
src/r_textures.h
View file

@ -33,7 +33,7 @@ typedef struct
UINT16 wad, lump;
UINT8 flip; // 1 = flipx, 2 = flipy, 3 = both
UINT8 alpha; // Translucency value
enum patchalphastyle style;
patchalphastyle_t style;
} texpatch_t;
// texture type

65
src/r_things.c
View file

@ -1251,7 +1251,6 @@ static void R_ProjectDropShadow(mobj_t *thing, vissprite_t *vis, fixed_t scale,
patch_t *patch;
fixed_t xscale, yscale, shadowxscale, shadowyscale, shadowskew, x1, x2;
INT32 light = 0;
UINT8 trans = tr_transsub;
fixed_t groundz;
pslope_t *groundslope;
@ -1259,11 +1258,6 @@ static void R_ProjectDropShadow(mobj_t *thing, vissprite_t *vis, fixed_t scale,
if (abs(groundz-viewz)/tz > 4) return; // Prevent stretchy shadows and possible crashes
if (thing->whiteshadow == true)
{
trans = tr_transadd;
}
patch = W_CachePatchName("DSHADOW", PU_SPRITE);
xscale = FixedDiv(projection[viewssnum], tz);
yscale = FixedDiv(projectiony[viewssnum], tz);
@ -1351,7 +1345,7 @@ static void R_ProjectDropShadow(mobj_t *thing, vissprite_t *vis, fixed_t scale,
shadow->extra_colormap = thing->subsector->sector->extra_colormap;
}
shadow->transmap = transtables + ((trans-1) << FF_TRANSSHIFT);
shadow->transmap = R_GetBlendTable(thing->whiteshadow ? AST_ADD : AST_SUBTRACT, 0);
shadow->colormap = colormaps;
objectsdrawn++;
@ -1396,7 +1390,8 @@ static void R_ProjectSprite(mobj_t *thing)
boolean hflip = (!R_ThingHorizontallyFlipped(thing) != !mirrored);
INT32 lindex;
INT32 trans;
UINT32 blendmode;
UINT32 trans;
vissprite_t *vis;
patch_t *patch;
@ -1802,15 +1797,22 @@ static void R_ProjectSprite(mobj_t *thing)
return;
}
// Determine the translucency value.
if (oldthing->frame & FF_TRANSMASK)
// Determine the blendmode and translucency value
{
trans = (oldthing->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
if (oldthing->blendmode == AST_TRANSLUCENT && trans >= NUMTRANSMAPS)
return;
if (oldthing->renderflags & RF_BLENDMASK)
blendmode = (oldthing->renderflags & RF_BLENDMASK) >> RF_BLENDSHIFT;
else
blendmode = (oldthing->frame & FF_BLENDMASK) >> FF_BLENDSHIFT;
if (blendmode)
blendmode++; // realign to constants
if (oldthing->renderflags & RF_TRANSMASK)
trans = (oldthing->renderflags & RF_TRANSMASK) >> RF_TRANSSHIFT;
else
trans = (oldthing->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
if (trans >= NUMTRANSMAPS)
return; // cap
}
else
trans = 0;
// Check if this sprite needs to be rendered like a shadow
shadowdraw = (!!(thing->renderflags & RF_SHADOWDRAW) && !(papersprite || splat));
@ -1994,17 +1996,14 @@ static void R_ProjectSprite(mobj_t *thing)
vis->scale += FixedMul(scalestep, spriteyscale) * (vis->x1 - x1);
}
if (oldthing->blendmode != AST_COPY)
vis->transmap = R_GetBlendTable(oldthing->blendmode, trans);
else
vis->transmap = NULL;
vis->transmap = R_GetBlendTable(blendmode, trans);
if (R_ThingIsFullBright(oldthing))
if (R_ThingIsSemiBright(oldthing))
vis->cut |= SC_SEMIBRIGHT;
else if (R_ThingIsFullBright(oldthing))
vis->cut |= SC_FULLBRIGHT;
else if (R_ThingIsFullDark(oldthing))
vis->cut |= SC_FULLDARK;
else if (R_ThingIsSemiBright(oldthing))
vis->cut |= SC_SEMIBRIGHT;
//
// determine the colormap (lightlevel & special effects)
@ -2996,10 +2995,10 @@ boolean R_ThingVisible (mobj_t *thing)
if (r_viewmobj && (thing == r_viewmobj || (r_viewmobj->player && r_viewmobj->player->followmobj == thing)))
return false;
if ((viewssnum == 0 && (thing->drawflags & MFD_DONTDRAWP1))
|| (viewssnum == 1 && (thing->drawflags & MFD_DONTDRAWP2))
|| (viewssnum == 2 && (thing->drawflags & MFD_DONTDRAWP3))
|| (viewssnum == 3 && (thing->drawflags & MFD_DONTDRAWP4)))
if ((viewssnum == 0 && (thing->renderflags & RF_DONTDRAWP1))
|| (viewssnum == 1 && (thing->renderflags & RF_DONTDRAWP2))
|| (viewssnum == 2 && (thing->renderflags & RF_DONTDRAWP3))
|| (viewssnum == 3 && (thing->renderflags & RF_DONTDRAWP4)))
return false;
return true;
@ -3052,22 +3051,28 @@ boolean R_ThingIsPaperSprite(mobj_t *thing)
boolean R_ThingIsFloorSprite(mobj_t *thing)
{
return (thing->flags2 & MF2_SPLAT || thing->renderflags & RF_FLOORSPRITE);
return (thing->flags2 & MF2_SPLAT || thing->frame & FF_FLOORSPRITE || thing->renderflags & RF_FLOORSPRITE);
}
boolean R_ThingIsFullBright(mobj_t *thing)
{
return (thing->frame & FF_FULLBRIGHT || thing->renderflags & RF_FULLBRIGHT);
if (thing->renderflags & RF_BRIGHTMASK)
return ((thing->renderflags & RF_BRIGHTMASK) == RF_FULLBRIGHT);
return ((thing->frame & FF_BRIGHTMASK) == FF_FULLBRIGHT);
}
boolean R_ThingIsSemiBright(mobj_t *thing)
{
return (thing->frame & FF_SEMIBRIGHT || thing->renderflags & RF_SEMIBRIGHT);
if (thing->renderflags & RF_BRIGHTMASK)
return ((thing->renderflags & RF_BRIGHTMASK) == RF_SEMIBRIGHT);
return ((thing->frame & FF_BRIGHTMASK) == FF_SEMIBRIGHT);
}
boolean R_ThingIsFullDark(mobj_t *thing)
{
return (thing->renderflags & RF_FULLDARK);
if (thing->renderflags & RF_BRIGHTMASK)
return ((thing->renderflags & RF_BRIGHTMASK) == RF_FULLDARK);
return ((thing->frame & FF_BRIGHTMASK) == FF_FULLDARK);
}
//

189
src/v_video.c
View file

@ -88,6 +88,7 @@ consvar_t cv_constextsize = CVAR_INIT ("con_textsize", "Medium", CV_SAVE|CV_CALL
// local copy of the palette for V_GetColor()
RGBA_t *pLocalPalette = NULL;
RGBA_t *pMasterPalette = NULL;
RGBA_t *pGammaCorrectedPalette = NULL;
/*
The following was an extremely helpful resource when developing my Colour Cube LUT.
@ -285,33 +286,25 @@ static boolean InitCube(void)
return true;
}
#ifdef BACKWARDSCOMPATCORRECTION
/*
So it turns out that the way gamma was implemented previously, the default
colour profile of the game was messed up. Since this bad decision has been
around for a long time, and the intent is to keep the base game looking the
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};
#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)
@ -322,33 +315,37 @@ static void LoadPalette(const char *lumpname)
Cubeapply = InitCube();
Z_Free(pLocalPalette);
if (pLocalPalette != pMasterPalette)
Z_Free(pLocalPalette);
Z_Free(pMasterPalette);
Z_Free(pGammaCorrectedPalette);
pLocalPalette = Z_Malloc(sizeof (*pLocalPalette)*palsize, PU_STATIC, NULL);
pMasterPalette = Z_Malloc(sizeof (*pMasterPalette)*palsize, PU_STATIC, NULL);
if (Cubeapply)
pLocalPalette = Z_Malloc(sizeof (*pLocalPalette)*palsize, PU_STATIC, NULL);
else
pLocalPalette = pMasterPalette;
pGammaCorrectedPalette = Z_Malloc(sizeof (*pGammaCorrectedPalette)*palsize, PU_STATIC, NULL);
pal = W_CacheLumpNum(lumpnum, PU_CACHE);
for (i = 0; i < palsize; i++)
{
#ifdef BACKWARDSCOMPATCORRECTION
pMasterPalette[i].s.red = pLocalPalette[i].s.red = correctiontable[*pal++];
pMasterPalette[i].s.green = pLocalPalette[i].s.green = correctiontable[*pal++];
pMasterPalette[i].s.blue = pLocalPalette[i].s.blue = correctiontable[*pal++];
#else
pMasterPalette[i].s.red = pLocalPalette[i].s.red = *pal++;
pMasterPalette[i].s.green = pLocalPalette[i].s.green = *pal++;
pMasterPalette[i].s.blue = pLocalPalette[i].s.blue = *pal++;
#endif
pMasterPalette[i].s.alpha = pLocalPalette[i].s.alpha = 0xFF;
pMasterPalette[i].s.red = *pal++;
pMasterPalette[i].s.green = *pal++;
pMasterPalette[i].s.blue = *pal++;
pMasterPalette[i].s.alpha = 0xFF;
// lerp of colour cubing! if you want, make it smoother yourself
if (Cubeapply)
V_CubeApply(&pLocalPalette[i].s.red, &pLocalPalette[i].s.green, &pLocalPalette[i].s.blue);
pGammaCorrectedPalette[i].rgba = V_GammaDecode(pMasterPalette[i].rgba);
if (!Cubeapply)
continue;
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;
@ -357,7 +354,7 @@ void V_CubeApply(UINT8 *red, UINT8 *green, UINT8 *blue)
if (!Cubeapply)
return;
linear = (*red/255.0);
linear = ((*input).s.red/255.0);
#define dolerp(e1, e2) ((1 - linear)*e1 + linear*e2)
for (q = 0; q < 3; q++)
{
@ -366,13 +363,13 @@ 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.0);
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.0);
linear = ((*input).s.blue/255.0);
for (q = 0; q < 3; q++)
{
working[0][q] = 255*dolerp(working[0][q], working[1][q]);
@ -383,9 +380,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)
@ -519,7 +516,7 @@ static inline UINT8 transmappedpdraw(const UINT8 *dest, const UINT8 *source, fix
void V_DrawStretchyFixedPatch(fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 scrn, patch_t *patch, const UINT8 *colormap)
{
UINT8 (*patchdrawfunc)(const UINT8*, const UINT8*, fixed_t);
UINT32 alphalevel = 0;
UINT32 alphalevel, blendmode;
fixed_t col, ofs, colfrac, rowfrac, fdup, vdup;
INT32 dupx, dupy;
@ -543,28 +540,22 @@ void V_DrawStretchyFixedPatch(fixed_t x, fixed_t y, fixed_t pscale, fixed_t vsca
patchdrawfunc = standardpdraw;
v_translevel = NULL;
if ((blendmode = ((scrn & V_BLENDMASK) >> V_BLENDSHIFT)))
blendmode++; // realign to constants
if ((alphalevel = ((scrn & V_ALPHAMASK) >> V_ALPHASHIFT)))
{
if (alphalevel > 11) // not standard, V_ADDTRANS or V_SUBTRANS
{
if (alphalevel == 13) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 14) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 15) // V_HUDTRANSDOUBLE
alphalevel = hudplusalpha[st_translucency];
if (alphalevel == 10) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 11) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 12) // V_HUDTRANSDOUBLE
alphalevel = hudplusalpha[st_translucency];
if (alphalevel >= 10) // Still inelegible to render?
return;
}
if (alphalevel)
{
v_translevel = R_GetTranslucencyTable(alphalevel);
patchdrawfunc = translucentpdraw;
}
if (alphalevel >= 10) // Still inelegible to render?
return;
}
if ((v_translevel = R_GetBlendTable(blendmode, alphalevel)))
patchdrawfunc = translucentpdraw;
v_colormap = NULL;
if (colormap)
@ -617,12 +608,6 @@ void V_DrawStretchyFixedPatch(fixed_t x, fixed_t y, fixed_t pscale, fixed_t vsca
// TODO: make some kind of vertical version of V_FLIP, maybe by deprecating V_OFFSET in future?!?
offsety = FixedMul(patch->topoffset<<FRACBITS, vscale);
if ((scrn & (V_NOSCALESTART|V_OFFSET)) == (V_NOSCALESTART|V_OFFSET)) // Multiply by dupx/dupy for crosshairs
{
offsetx = FixedMul(offsetx, dupx<<FRACBITS);
offsety = FixedMul(offsety, dupy<<FRACBITS);
}
// Subtract the offsets from x/y positions
x -= offsetx;
y -= offsety;
@ -716,7 +701,7 @@ void V_DrawStretchyFixedPatch(fixed_t x, fixed_t y, fixed_t pscale, fixed_t vsca
void V_DrawCroppedPatch(fixed_t x, fixed_t y, fixed_t pscale, INT32 scrn, patch_t *patch, fixed_t sx, fixed_t sy, fixed_t w, fixed_t h)
{
UINT8 (*patchdrawfunc)(const UINT8*, const UINT8*, fixed_t);
UINT32 alphalevel = 0;
UINT32 alphalevel, blendmode;
// boolean flip = false;
fixed_t col, ofs, colfrac, rowfrac, fdup;
@ -739,28 +724,22 @@ void V_DrawCroppedPatch(fixed_t x, fixed_t y, fixed_t pscale, INT32 scrn, patch_
patchdrawfunc = standardpdraw;
v_translevel = NULL;
if ((blendmode = ((scrn & V_BLENDMASK) >> V_BLENDSHIFT)))
blendmode++; // realign to constants
if ((alphalevel = ((scrn & V_ALPHAMASK) >> V_ALPHASHIFT)))
{
if (alphalevel > 11) // not standard, V_ADDTRANS or V_SUBTRANS
{
if (alphalevel == 13) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 14) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 15) // V_HUDTRANSDOUBLE
alphalevel = hudplusalpha[st_translucency];
if (alphalevel == 10) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 11) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 12) // V_HUDTRANSDOUBLE
alphalevel = hudplusalpha[st_translucency];
if (alphalevel >= 10) // Still inelegible to render?
return;
}
if (alphalevel)
{
v_translevel = R_GetTranslucencyTable(alphalevel);
patchdrawfunc = translucentpdraw;
}
if (alphalevel >= 10) // Still inelegible to render?
return;
}
if ((v_translevel = R_GetBlendTable(blendmode, alphalevel)))
patchdrawfunc = translucentpdraw;
// only use one dup, to avoid stretching (har har)
dupx = dupy = (vid.dupx < vid.dupy ? vid.dupx : vid.dupy);
@ -998,18 +977,15 @@ void V_DrawFillConsoleMap(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
if ((alphalevel = ((c & V_ALPHAMASK) >> V_ALPHASHIFT)))
{
if (alphalevel > 11) // not standard, V_ADDTRANS or V_SUBTRANS
{
if (alphalevel == 13) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 14) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 15) // V_HUDTRANSDOUBLE
alphalevel = hudplusalpha[st_translucency];
if (alphalevel == 10) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 11) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 12) // V_HUDTRANSDOUBLE
alphalevel = hudplusalpha[st_translucency];
if (alphalevel >= 10) // Still inelegible to render?
return;
}
if (alphalevel >= 10) // Still inelegible to render?
return;
}
if (!(c & V_NOSCALESTART))
@ -1945,10 +1921,7 @@ void V_DrawStringScaled(
case HU_FONT:
case TINY_FONT:
case KART_FONT:
if (( flags & V_RETURN8 ))
lfh = 8;
else
lfh = 12;
lfh = 12;
break;
case LT_FONT:
case CRED_FONT:

34
src/v_video.h
View file

@ -66,8 +66,13 @@ const char *GetPalette(void);
extern RGBA_t *pLocalPalette;
extern RGBA_t *pMasterPalette;
extern RGBA_t *pGammaCorrectedPalette;
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])
@ -123,29 +128,32 @@ void V_CubeApply(UINT8 *red, UINT8 *green, UINT8 *blue);
#define V_70TRANS 0x00070000
#define V_80TRANS 0x00080000 // used to be V_8020TRANS
#define V_90TRANS 0x00090000
#define V_ADDTRANS 0x000A0000
#define V_SUBTRANS 0x000B0000
#define V_HUDTRANSHALF 0x000D0000
#define V_HUDTRANS 0x000E0000 // draw the hud translucent
#define V_HUDTRANSDOUBLE 0x000F0000
#define V_HUDTRANSHALF 0x000A0000
#define V_HUDTRANS 0x000B0000 // draw the hud translucent
#define V_HUDTRANSDOUBLE 0x000C0000
// Macros follow
#define V_USERHUDTRANSHALF ((10-(cv_translucenthud.value/2))<<V_ALPHASHIFT)
#define V_USERHUDTRANS ((10-cv_translucenthud.value)<<V_ALPHASHIFT)
#define V_USERHUDTRANSDOUBLE ((10-min(cv_translucenthud.value*2, 10))<<V_ALPHASHIFT)
#define V_RETURN8 0x00100000 // 8 pixel return instead of 12
#define V_OFFSET 0x00200000 // account for offsets in patches
#define V_ALLOWLOWERCASE 0x00400000 // (strings only) allow fonts that have lowercase letters to use them
#define V_FLIP 0x00400000 // (patches only) Horizontal flip
#define V_SLIDEIN 0x00800000 // Slide in from the sides on level load, depending on snap flags
// use bits 21-23 for blendmodes
#define V_BLENDSHIFT 20
#define V_BLENDMASK 0x00700000
// preshifted blend flags minus 1 as effects don't distinguish between AST_COPY and AST_TRANSLUCENT
#define V_ADD ((AST_ADD-1)<<V_BLENDSHIFT) // Additive
#define V_SUBTRACT ((AST_SUBTRACT-1)<<V_BLENDSHIFT) // Subtractive
#define V_REVERSESUBTRACT ((AST_REVERSESUBTRACT-1)<<V_BLENDSHIFT) // Reverse subtractive
#define V_MODULATE ((AST_MODULATE-1)<<V_BLENDSHIFT) // Modulate
#define V_OVERLAY ((AST_OVERLAY-1)<<V_BLENDSHIFT) // Overlay
#define V_SNAPTOTOP 0x01000000 // for centering
#define V_SNAPTOBOTTOM 0x02000000 // for centering
#define V_SNAPTOLEFT 0x04000000 // for centering
#define V_SNAPTORIGHT 0x08000000 // for centering
#define V_WRAPX 0x10000000 // Don't clamp texture on X (for HW mode)
#define V_WRAPY 0x20000000 // Don't clamp texture on Y (for HW mode)
#define V_ALLOWLOWERCASE 0x10000000 // (strings only) allow fonts that have lowercase letters to use them
#define V_FLIP 0x10000000 // (patches only) Horizontal flip
#define V_SLIDEIN 0x20000000 // Slide in from the sides on level load, depending on snap flags
#define V_NOSCALESTART 0x40000000 // don't scale x, y, start coords
#define V_SPLITSCREEN 0x80000000 // Add half of screen width or height automatically depending on player number