lifning
/
SRB2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'le-fadefof-remove-storedthinker' into le-fadefof

This commit is contained in:
mazmazz 2018-08-16 23:38:03 -04:00
parent ca84e7265e 931297e2d7
commit cf853e3982
5 changed files with 282 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/p_saveg.c
View File

@ -1567,9 +1567,13 @@ static void SaveFadeThinker(const thinker_t *th, const UINT8 type)
const fade_t *ht = (const void *)th;
WRITEUINT8(save_p, type);
WRITEINT32(save_p, ht->affectee);
WRITEINT32(save_p, ht->destvalue);
WRITEINT32(save_p, ht->speed);
WRITEUINT32(save_p, ht->handleflags);
WRITEINT16(save_p, ht->destvalue);
WRITEINT16(save_p, ht->speed);
WRITEUINT8(save_p, ht->doexists);
WRITEUINT8(save_p, ht->dotranslucent);
WRITEUINT8(save_p, ht->dosolid);
WRITEUINT8(save_p, ht->dospawnflags);
WRITEUINT8(save_p, ht->doghostfade);
}
//
@ -2565,9 +2569,18 @@ static inline void LoadFadeThinker(actionf_p1 thinker)
fade_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
ht->affectee = READINT32(save_p);
ht->destvalue = READINT32(save_p);
ht->speed = READINT32(save_p);
ht->handleflags = READUINT32(save_p);
ht->destvalue = READINT16(save_p);
ht->speed = READINT16(save_p);
ht->doexists = READUINT8(save_p);
ht->dotranslucent = READUINT8(save_p);
ht->dosolid = READUINT8(save_p);
ht->dospawnflags = READUINT8(save_p);
ht->doghostfade = READUINT8(save_p);
line_t *ffloorline = LoadLine(ht->affectee);
if (ffloorline && ffloorline->frontsector)
ffloorline->frontsector->fadingdata = ht;
P_AddThinker(&ht->thinker);
}
@ -2757,7 +2770,7 @@ static void P_NetUnArchiveThinkers(void)
// clear sector thinker pointers so they don't point to non-existant thinkers for all of eternity
for (i = 0; i < numsectors; i++)
{
sectors[i].floordata = sectors[i].ceilingdata = sectors[i].lightingdata = NULL;
sectors[i].floordata = sectors[i].ceilingdata = sectors[i].lightingdata = sectors[i].fadingdata = NULL;
}
// read in saved thinkers

1
src/p_setup.c
View File

@ -693,6 +693,7 @@ static void P_LoadRawSectors(UINT8 *data, size_t i)
ss->floordata = NULL;
ss->ceilingdata = NULL;
ss->lightingdata = NULL;
ss->fadingdata = NULL;
ss->linecount = 0;
ss->lines = NULL;

431
src/p_spec.c
View File

