From 2e252cb905c9e6db5c5537752e86f23fff26a5b8 Mon Sep 17 00:00:00 2001
From: mazmazz <mar.marcoz@outlook.com>
Date: Fri, 17 Aug 2018 00:32:20 -0400
Subject: [PATCH 1/6] Move fadingdata (fade_t thinker) to line_t

---
 src/p_saveg.c |  12 +++--
 src/p_setup.c |   3 +-
 src/p_spec.c  | 132 ++++++++++++++++++++++++++++++++------------------
 src/r_defs.h  |   3 +-
 4 files changed, 97 insertions(+), 53 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index 70c6b411e..f30c52bda 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -2578,8 +2578,8 @@ static inline void LoadFadeThinker(actionf_p1 thinker)
 	ht->doghostfade = READUINT8(save_p);
 
 	line_t *ffloorline = LoadLine(ht->affectee);
-	if (ffloorline && ffloorline->frontsector)
-		ffloorline->frontsector->fadingdata = ht;
+	if (ffloorline)
+		ffloorline->fadingdata = ht;
 
 	P_AddThinker(&ht->thinker);
 }
@@ -2770,7 +2770,13 @@ 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 = sectors[i].fadingdata = NULL;
+		sectors[i].floordata = sectors[i].ceilingdata = sectors[i].lightingdata = NULL;
+	}
+
+	// same for line thinker pointers
+	for (i = 0; i < numlines; i++)
+	{
+		lines[i].fadingdata = NULL;
 	}
 
 	// read in saved thinkers
diff --git a/src/p_setup.c b/src/p_setup.c
index 67dbb8db7..5259394ee 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -693,7 +693,6 @@ 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;
@@ -1311,6 +1310,8 @@ static void P_LoadRawLineDefs(UINT8 *data, size_t i)
 #ifdef POLYOBJECTS
 		ld->polyobj = NULL;
 #endif
+
+		ld->fadingdata = NULL;
 	}
 }
 
diff --git a/src/p_spec.c b/src/p_spec.c
index 0fa16f9f4..6f392bbfe 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -3103,43 +3103,91 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
 
 		case 452: // Fade 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)
-					{
-						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));
-						}
-					}
+			INT16 destvalue = (INT16)(sides[line->sidenum[1]].textureoffset>>FRACBITS);
+			INT16 speed = (INT16)(sides[line->sidenum[1]].rowoffset>>FRACBITS);
+			INT16 sectag = (INT16)(sides[line->sidenum[0]].textureoffset>>FRACBITS);
+			INT16 foftag = (INT16)(sides[line->sidenum[0]].rowoffset>>FRACBITS);
+			sector_t *sec; // Sector that the FOF is visible in
+			ffloor_t *rover; // FOF that we are going to crumble
+
+			for (secnum = -1; (secnum = P_FindSectorFromTag(sectag, secnum)) >= 0 ;)
+			{
+				sec = sectors + secnum;
+
+				if (!sec->ffloors)
+				{
+					CONS_Debug(DBG_GAMELOGIC, "Line type 452 Executor: Target sector #%d has no FOFs.\n", secnum);
+					return;
+				}
+
+				for (rover = sec->ffloors; rover; rover = rover->next)
+				{
+					if (rover->master->frontsector->tag == foftag)
+						break;
+				}
+
+				if (!rover)
+				{
+					CONS_Debug(DBG_GAMELOGIC, "Line type 452 Executor: Can't find a FOF control sector with tag %d\n", foftag);
+					return;
+				}
+
+				if (speed > 0)
+					P_AddMasterFader(destvalue, speed,
+						(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)(rover->master-lines));
+				else
+				{
+					P_RemoveFading(&lines[(INT32)(rover->master-lines)]);
+					P_FindFakeFloorsDoAlpha(destvalue, 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)(rover->master-lines));
+				}
+				break;
+			}
 			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)]);
+			INT16 sectag = (INT16)(sides[line->sidenum[0]].textureoffset>>FRACBITS);
+			INT16 foftag = (INT16)(sides[line->sidenum[0]].rowoffset>>FRACBITS);
+			sector_t *sec; // Sector that the FOF is visible in
+			ffloor_t *rover; // FOF that we are going to crumble
+
+			for (secnum = -1; (secnum = P_FindSectorFromTag(sectag, secnum)) >= 0 ;)
+			{
+				sec = sectors + secnum;
+
+				if (!sec->ffloors)
+				{
+					CONS_Debug(DBG_GAMELOGIC, "Line type 453 Executor: Target sector #%d has no FOFs.\n", secnum);
+					return;
+				}
+
+				for (rover = sec->ffloors; rover; rover = rover->next)
+				{
+					if (rover->master->frontsector->tag == foftag)
+						break;
+				}
+
+				if (!rover)
+				{
+					CONS_Debug(DBG_GAMELOGIC, "Line type 453 Executor: Can't find a FOF control sector with tag %d\n", foftag);
+					return;
+				}
+
+				P_RemoveFading(&lines[(INT32)(rover->master-lines)]);
+				break;
+			}
 			break;
 		}
 
