thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Mammoth commit, sorry.

Browse source 
All my work thus far on solving the drawflag/renderflag/additive/subtractive conundrum.

Outstandng problems:
* Bad additive/subtractive tables means that they appear opaque except under certain conditions.
* No support for FOFs, Polyobjects, or linedefs in OpenGL yet.
* All OpenGL support mostly done blind, may or may not function in practice.

If nothing else, the hard engineering problems are solved and it's just bug hammering...
This commit is contained in:
toaster 2021-03-31 22:46:23 +01:00
parent 553d708525
commit 40cbc30bff
38 changed files with 594 additions and 549 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

96
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,18 +6466,6 @@ 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_ADD",AST_ADD},
{"AST_SUBTRACT",AST_SUBTRACT},
{"AST_REVERSESUBTRACT",AST_REVERSESUBTRACT},
{"AST_MODULATE",AST_MODULATE},
{"AST_OVERLAY",AST_OVERLAY},
// Render flags
{"RF_HORIZONTALFLIP",RF_HORIZONTALFLIP},
@ -6481,9 +6477,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 +6488,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 +6908,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 +7022,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;

91
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,39 @@ 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];
if (!alphalevel)
flags &= ~PF_Translucent;
if (blendmode == AST_ADD)
flags |= PF_Additive;
else if (blendmode == AST_SUBTRACT)
flags |= PF_Subtractive;
else if (blendmode == AST_REVERSESUBTRACT)
flags |= PF_ReverseSubtract;
else if (blendmode == AST_MODULATE)
flags |= PF_Multiplicative;
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 +299,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 +308,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 +426,39 @@ 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];
if (!alphalevel)
flags &= ~PF_Translucent;
if (blendmode == AST_ADD)
flags |= PF_Additive;
else if (blendmode == AST_SUBTRACT)
flags |= PF_Subtractive;
else if (blendmode == AST_REVERSESUBTRACT)
flags |= PF_ReverseSubtract;
else if (blendmode == AST_MODULATE)
flags |= PF_Multiplicative;
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);
}

119
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;
@ -2903,7 +2903,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
@ -3882,17 +3882,25 @@ 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);
}
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
@ -3900,9 +3908,10 @@ static void HWR_SplitSprite(gl_vissprite_t *spr)
// 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;
blend = HWR_GetBlendModeFlag(blendmode)|occlusion;
if (!occlusion) use_linkdraw_hack = true;
}
}
alpha = Surf.PolyColor.s.alpha;
@ -4308,17 +4317,25 @@ 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);
}
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
@ -4326,9 +4343,10 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
// 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;
blend = HWR_GetBlendModeFlag(blendmode)|occlusion;
if (!occlusion) use_linkdraw_hack = true;
}
}
if (spr->renderflags & RF_SHADOWEFFECTS)
{
@ -4426,13 +4444,25 @@ 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);
}
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
@ -4440,7 +4470,8 @@ static inline void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
// Hurdler: PF_Environement would be cool, but we need to fix
// the issue with the fog before
Surf.PolyColor.s.alpha = 0xFF;
blend = HWR_GetBlendModeFlag(spr->mobj->blendmode)|PF_Occlude;
blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude;
}
}
HWR_ProcessPolygon(&Surf, wallVerts, 4, blend|PF_Modulated, SHADER_SPRITE, false); // sprite shader
@ -4471,8 +4502,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 +4520,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;

24
src/hardware/hw_md2.c
View file

@ -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);
// Determine the blendmode and translucency value
{
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(spr->mobj->blendmode);
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++;

16
src/info.c
View file

@ -1954,7 +1954,7 @@ state_t states[NUMSTATES] =
// 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_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;

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;

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

43
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)<<RF_BLENDSHIFT)
#define FF_SUBTRACT ((AST_SUBTRACT-1)<<RF_BLENDSHIFT)
#define FF_REVERSESUBTRACT ((AST_REVERSESUBTRACT-1)<<RF_BLENDSHIFT)
#define FF_MODULATE ((AST_MODULATE-1)<<RF_BLENDSHIFT)
#define FF_OVERLAY ((AST_OVERLAY-1)<<RF_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)
/// \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 appears with moderate brightness (mutually exclusive with above)
#define FF_SEMIBRIGHT 0x00200000
/// \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);