@ -103,7 +103,14 @@ static void P_SpawnFriction(void);
static void P_SpawnPushers(void);
static void Add_Pusher(pushertype_e type, fixed_t x_mag, fixed_t y_mag, mobj_t *source, INT32 affectee, INT32 referrer, INT32 exclusive, INT32 slider); //SoM: 3/9/2000
static void Add_MasterDisappearer(tic_t appeartime, tic_t disappeartime, tic_t offset, INT32 line, INT32 sourceline);
static void P_AddMasterFader(INT32 destvalue, INT32 speed, BOOL handleexist, BOOL handlesolid, BOOL handletrans, INT32 line);
static void P_ResetFading(line_t *line, fade_t *data);
#define P_RemoveFading(l) P_ResetFading(l, NULL);
static INT32 P_FindFakeFloorsDoAlpha(INT16 destvalue, INT16 speed,
boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
boolean doghostfade, INT32 line);
static void P_AddMasterFader(INT16 destvalue, INT16 speed,
boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
boolean doghostfade, INT32 line);
static void P_AddBlockThinker(sector_t *sec, line_t *sourceline);
static void P_AddFloatThinker(sector_t *sec, INT32 tag, line_t *sourceline);
//static void P_AddBridgeThinker(line_t *sourceline, sector_t *sec);
@ -3100,17 +3107,41 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
for (s = -1; (s = P_FindSectorFromLineTag(line, s)) >= 0 ;)
for (j = 0; (unsigned)j < sectors[s].linecount; j++)
if (sectors[s].lines[j]->special >= 100 && sectors[s].lines[j]->special < 300)
P_AddMasterFader(sides[line->sidenum[0]].textureoffset>>FRACBITS,
sides[line->sidenum[0]].rowoffset>>FRACBITS,
(line->flags & ML_BLOCKMONSTERS), // handle FF_EXISTS
(line->flags & ML_NOCLIMB), // handle FF_SOLID
!(line->flags & ML_EFFECT1), // do not handle FF_TRANSLUCENT
(INT32)(sectors[s].lines[j]-lines));
{
if (sides[line->sidenum[0]].rowoffset>>FRACBITS > 0)
P_AddMasterFader(sides[line->sidenum[0]].textureoffset>>FRACBITS,
sides[line->sidenum[0]].rowoffset>>FRACBITS,
(line->flags & ML_BLOCKMONSTERS), // handle FF_EXISTS
!(line->flags & ML_NOCLIMB), // do not handle FF_TRANSLUCENT
(line->flags & ML_BOUNCY), // handle FF_SOLID
(line->flags & ML_EFFECT1), // handle spawnflags
(line->flags & ML_EFFECT2), // enable flags on fade-in finish only
(INT32)(sectors[s].lines[j]-lines));
else
{
P_RemoveFading(&lines[(INT32)(sectors[s].lines[j]-lines)]);
P_FindFakeFloorsDoAlpha(sides[line->sidenum[0]].textureoffset>>FRACBITS,
0, // set alpha immediately
(line->flags & ML_BLOCKMONSTERS), // handle FF_EXISTS
!(line->flags & ML_NOCLIMB), // do not handle FF_TRANSLUCENT
(line->flags & ML_BOUNCY), // handle FF_SOLID
(line->flags & ML_EFFECT1), // handle spawnflags
(line->flags & ML_EFFECT2), // enable flags on fade-in finish only
(INT32)(sectors[s].lines[j]-lines));
}
}
break;
}
case 453: // Stop fading FOF
{
INT32 s, j;
for (s = -1; (s = P_FindSectorFromLineTag(line, s)) >= 0 ;)
for (j = 0; (unsigned)j < sectors[s].linecount; j++)
if (sectors[s].lines[j]->special >= 100 && sectors[s].lines[j]->special < 300)
P_RemoveFading(&lines[(INT32)(sectors[s].lines[j]-lines)]);
break;
}
#ifdef POLYOBJECTS
case 480: // Polyobj_DoorSlide
@ -7113,35 +7144,229 @@ void T_Disappear(disappear_t *d)
}
}
/** Removes fadingdata from FOF control sector
*
* \param line line to search for target faders
* \param data pointer to set new fadingdata to. Can be NULL to erase.
*/
static void P_ResetFading(line_t *line, fade_t *data)
{
ffloor_t *rover;
register INT32 s;
// find any existing thinkers and remove them, then replace with new data
for (s = -1; (s = P_FindSectorFromLineTag(line, s)) >= 0 ;)
{
for (rover = sectors[s].ffloors; rover; rover = rover->next)
{
if (rover->master != line)
continue;
if(((fade_t *)rover->master->frontsector->fadingdata) != data)
{
if(&((fade_t *)rover->master->frontsector->fadingdata)->thinker)
P_RemoveThinker(&((fade_t *)rover->master->frontsector->fadingdata)->thinker);
rover->master->frontsector->fadingdata = data;
}
}
}
}
static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
boolean doghostfade)
{
boolean result = false;
if (rover->alpha == destvalue)
return result;
// fade out
else if (rover->alpha > destvalue)
{
// finish fading out
if (speed < 1 || rover->alpha - speed <= destvalue + speed)
{
rover->alpha = destvalue;
if (doexists)
{
if (rover->alpha <= 1)
rover->flags &= ~FF_EXISTS;
else
rover->flags |= FF_EXISTS;
}
if (dosolid
&& !(rover->flags & FF_SWIMMABLE)
&& !(rover->flags & FF_QUICKSAND))
rover->flags &= ~FF_SOLID; // make intangible at end of fade-out
if (dotranslucent)
{
if (rover->alpha >= 256)
{
rover->flags |= FF_CUTLEVEL;
rover->flags &= ~(FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA);
}
else
{
rover->flags |= FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA;
rover->flags &= ~FF_CUTLEVEL;
}
if (rover->flags & FF_SOLID)
rover->flags &= ~FF_CUTSPRITES;
else
rover->flags |= FF_CUTSPRITES;
}
}
else // continue fading out
{
rover->alpha -= speed;
if (doexists)
rover->flags |= FF_EXISTS;
if (dosolid
&& !(rover->flags & FF_SWIMMABLE)
&& !(rover->flags & FF_QUICKSAND))
rover->flags |= FF_SOLID; // keep solid during fade
if (dotranslucent)
{
rover->flags |= FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA;
rover->flags &= ~FF_CUTLEVEL;
if (rover->flags & FF_SOLID)
rover->flags &= ~FF_CUTSPRITES;
else
rover->flags |= FF_CUTSPRITES;
}
result = true;
}
}
else // fade in
{
// finish fading in
if (speed < 1 || rover->alpha + speed >= destvalue - speed)
{
rover->alpha = destvalue;
if (doexists)
{
if (rover->alpha <= 1)
rover->flags &= ~FF_EXISTS;
else
rover->flags |= FF_EXISTS;
}
if (dosolid
&& !(rover->flags & FF_SWIMMABLE)
&& !(rover->flags & FF_QUICKSAND))
rover->flags |= FF_SOLID; // make solid at end of fade-in
if (dotranslucent)
{
if (rover->alpha >= 256)
{
rover->flags |= FF_CUTLEVEL;
rover->flags &= ~(FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA);
}
else
{
rover->flags |= FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA;
rover->flags &= ~FF_CUTLEVEL;
}
if (rover->flags & FF_SOLID)
rover->flags &= ~FF_CUTSPRITES;
else
rover->flags |= FF_CUTSPRITES;
}
}
else // continue fading in
{
rover->alpha += speed;
if (doexists)
rover->flags |= FF_EXISTS;
if (dosolid
&& !(rover->flags & FF_SWIMMABLE)
&& !(rover->flags & FF_QUICKSAND))
rover->flags |= FF_SOLID; // keep solid during fade
if (dotranslucent)
{
rover->flags |= FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA;
rover->flags &= ~FF_CUTLEVEL;
if (rover->flags & FF_SOLID)
rover->flags &= ~FF_CUTSPRITES;
else
rover->flags |= FF_CUTSPRITES;
}
result = true;
}
}
return result;
}
static INT32 P_FindFakeFloorsDoAlpha(INT16 destvalue, INT16 speed,
boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
boolean doghostfade, INT32 line)
{
ffloor_t *rover;
register INT32 s;
INT32 affectedffloors = 0;
for (s = -1; (s = P_FindSectorFromLineTag(&lines[line], s)) >= 0 ;)
{
for (rover = sectors[s].ffloors; rover; rover = rover->next)
{
if (rover->master != &lines[line])
continue;
affectedffloors += (INT32)P_DoFakeFloorAlpha(rover, destvalue, speed, doexists, dotranslucent, dosolid, dospawnflags, doghostfade);
}
}
return affectedffloors;
}
/** Adds master fader thinker.
*
* \param destvalue transparency value to fade to
* \param speed speed to fade by
* \param handleexist handle FF_EXISTS
* \param handlesolid handle FF_SOLID
* \param handletrans do not handle FF_TRANSLUCENT
* \param doexists handle FF_EXISTS
* \param dotranslucent handle FF_TRANSLUCENT
* \param dosolid handle FF_SOLID
* \param dospawnflags handle spawnflags
* \param doghostfade enable flags when fade-in is finished; never on fade-out
* \param line line to target FOF
*/
static void P_AddMasterFader(INT32 destvalue, INT32 speed, BOOL handleexist, BOOL handlesolid, BOOL handletrans, INT32 line)
static void P_AddMasterFader(INT16 destvalue, INT16 speed,
boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
boolean doghostfade, INT32 line)
{
fade_t *d = Z_Malloc(sizeof *d, PU_LEVSPEC, NULL);
d->thinker.function.acp1 = (actionf_p1)T_Fade;
d->affectee = line;
d->destvalue = max(1, min(256, destvalue)); // ffloor->alpha is 1-256
d->speed = max(1, speed); // minimum speed 1/tic
d->speed = max(1, speed); // minimum speed 1/tic // if speed < 1, alpha is set immediately in thinker
d->doexists = doexists;
d->dotranslucent = dotranslucent;
d->dosolid = dosolid;
d->dospawnflags = dospawnflags;
d->doghostfade = doghostfade;
// combine the flags-to-handle, this is more convenient than separate BOOLS
d->handleflags = 0;
if (handleexist)
d->handleflags |= FF_EXISTS;
if (handlesolid)
d->handleflags |= FF_SOLID;
if (handletrans)
d->handleflags |= FF_TRANSLUCENT;
// find any existing thinkers and remove them, then replace with new data
P_ResetFading(&lines[d->affectee], d);
P_AddThinker(&d->thinker);
}
@ -7153,163 +7378,13 @@ static void P_AddMasterFader(INT32 destvalue, INT32 speed, BOOL handleexist, BOO
*/
void T_Fade(fade_t *d)
{
ffloor_t *rover;
register INT32 s;
INT32 affectedffloors = 0;
for (s = -1; (s = P_FindSectorFromLineTag(&lines[d->affectee], s)) >= 0 ;)
{
for (rover = sectors[s].ffloors; rover; rover = rover->next)
{
if (rover->master != &lines[d->affectee])
continue;
// fade out
if (rover->alpha > d->destvalue)
{
// finish fading out
if (rover->alpha - d->speed <= d->destvalue + d->speed)
{
if (rover->alpha != d->destvalue)
{
rover->alpha = d->destvalue;
if (d->handleflags & FF_EXISTS)
{
if (rover->alpha <= 1)
rover->flags &= ~FF_EXISTS;
else
rover->flags |= FF_EXISTS;
}
if ((d->handleflags & FF_SOLID)
&& !(rover->flags & FF_SWIMMABLE)
&& !(rover->flags & FF_QUICKSAND))
rover->flags &= ~FF_SOLID; // make intangible at end of fade-out
if (d->handleflags & FF_TRANSLUCENT)
{
if (rover->alpha >= 256)
{
rover->flags |= FF_CUTLEVEL;
rover->flags &= ~(FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA);
}
else
{
rover->flags |= FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA;
rover->flags &= ~FF_CUTLEVEL;
}
if (rover->flags & FF_SOLID)
rover->flags &= ~FF_CUTSPRITES;
else
rover->flags |= FF_CUTSPRITES;
}
}
}
else // continue fading out
{
rover->alpha -= d->speed;
if (d->handleflags & FF_EXISTS)
rover->flags |= FF_EXISTS;
if ((d->handleflags & FF_SOLID)
&& !(rover->flags & FF_SWIMMABLE)
&& !(rover->flags & FF_QUICKSAND))
rover->flags |= FF_SOLID; // keep solid during fade
if (d->handleflags & FF_TRANSLUCENT)
{
rover->flags |= FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA;
rover->flags &= ~FF_CUTLEVEL;
if (rover->flags & FF_SOLID)
rover->flags &= ~FF_CUTSPRITES;
else
rover->flags |= FF_CUTSPRITES;
}
affectedffloors++;
}
}
else // fade in
{
// finish fading in
if (rover->alpha + d->speed >= d->destvalue - d->speed)
{
if (rover->alpha != d->destvalue)
{
rover->alpha = d->destvalue;
if (d->handleflags & FF_EXISTS)
{
if (rover->alpha <= 1)
rover->flags &= ~FF_EXISTS;
else
rover->flags |= FF_EXISTS;
}
if ((d->handleflags & FF_SOLID)
&& !(rover->flags & FF_SWIMMABLE)
&& !(rover->flags & FF_QUICKSAND))
rover->flags |= FF_SOLID; // make solid at end of fade-in
if (d->handleflags & FF_TRANSLUCENT)
{
if (rover->alpha >= 256)
{
rover->flags |= FF_CUTLEVEL;
rover->flags &= ~(FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA);
}
else
{
rover->flags |= FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA;
rover->flags &= ~FF_CUTLEVEL;
}
if (rover->flags & FF_SOLID)
rover->flags &= ~FF_CUTSPRITES;
else
rover->flags |= FF_CUTSPRITES;
}
}
}
else // continue fading in
{
rover->alpha += d->speed;
if (d->handleflags & FF_EXISTS)
rover->flags |= FF_EXISTS;
if ((d->handleflags & FF_SOLID)
&& !(rover->flags & FF_SWIMMABLE)
&& !(rover->flags & FF_QUICKSAND))
rover->flags |= FF_SOLID; // keep solid during fade
if (d->handleflags & FF_TRANSLUCENT)
{
rover->flags |= FF_TRANSLUCENT|FF_EXTRA|FF_CUTEXTRA;
rover->flags &= ~FF_CUTLEVEL;
if (rover->flags & FF_SOLID)
rover->flags &= ~FF_CUTSPRITES;
else
rover->flags |= FF_CUTSPRITES;
}
affectedffloors++;
}
}
}
}
INT32 affectedffloors = P_FindFakeFloorsDoAlpha(d->destvalue, d->speed,
d->doexists, d->dotranslucent, d->dosolid, d->dospawnflags,
d->doghostfade, d->affectee);
// no more ffloors to fade? remove myself
if (affectedffloors == 0)
{
// \todo how to erase the fade_t struct?
P_RemoveThinker(&d->thinker);
}
P_RemoveFading(&lines[d->affectee]);
}
/*

10
src/p_spec.h
View File

@ -454,9 +454,13 @@ typedef struct
{
thinker_t thinker; ///< Thinker structure for effect.
INT32 affectee; ///< Number of affected line
INT32 destvalue; ///< Transparency value to fade to
INT32 speed; ///< Speed to fade by
UINT32 handleflags; ///< FOF flags to handle
INT16 destvalue; ///< Transparency value to fade to
INT16 speed; ///< Speed to fade by
boolean doexists; ///< Handle FF_EXISTS handling
boolean dotranslucent; ///< Handle FF_TRANSLUCENT handling
boolean dosolid; ///< Handle FF_SOLID handling
boolean dospawnflags; ///< Enable spawnflags handling
boolean doghostfade; ///< Set flags only when fade-in is finished; never during fade-out
} fade_t;
void T_Fade(fade_t *d);

1
src/r_defs.h
View File

@ -308,6 +308,7 @@ typedef struct sector_s
void *floordata; // floor move thinker
void *ceilingdata; // ceiling move thinker
void *lightingdata; // lighting change thinker
void *fadingdata; // fading FOF thinker
// floor and ceiling texture offsets
fixed_t floor_xoffs, floor_yoffs;