@@ -7151,25 +7199,13 @@ void T_Disappear(disappear_t *d)
  */
 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 ;)
+	if(((fade_t *)line->fadingdata) != data)
 	{
-		for (rover = sectors[s].ffloors; rover; rover = rover->next)
-		{
-			if (rover->master != line)
-				continue;
+		if(&((fade_t *)line->fadingdata)->thinker)
+			P_RemoveThinker(&((fade_t *)line->fadingdata)->thinker);
 
-			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;
-			}
-		}
+		line->fadingdata = data;
 	}
 }
 
diff --git a/src/r_defs.h b/src/r_defs.h
index b4c7d2112..c425f3a3b 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -308,7 +308,6 @@ 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;
@@ -444,6 +443,8 @@ typedef struct line_s
 
 	char *text; // a concatination of all front and back texture names, for linedef specials that require a string.
 	INT16 callcount; // no. of calls left before triggering, for the "X calls" linedef specials, defaults to 0
+
+	void *fadingdata; // fading FOF thinker
 } line_t;
 
 //

From 677f19ede6680bffc5e97253b48e70d55fd403f4 Mon Sep 17 00:00:00 2001
From: mazmazz <mar.marcoz@outlook.com>
Date: Fri, 17 Aug 2018 02:28:52 -0400
Subject: [PATCH 2/6] Move fading thinker to ffloor_t.fadingdata

---
 src/p_saveg.c |  31 ++++++++++------
 src/p_setup.c |   2 -
 src/p_spec.c  | 101 +++++++++++++++++++-------------------------------
 src/p_spec.h  |   6 ++-
 src/r_defs.h  |   4 +-
 5 files changed, 65 insertions(+), 79 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index f30c52bda..daa6bb937 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -1566,7 +1566,8 @@ 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->sectornum);
+	WRITEINT32(save_p, ht->ffloornum);
 	WRITEINT16(save_p, ht->destvalue);
 	WRITEINT16(save_p, ht->speed);
 	WRITEUINT8(save_p, ht->doexists);
@@ -2568,7 +2569,8 @@ 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->sectornum = READINT32(save_p);
+	ht->ffloornum = READINT32(save_p);
 	ht->destvalue = READINT16(save_p);
 	ht->speed = READINT16(save_p);
 	ht->doexists = READUINT8(save_p);
@@ -2577,9 +2579,22 @@ static inline void LoadFadeThinker(actionf_p1 thinker)
 	ht->dospawnflags = READUINT8(save_p);
 	ht->doghostfade = READUINT8(save_p);
 
-	line_t *ffloorline = LoadLine(ht->affectee);
-	if (ffloorline)
-		ffloorline->fadingdata = ht;
+	sector_t *ss = LoadSector(ht->sectornum);
+	if (ss)
+	{
+		size_t j = 0; // ss->ffloors is saved as ffloor #0, ss->ffloors->next is #1, etc
+		ffloor_t *rover;
+		for (rover = ss->ffloors; rover; rover = rover->next)
+		{
+			if (j == ht->ffloornum)
+			{
+				ht->rover = rover;
+				rover->fadingdata = ht;
+				break;
+			}
+			j++;
+		}
+	}
 
 	P_AddThinker(&ht->thinker);
 }
@@ -2773,12 +2788,6 @@ static void P_NetUnArchiveThinkers(void)
 		sectors[i].floordata = sectors[i].ceilingdata = sectors[i].lightingdata = NULL;
 	}
 
-	// same for line thinker pointers
-	for (i = 0; i < numlines; i++)
-	{
-		lines[i].fadingdata = NULL;
-	}
-
 	// read in saved thinkers
 	for (;;)
 	{
diff --git a/src/p_setup.c b/src/p_setup.c
index 5259394ee..c62f281b3 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -1310,8 +1310,6 @@ static void P_LoadRawLineDefs(UINT8 *data, size_t i)
 #ifdef POLYOBJECTS
 		ld->polyobj = NULL;
 #endif
-
-		ld->fadingdata = NULL;
 	}
 }
 
diff --git a/src/p_spec.c b/src/p_spec.c
index 6f392bbfe..20f034ac8 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -103,14 +103,15 @@ 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_ResetFading(line_t *line, fade_t *data);
+static void P_ResetFading(ffloor_t *rover, fade_t *data);
 #define P_RemoveFading(l) P_ResetFading(l, NULL);
-static INT32 P_FindFakeFloorsDoAlpha(INT16 destvalue, INT16 speed,
+static boolean P_DoFakeFloorAlpha(ffloor_t *rover, 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 doghostfade);
+static void P_AddMasterFader(ffloor_t *rover, size_t sectornum, size_t ffloornum,
+	INT16 destvalue, INT16 speed,
 	boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
-	boolean doghostfade, INT32 line);
+	boolean doghostfade);
 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);