2
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

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

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

47
src/r_defs.h
View file

@ -729,6 +729,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 +745,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

8
src/r_draw.c
View file

@ -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();
}
@ -259,10 +256,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.

6
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)
{
@ -882,9 +882,9 @@ void R_DrawSinglePlane(visplane_t *pl)
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);
ds_transmap = R_GetTranslucencyTable(tr_trans50); // TODOOOOOOOOOOOOO
else if (pl->ffloor->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)
ds_transmap = transtables + ((tr_transsub-1)<<FF_TRANSSHIFT);
ds_transmap = R_GetTranslucencyTable(tr_trans50); // TODOOOOOOOOOOOOO
else // Opaque, but allow transparent flat pixels
spanfunctype = SPANDRAWFUNC_SPLAT;

50
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);
@ -640,9 +652,9 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
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);
dc_transmap = R_GetTranslucencyTable(tr_trans50); // TODOOOOOOOOOOOOO
else if (pfloor->alpha == FFLOOR_ALPHA_SPECIAL_SUBTRACTIVE)
dc_transmap = transtables + ((tr_transsub-1)<<FF_TRANSSHIFT);
dc_transmap = R_GetTranslucencyTable(tr_trans50); // TODOOOOOOOOOOOOO
else
fuzzy = false; // Opaque

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

64
src/r_things.c
View file

@ -1251,7 +1251,7 @@ 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;
boolean additive = false;
fixed_t groundz;
pslope_t *groundslope;
@ -1260,9 +1260,7 @@ 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;
}
additive = true;
patch = W_CachePatchName("DSHADOW", PU_SPRITE);
xscale = FixedDiv(projection[viewssnum], tz);
@ -1351,7 +1349,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(additive ? AST_ADD : AST_SUBTRACT, 0);
shadow->colormap = colormaps;
objectsdrawn++;
@ -1396,7 +1394,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 +1801,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
trans = 0;
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
}
// Check if this sprite needs to be rendered like a shadow
shadowdraw = (!!(thing->renderflags & RF_SHADOWDRAW) && !(papersprite || splat));
@ -1994,17 +2000,17 @@ 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);
if (blendmode != AST_COPY)
vis->transmap = R_GetBlendTable(blendmode, trans);
else
vis->transmap = NULL;
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 +3002,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 +3058,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);
}
//

58
src/v_video.c
View file

@ -519,7 +519,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 +543,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
if (alphalevel == 10) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 14) // V_HUDTRANS
else if (alphalevel == 11) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 15) // V_HUDTRANSDOUBLE
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);
if ((v_translevel = R_GetBlendTable(blendmode, alphalevel)))
patchdrawfunc = translucentpdraw;
}
}
v_colormap = NULL;
if (colormap)
@ -617,12 +611,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 +704,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 +727,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
if (alphalevel == 10) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 14) // V_HUDTRANS
else if (alphalevel == 11) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 15) // V_HUDTRANSDOUBLE
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);
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,19 +980,16 @@ 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
if (alphalevel == 10) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 14) // V_HUDTRANS
else if (alphalevel == 11) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 15) // V_HUDTRANSDOUBLE
else if (alphalevel == 12) // V_HUDTRANSDOUBLE
alphalevel = hudplusalpha[st_translucency];
if (alphalevel >= 10) // Still inelegible to render?
return;
}
}
if (!(c & V_NOSCALESTART))
{
@ -1945,9 +1924,6 @@ void V_DrawStringScaled(
case HU_FONT:
case TINY_FONT:
case KART_FONT:
if (( flags & V_RETURN8 ))
lfh = 8;
else
lfh = 12;
break;
case LT_FONT:

27
src/v_video.h
View file

@ -123,29 +123,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