@@ -3109,6 +3110,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
 			INT16 foftag = (INT16)(sides[line->sidenum[0]].rowoffset>>FRACBITS);
 			sector_t *sec; // Sector that the FOF is visible in
 			ffloor_t *rover; // FOF that we are going to crumble
+			size_t j = 0; // sec->ffloors is saved as ffloor #0, ss->ffloors->next is #1, etc
 
 			for (secnum = -1; (secnum = P_FindSectorFromTag(sectag, secnum)) >= 0 ;)
 			{
@@ -3124,6 +3126,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
 				{
 					if (rover->master->frontsector->tag == foftag)
 						break;
+					j++;
 				}
 
 				if (!rover)
@@ -3133,25 +3136,24 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
 				}
 
 				if (speed > 0)
-					P_AddMasterFader(destvalue, speed,
-						(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)(rover->master-lines));
+					P_AddMasterFader(rover, secnum, j,
+						destvalue, speed,
+						(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
 				else
 				{
-					P_RemoveFading(&lines[(INT32)(rover->master-lines)]);
-					P_FindFakeFloorsDoAlpha(destvalue, 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)(rover->master-lines));
+					P_RemoveFading(rover);
+					P_DoFakeFloorAlpha(rover,
+						destvalue, 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
 				}
-				break;
 			}
 			break;
 		}
@@ -3185,8 +3187,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
 					return;
 				}
 
-				P_RemoveFading(&lines[(INT32)(rover->master-lines)]);
-				break;
+				P_RemoveFading(rover);
 			}
 			break;
 		}
@@ -5036,7 +5037,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
 	ffloor->spawnflags = ffloor->flags = flags;
 	ffloor->master = master;
 	ffloor->norender = INFTICS;
-
+	ffloor->fadingdata = NULL;
 
 	// Scan the thinkers to check for special conditions applying to this FOF.
 	// If we have thinkers sorted by sector, just check the relevant ones;
@@ -7197,15 +7198,15 @@ void T_Disappear(disappear_t *d)
  * \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)
+static void P_ResetFading(ffloor_t *rover, fade_t *data)
 {
 	// find any existing thinkers and remove them, then replace with new data
-	if(((fade_t *)line->fadingdata) != data)
+	if(((fade_t *)rover->fadingdata) != data)
 	{
-		if(&((fade_t *)line->fadingdata)->thinker)
-			P_RemoveThinker(&((fade_t *)line->fadingdata)->thinker);
+		if(&((fade_t *)rover->fadingdata)->thinker)
+			P_RemoveThinker(&((fade_t *)rover->fadingdata)->thinker);
 
-		line->fadingdata = data;
+		rover->fadingdata = data;
 	}
 }
 
@@ -7352,28 +7353,6 @@ static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
 	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
@@ -7385,14 +7364,17 @@ static INT32 P_FindFakeFloorsDoAlpha(INT16 destvalue, INT16 speed,
   * \param doghostfade	enable flags when fade-in is finished; never on fade-out
   * \param line			line to target FOF
   */
-static void P_AddMasterFader(INT16 destvalue, INT16 speed,
+static void P_AddMasterFader(ffloor_t *rover, size_t sectornum, size_t ffloornum,
+	INT16 destvalue, INT16 speed,
 	boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
-	boolean doghostfade, INT32 line)
+	boolean doghostfade)
 {
 	fade_t *d = Z_Malloc(sizeof *d, PU_LEVSPEC, NULL);
 
 	d->thinker.function.acp1 = (actionf_p1)T_Fade;
-	d->affectee = line;
+	d->rover = rover;
+	d->sectornum = (INT32)sectornum;
+	d->ffloornum = (INT32)ffloornum;
 	d->destvalue = max(1, min(256, destvalue)); // ffloor->alpha is 1-256
 	d->speed = max(1, speed); // minimum speed 1/tic // if speed < 1, alpha is set immediately in thinker
 	d->doexists = doexists;
@@ -7402,7 +7384,7 @@ static void P_AddMasterFader(INT16 destvalue, INT16 speed,
 	d->doghostfade = doghostfade;
 
 	// find any existing thinkers and remove them, then replace with new data
-	P_ResetFading(&lines[d->affectee], d);
+	P_ResetFading(rover, d);
 
 	P_AddThinker(&d->thinker);
 }
@@ -7414,13 +7396,8 @@ static void P_AddMasterFader(INT16 destvalue, INT16 speed,
   */
 void T_Fade(fade_t *d)
 {
-	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)
-		P_RemoveFading(&lines[d->affectee]);
+	if (d->rover && !P_DoFakeFloorAlpha(d->rover, d->destvalue, d->speed, d->doexists, d->dotranslucent, d->dosolid, d->dospawnflags, d->doghostfade))
+		P_RemoveFading(d->rover);
 }
 
 /*
diff --git a/src/p_spec.h b/src/p_spec.h
index 672b96f30..fcced9cea 100644
--- a/src/p_spec.h
+++ b/src/p_spec.h
@@ -453,14 +453,16 @@ void T_Disappear(disappear_t *d);
 typedef struct
 {
 	thinker_t thinker;  ///< Thinker structure for effect.
-	INT32 affectee;     ///< Number of affected line
+	ffloor_t *rover;    ///< Target ffloor
+	INT32 sectornum;    ///< Number of ffloor target sector
+	INT32 ffloornum;    ///< Number of ffloor of target sector
 	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
+	boolean doghostfade;   ///< Set flags only when fade-in is finished; never during fade-out
 } fade_t;
 
 void T_Fade(fade_t *d);
diff --git a/src/r_defs.h b/src/r_defs.h
index c425f3a3b..ea5db3947 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -177,6 +177,8 @@ typedef struct ffloor_s
 	// these are saved for netgames, so do not let Lua touch these!
 	ffloortype_e spawnflags; // flags the 3D floor spawned with
 	INT32 spawnalpha; // alpha the 3D floor spawned with
+
+	void *fadingdata; // fading FOF thinker
 } ffloor_t;
 
 
@@ -443,8 +445,6 @@ typedef struct line_s
 
 	char *text; // a concatination of all front and back texture names, for linedef specials that require a string.
 	INT16 callcount; // no. of calls left before triggering, for the "X calls" linedef specials, defaults to 0
-
-	void *fadingdata; // fading FOF thinker
 } line_t;
 
 //

From 020b18b84ba668e0ee371205d019c1695ec204f1 Mon Sep 17 00:00:00 2001
From: mazmazz <mar.marcoz@outlook.com>
Date: Fri, 17 Aug 2018 14:49:33 -0400
Subject: [PATCH 3/6] Revised and re-organized P_DoFakeFloorAlpha fading
 procedure

* dosolid routine now refers to spawnflags
---
 src/p_spec.c | 203 +++++++++++++++++++++++++--------------------------
 1 file changed, 98 insertions(+), 105 deletions(-)

diff --git a/src/p_spec.c b/src/p_spec.c
index 20f034ac8..9fe25bcba 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -7214,74 +7214,34 @@ static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
 	boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
 	boolean doghostfade)
 {
-	boolean result = false;
+	boolean stillfading = false;
 
+	// routines specific to fade in and fade out
 	if (rover->alpha == destvalue)
-		return result;
-	// fade out
-	else if (rover->alpha > destvalue)
+		return stillfading;
+	else if (rover->alpha > destvalue) // fade out
 	{
 		// finish fading out
 		if (speed < 1 || rover->alpha - speed <= destvalue + speed)
 		{
 			rover->alpha = destvalue;
 
-			if (doexists)
+			if (dosolid)
 			{
-				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;
+				if (rover->spawnflags & FF_SOLID)
+					rover->flags &= ~FF_SOLID;
+				if (rover->spawnflags & FF_SWIMMABLE)
+					rover->flags &= ~FF_SWIMMABLE;
+				if (rover->spawnflags & FF_QUICKSAND)
+					rover->flags &= ~FF_QUICKSAND;
+				if (rover->spawnflags & FF_BUSTUP)
+					rover->flags &= ~FF_BUSTUP;
 			}
 		}
 		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;
+			stillfading = true;
 		}
 	}
 	else // fade in
@@ -7291,66 +7251,99 @@ static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
 		{
 			rover->alpha = destvalue;
 
-			if (doexists)
+			if (dosolid)
 			{
-				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;
+				if (rover->spawnflags & FF_SOLID)
+					rover->flags |= FF_SOLID;
+				if (rover->spawnflags & FF_SWIMMABLE)
+					rover->flags |= FF_SWIMMABLE;
+				if (rover->spawnflags & FF_QUICKSAND)
+					rover->flags |= FF_QUICKSAND;
+				if (rover->spawnflags & FF_BUSTUP)
+					rover->flags |= FF_BUSTUP;
 			}
 		}
 		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;
+			stillfading = true;
 		}
 	}
 
-	return result;
+	// routines common to both fade in and fade out
+	if (!stillfading)
+	{
+		if (doexists)
+		{
+			if (rover->alpha <= 1)
+				rover->flags &= ~FF_EXISTS;
+			else
+				rover->flags |= FF_EXISTS;
+		}
+
+		if (dotranslucent)
+		{
+			if (rover->alpha >= 256)
+			{
+				//rover->flags |= FF_CUTLEVEL;
+				rover->flags &= ~FF_TRANSLUCENT;
+			}
+			else
+			{
+				rover->flags |= FF_TRANSLUCENT;
+				//rover->flags &= ~FF_CUTLEVEL;
+			}
+
+			// if (rover->flags & FF_SOLID)
+			// 	rover->flags &= ~FF_CUTSPRITES;
+			// else
+			// 	rover->flags |= FF_CUTSPRITES;
+		}
+	}
+	else
+	{
+		if (doexists)
+			rover->flags |= FF_EXISTS;
+
+		if (dotranslucent)
+		{
+			rover->flags |= FF_TRANSLUCENT;
+			//rover->flags &= ~FF_CUTLEVEL;
+
+			// if (rover->flags & FF_SOLID)
+			// 	rover->flags &= ~FF_CUTSPRITES;
+			// else
+			// 	rover->flags |= FF_CUTSPRITES;
+		}
+
+		if (dosolid)
+		{
+			if (doghostfade) // remove interaction flags during fade
+			{
+				if (rover->spawnflags & FF_SOLID)
+					rover->flags &= ~FF_SOLID;
+				if (rover->spawnflags & FF_SWIMMABLE)
+					rover->flags &= ~FF_SWIMMABLE;
+				if (rover->spawnflags & FF_QUICKSAND)
+					rover->flags &= ~FF_QUICKSAND;
+				if (rover->spawnflags & FF_BUSTUP)
+					rover->flags &= ~FF_BUSTUP;
+			}
+			else // keep interaction during fade
+			{
+				if (rover->spawnflags & FF_SOLID)
+					rover->flags |= FF_SOLID;
+				if (rover->spawnflags & FF_SWIMMABLE)
+					rover->flags |= FF_SWIMMABLE;
+				if (rover->spawnflags & FF_QUICKSAND)
+					rover->flags |= FF_QUICKSAND;
+				if (rover->spawnflags & FF_BUSTUP)
+					rover->flags |= FF_BUSTUP;
+			}
+		}
+	}
+
+	return stillfading;
 }
 
 /** Adds master fader thinker.

From 45ae6efbadfc01d54d70081909573680472416a1 Mon Sep 17 00:00:00 2001
From: mazmazz <mar.marcoz@outlook.com>
Date: Fri, 17 Aug 2018 15:13:05 -0400
Subject: [PATCH 4/6] Refactor function and variable names; change defaults for
 fake floor fader line flags

---
 src/p_saveg.c |  8 ++---
 src/p_spec.c  | 87 ++++++++++++++++++++++++---------------------------
 src/p_spec.h  | 10 +++---
 3 files changed, 50 insertions(+), 55 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index daa6bb937..c2158aa0d 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -1572,9 +1572,9 @@ static void SaveFadeThinker(const thinker_t *th, const UINT8 type)
 	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->docollision);
 	WRITEUINT8(save_p, ht->doghostfade);
+	WRITEUINT8(save_p, ht->exactalpha);
 }
 
 //
@@ -2575,9 +2575,9 @@ static inline void LoadFadeThinker(actionf_p1 thinker)
 	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->docollision = READUINT8(save_p);
 	ht->doghostfade = READUINT8(save_p);
+	ht->exactalpha = READUINT8(save_p);
 
 	sector_t *ss = LoadSector(ht->sectornum);
 	if (ss)
diff --git a/src/p_spec.c b/src/p_spec.c
index 9fe25bcba..4694eb015 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -103,15 +103,13 @@ 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_ResetFading(ffloor_t *rover, fade_t *data);
-#define P_RemoveFading(l) P_ResetFading(l, NULL);
-static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
-	boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
-	boolean doghostfade);
-static void P_AddMasterFader(ffloor_t *rover, size_t sectornum, size_t ffloornum,
+static void P_ResetFakeFloorFader(ffloor_t *rover, fade_t *data);
+#define P_RemoveFakeFloorFader(l) P_ResetFakeFloorFader(l, NULL);
+static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
+	boolean doexists, boolean dotranslucent, boolean docollision, boolean doghostfade, boolean exactalpha);
+static void P_AddFakeFloorFader(ffloor_t *rover, size_t sectornum, size_t ffloornum,
 	INT16 destvalue, INT16 speed,
-	boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
-	boolean doghostfade);
+	boolean doexists, boolean dotranslucent, boolean docollision, boolean doghostfade, boolean exactalpha);
 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);
@@ -3136,23 +3134,23 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
 				}
 
 				if (speed > 0)
-					P_AddMasterFader(rover, secnum, j,
+					P_AddFakeFloorFader(rover, secnum, j,
 						destvalue, speed,
-						(line->flags & ML_BLOCKMONSTERS),   // handle FF_EXISTS
+						!(line->flags & ML_BLOCKMONSTERS),  // do not 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
+						!(line->flags & ML_BOUNCY),         // do not handle interactive flags
+						(line->flags & ML_EFFECT1),         // do ghost fade (no interactive flags during fade)
+						(line->flags & ML_TFERLINE));       // use exact alpha values (for opengl)
 				else
 				{
-					P_RemoveFading(rover);
-					P_DoFakeFloorAlpha(rover,
-						destvalue, 0,   // set alpha immediately
-						(line->flags & ML_BLOCKMONSTERS),   // handle FF_EXISTS
+					P_RemoveFakeFloorFader(rover);
+					P_FadeFakeFloor(rover,
+						destvalue, 0, // set alpha immediately
+						!(line->flags & ML_BLOCKMONSTERS),  // do not 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
+						!(line->flags & ML_BOUNCY),         // do not handle interactive flags
+						(line->flags & ML_EFFECT1),         // do ghost fade (no interactive flags during fade)
+						(line->flags & ML_TFERLINE));       // use exact alpha values (for opengl)
 				}
 			}
 			break;
@@ -3187,7 +3185,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
 					return;
 				}
 
-				P_RemoveFading(rover);
+				P_RemoveFakeFloorFader(rover);
 			}
 			break;
 		}
@@ -7198,7 +7196,7 @@ void T_Disappear(disappear_t *d)
  * \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(ffloor_t *rover, fade_t *data)
+static void P_ResetFakeFloorFader(ffloor_t *rover, fade_t *data)
 {
 	// find any existing thinkers and remove them, then replace with new data
 	if(((fade_t *)rover->fadingdata) != data)
@@ -7210,9 +7208,8 @@ static void P_ResetFading(ffloor_t *rover, fade_t *data)
 	}
 }
 
-static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
-	boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
-	boolean doghostfade)
+static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
+	boolean doexists, boolean dotranslucent, boolean docollision, boolean doghostfade, boolean exactalpha)
 {
 	boolean stillfading = false;
 
@@ -7226,7 +7223,7 @@ static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
 		{
 			rover->alpha = destvalue;
 
-			if (dosolid)
+			if (docollision)
 			{
 				if (rover->spawnflags & FF_SOLID)
 					rover->flags &= ~FF_SOLID;
@@ -7251,7 +7248,7 @@ static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
 		{
 			rover->alpha = destvalue;
 
-			if (dosolid)
+			if (docollision)
 			{
 				if (rover->spawnflags & FF_SOLID)
 					rover->flags |= FF_SOLID;
@@ -7316,7 +7313,7 @@ static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
 			// 	rover->flags |= FF_CUTSPRITES;
 		}
 
-		if (dosolid)
+		if (docollision)
 		{
 			if (doghostfade) // remove interaction flags during fade
 			{
@@ -7346,21 +7343,19 @@ static boolean P_DoFakeFloorAlpha(ffloor_t *rover, INT16 destvalue, INT16 speed,
 	return stillfading;
 }
 
-/** Adds master fader thinker.
+/** Adds fake floor fader thinker.
   *
-  * \param destvalue	transparency value to fade to
-  * \param speed		speed to fade by
-  * \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
+  * \param destvalue    transparency value to fade to
+  * \param speed        speed to fade by
+  * \param doexists	    handle FF_EXISTS
+  * \param dotranslucent handle FF_TRANSLUCENT
+  * \param docollision handle interactive flags
+  * \param doghostfade  no interactive flags during fading
+  * \param exactalpha   use exact alpha values (opengl)
   */
-static void P_AddMasterFader(ffloor_t *rover, size_t sectornum, size_t ffloornum,
+static void P_AddFakeFloorFader(ffloor_t *rover, size_t sectornum, size_t ffloornum,
 	INT16 destvalue, INT16 speed,
-	boolean doexists, boolean dotranslucent, boolean dosolid, boolean dospawnflags,
-	boolean doghostfade)
+	boolean doexists, boolean dotranslucent, boolean docollision, boolean doghostfade, boolean exactalpha)
 {
 	fade_t *d = Z_Malloc(sizeof *d, PU_LEVSPEC, NULL);
 
@@ -7372,12 +7367,12 @@ static void P_AddMasterFader(ffloor_t *rover, size_t sectornum, size_t ffloornum
 	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->docollision = docollision;
 	d->doghostfade = doghostfade;
+	d->exactalpha = exactalpha;
 
 	// find any existing thinkers and remove them, then replace with new data
-	P_ResetFading(rover, d);
+	P_ResetFakeFloorFader(rover, d);
 
 	P_AddThinker(&d->thinker);
 }
@@ -7385,12 +7380,12 @@ static void P_AddMasterFader(ffloor_t *rover, size_t sectornum, size_t ffloornum
 /** Makes a FOF fade
   *
   * \param d Fade thinker.
-  * \sa P_AddMasterFader
+  * \sa P_AddFakeFloorFader
   */
 void T_Fade(fade_t *d)
 {
-	if (d->rover && !P_DoFakeFloorAlpha(d->rover, d->destvalue, d->speed, d->doexists, d->dotranslucent, d->dosolid, d->dospawnflags, d->doghostfade))
-		P_RemoveFading(d->rover);
+	if (d->rover && !P_FadeFakeFloor(d->rover, d->destvalue, d->speed, d->doexists, d->dotranslucent, d->docollision, d->doghostfade, d->exactalpha))
+		P_RemoveFakeFloorFader(d->rover);
 }
 
 /*
diff --git a/src/p_spec.h b/src/p_spec.h
index fcced9cea..b4e9594d2 100644
--- a/src/p_spec.h
+++ b/src/p_spec.h
@@ -458,11 +458,11 @@ typedef struct
 	INT32 ffloornum;    ///< Number of ffloor of target sector
 	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
+	boolean doexists;   ///< Handle FF_EXISTS
+	boolean dotranslucent; ///< Handle FF_TRANSLUCENT
+	boolean docollision; ///< Handle interactive flags
+	boolean doghostfade; ///< No interactive flags during fading
+	boolean exactalpha; ///< Use exact alpha values (opengl)
 } fade_t;
 
 void T_Fade(fade_t *d);

From bf5efe645778f71a496a8f884f23b3514cc1ba74 Mon Sep 17 00:00:00 2001
From: mazmazz <mar.marcoz@outlook.com>
Date: Fri, 17 Aug 2018 15:59:34 -0400
Subject: [PATCH 5/6] Cleanup fade fake floor code

---
 src/p_spec.c | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/src/p_spec.c b/src/p_spec.c
index 4694eb015..ec07003bd 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -7282,19 +7282,14 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 		{
 			if (rover->alpha >= 256)
 			{
-				//rover->flags |= FF_CUTLEVEL;
+				//rover->flags |= (FF_CUTLEVEL | FF_CUTEXTRA);
 				rover->flags &= ~FF_TRANSLUCENT;
 			}
 			else
 			{
 				rover->flags |= FF_TRANSLUCENT;
-				//rover->flags &= ~FF_CUTLEVEL;
+				//rover->flags &= ~(FF_CUTLEVEL | FF_CUTEXTRA);
 			}
-
-			// if (rover->flags & FF_SOLID)
-			// 	rover->flags &= ~FF_CUTSPRITES;
-			// else
-			// 	rover->flags |= FF_CUTSPRITES;
 		}
 	}
 	else
@@ -7305,17 +7300,12 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 		if (dotranslucent)
 		{
 			rover->flags |= FF_TRANSLUCENT;
-			//rover->flags &= ~FF_CUTLEVEL;
-
-			// if (rover->flags & FF_SOLID)
-			// 	rover->flags &= ~FF_CUTSPRITES;
-			// else
-			// 	rover->flags |= FF_CUTSPRITES;
+			//rover->flags &= ~(FF_CUTLEVEL | FF_CUTEXTRA);
 		}
 
 		if (docollision)
 		{
-			if (doghostfade) // remove interaction flags during fade
+			if (doghostfade) // remove collision flags during fade
 			{
 				if (rover->spawnflags & FF_SOLID)
 					rover->flags &= ~FF_SOLID;
@@ -7326,7 +7316,7 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 				if (rover->spawnflags & FF_BUSTUP)
 					rover->flags &= ~FF_BUSTUP;
 			}
-			else // keep interaction during fade
+			else // keep collision during fade
 			{
 				if (rover->spawnflags & FF_SOLID)
 					rover->flags |= FF_SOLID;

From d94608fa101f56a2b1e5a22d34b8ff7184154282 Mon Sep 17 00:00:00 2001
From: mazmazz <mar.marcoz@outlook.com>
Date: Fri, 17 Aug 2018 16:27:32 -0400
Subject: [PATCH 6/6] Add alpha clamping so OpenGL conforms to Software's
 translucent levels

---
 src/p_saveg.c |  2 ++
 src/p_spec.c  | 59 ++++++++++++++++++++++++++++++++++++++++++---------
 src/p_spec.h  |  1 +
 3 files changed, 52 insertions(+), 10 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index c2158aa0d..c1af4167b 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -1568,6 +1568,7 @@ static void SaveFadeThinker(const thinker_t *th, const UINT8 type)
 	WRITEUINT8(save_p, type);
 	WRITEINT32(save_p, ht->sectornum);
 	WRITEINT32(save_p, ht->ffloornum);
+	WRITEINT32(save_p, ht->alpha);
 	WRITEINT16(save_p, ht->destvalue);
 	WRITEINT16(save_p, ht->speed);
 	WRITEUINT8(save_p, ht->doexists);
@@ -2571,6 +2572,7 @@ static inline void LoadFadeThinker(actionf_p1 thinker)
 	ht->thinker.function.acp1 = thinker;
 	ht->sectornum = READINT32(save_p);
 	ht->ffloornum = READINT32(save_p);
+	ht->alpha = READINT32(save_p);
 	ht->destvalue = READINT16(save_p);
 	ht->speed = READINT16(save_p);
 	ht->doexists = READUINT8(save_p);
diff --git a/src/p_spec.c b/src/p_spec.c
index ec07003bd..50cf049ff 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -7212,16 +7212,23 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 	boolean doexists, boolean dotranslucent, boolean docollision, boolean doghostfade, boolean exactalpha)
 {
 	boolean stillfading = false;
+	INT32 alpha;
+	fade_t *fadingdata = (fade_t *)rover->fadingdata;
+
+	if (fadingdata)
+		alpha = fadingdata->alpha;
+	else
+		alpha = rover->alpha;
 
 	// routines specific to fade in and fade out
-	if (rover->alpha == destvalue)
+	if (alpha == destvalue)
 		return stillfading;
-	else if (rover->alpha > destvalue) // fade out
+	else if (alpha > destvalue) // fade out
 	{
 		// finish fading out
-		if (speed < 1 || rover->alpha - speed <= destvalue + speed)
+		if (speed < 1 || alpha - speed <= destvalue + speed)
 		{
-			rover->alpha = destvalue;
+			alpha = destvalue;
 
 			if (docollision)
 			{
@@ -7237,16 +7244,16 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 		}
 		else // continue fading out
 		{
-			rover->alpha -= speed;
+			alpha -= speed;
 			stillfading = true;
 		}
 	}
 	else // fade in
 	{
 		// finish fading in
-		if (speed < 1 || rover->alpha + speed >= destvalue - speed)
+		if (speed < 1 || alpha + speed >= destvalue - speed)
 		{
-			rover->alpha = destvalue;
+			alpha = destvalue;
 
 			if (docollision)
 			{
@@ -7262,7 +7269,7 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 		}
 		else // continue fading in
 		{
-			rover->alpha += speed;
+			alpha += speed;
 			stillfading = true;
 		}
 	}
@@ -7272,7 +7279,7 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 	{
 		if (doexists)
 		{
-			if (rover->alpha <= 1)
+			if (alpha <= 1)
 				rover->flags &= ~FF_EXISTS;
 			else
 				rover->flags |= FF_EXISTS;
@@ -7280,7 +7287,7 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 
 		if (dotranslucent)
 		{
-			if (rover->alpha >= 256)
+			if (alpha >= 256)
 			{
 				//rover->flags |= (FF_CUTLEVEL | FF_CUTEXTRA);
 				rover->flags &= ~FF_TRANSLUCENT;
@@ -7330,6 +7337,37 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 destvalue, INT16 speed,
 		}
 	}
 
+	if (!stillfading || exactalpha)
+		rover->alpha = alpha;
+	else // clamp fadingdata->alpha to software's alpha levels
+	{
+		if (alpha < 12)
+			rover->alpha = destvalue < 12 ? destvalue : 1; // Don't even draw it
+		else if (alpha < 38)
+			rover->alpha = destvalue >= 12 && destvalue < 38 ? destvalue : 25;
+		else if (alpha < 64)
+			rover->alpha = destvalue >=38 && destvalue < 64 ? destvalue : 51;
+		else if (alpha < 89)
+			rover->alpha = destvalue >= 64 && destvalue < 89 ? destvalue : 76;
+		else if (alpha < 115)
+			rover->alpha = destvalue >= 89 && destvalue < 115 ? destvalue : 102;
+		else if (alpha < 140)
+			rover->alpha = destvalue >= 115 && destvalue < 140 ? destvalue : 128;
+		else if (alpha < 166)
+			rover->alpha = destvalue >= 140 && destvalue < 166 ? destvalue : 154;
+		else if (alpha < 192)
+			rover->alpha = destvalue >= 166 && destvalue < 192 ? destvalue : 179;
+		else if (alpha < 217)
+			rover->alpha = destvalue >= 192 && destvalue < 217 ? destvalue : 204;
+		else if (alpha < 243)
+			rover->alpha = destvalue >= 217 && destvalue < 243 ? destvalue : 230;
+		else // Opaque
+			rover->alpha = destvalue >= 243 ? destvalue : 256;
+	}
+
+	if (fadingdata)
+		fadingdata->alpha = alpha;
+
 	return stillfading;
 }
 
@@ -7353,6 +7391,7 @@ static void P_AddFakeFloorFader(ffloor_t *rover, size_t sectornum, size_t ffloor
 	d->rover = rover;
 	d->sectornum = (INT32)sectornum;
 	d->ffloornum = (INT32)ffloornum;
+	d->alpha = rover->alpha;
 	d->destvalue = max(1, min(256, destvalue)); // ffloor->alpha is 1-256
 	d->speed = max(1, speed); // minimum speed 1/tic // if speed < 1, alpha is set immediately in thinker
 	d->doexists = doexists;
diff --git a/src/p_spec.h b/src/p_spec.h
index b4e9594d2..dc2ab0e6a 100644
--- a/src/p_spec.h
+++ b/src/p_spec.h
@@ -456,6 +456,7 @@ typedef struct
 	ffloor_t *rover;    ///< Target ffloor
 	INT32 sectornum;    ///< Number of ffloor target sector
 	INT32 ffloornum;    ///< Number of ffloor of target sector
+	INT32 alpha;        ///< Internal alpha counter
 	INT16 destvalue;    ///< Transparency value to fade to
 	INT16 speed;        ///< Speed to fade by
 	boolean doexists;   ///< Handle FF_EXISTS