Merge branch 'master' of https://github.com/coelckers/gzdoom

# Conflicts:
#	src/r_bsp.cpp
#	src/r_main.cpp
#	src/r_things.cpp

src/d_player.h

@@ -169,6 +169,9 @@ public:
 	// [CW] Fades for when you are being damaged.
 	PalEntry DamageFade;
 
+	// [SP] ViewBob Multiplier
+	double		ViewBob;
+
 	bool UpdateWaterLevel (bool splash);
 	bool ResetAirSupply (bool playgasp = true);
 

src/gl/dynlights/gl_dynlight.cpp

@@ -1082,6 +1082,7 @@ void gl_AttachLight(AActor *actor, unsigned int count, const FLightDefaults *lig
 		light->target = actor;
 		light->owned = true;
 		light->ObjectFlags |= OF_Transient;
+		light->flags4 |= MF4_ATTENUATE;
 		actor->dynamiclights.Push(light);
 	}
 	light->flags2&=~MF2_DORMANT;

src/gl/dynlights/gl_dynlight.h

@@ -50,6 +50,7 @@ enum
 #define MF4_SUBTRACTIVE MF4_MISSILEEVENMORE
 #define MF4_ADDITIVE MF4_MISSILEMORE
 #define MF4_DONTLIGHTSELF MF4_SEESDAGGERS
+#define MF4_ATTENUATE MF4_INCOMBAT
 
 enum ELightType
 {

src/gl/dynlights/gl_dynlight1.cpp

@@ -116,7 +116,7 @@ bool gl_GetLight(int group, Plane & p, ADynamicLight * light, bool checkside, FD
 	data[4] = r;
 	data[5] = g;
 	data[6] = b;
-	data[7] = 0;
+	data[7] = !!(light->flags4 & MF4_ATTENUATE);
 	return true;
 }
 

src/gl/scene/gl_drawinfo.cpp

@@ -536,7 +536,7 @@ void GLDrawList::SortSpriteIntoWall(SortNode * head,SortNode * sort)
 
 		const bool drawBillboardFacingCamera = gl_billboard_faces_camera;
 		// [Nash] has +ROLLSPRITE
-		const bool rotated = (ss->actor != nullptr && ss->actor->renderflags & RF_ROLLSPRITE | RF_WALLSPRITE | RF_FLATSPRITE);
+		const bool rotated = (ss->actor != nullptr && ss->actor->renderflags & (RF_ROLLSPRITE | RF_WALLSPRITE | RF_FLATSPRITE));
 
 		// cannot sort them at the moment. This requires more complex splitting.
 		if (drawWithXYBillboard || drawBillboardFacingCamera || rotated)

src/gl/scene/gl_wall.h

@@ -66,7 +66,7 @@ struct GLSeg
 		// we do not use the vector math inlines here because they are not optimized for speed but accuracy in the playsim
 		float x = y2 - y1;
 		float y = x1 - x2;
-		float length = sqrt(x*x + y*y);
+		float length = sqrtf(x*x + y*y);
 		return FVector3(x / length, 0, y / length);
 	}
 };

src/p_acs.cpp

@@ -2907,7 +2907,8 @@ FSerializer &Serialize(FSerializer &arc, const char *key, SavingRunningscript &r
 void DACSThinker::Serialize(FSerializer &arc)
 {
 	Super::Serialize(arc);
-	arc("scripts", Scripts);
+	arc("scripts", Scripts)
+		("lastscript", LastScript);
 
 	if (arc.isWriting())
 	{

src/p_pspr.cpp

@@ -582,8 +582,9 @@ void P_BobWeapon (player_t *player, float *x, float *y, double ticfrac)
 
 		if (curbob != 0)
 		{
-			float bobx = float(player->bob * Rangex);
+			//[SP] Added in decorate player.viewbob checks
-			float boby = float(player->bob * Rangey);
+			float bobx = float(player->bob * Rangex * (float)player->mo->ViewBob);
+			float boby = float(player->bob * Rangey * (float)player->mo->ViewBob);
 			switch (bobstyle)
 			{
 			case AWeapon::BobNormal:

src/p_saveg.cpp

@@ -640,6 +640,12 @@ static void ReadOnePlayer(FSerializer &arc, bool skipload)
 					playerTemp.Serialize(arc);
 					if (!skipload)
 					{
+						// This temp player has undefined pitch limits, so set them to something
+						// that should leave the pitch stored in the savegame intact when
+						// rendering. The real pitch limits will be set by P_SerializePlayers()
+						// via a net command, but that won't be processed in time for a screen
+						// wipe, so we need something here.
+						playerTemp.MaxPitch = playerTemp.MinPitch = playerTemp.mo->Angles.Pitch;
 						CopyPlayer(&players[i], &playerTemp, name);
 					}
 					else

src/p_user.cpp

@@ -652,7 +652,8 @@ void APlayerPawn::Serialize(FSerializer &arc)
 		("fallingscreammaxn", FallingScreamMaxSpeed, def->FallingScreamMaxSpeed)
 		("userange", UseRange, def->UseRange)
 		("aircapacity", AirCapacity, def->AirCapacity)
-		("viewheight", ViewHeight, def->ViewHeight);
+		("viewheight", ViewHeight, def->ViewHeight)
+		("viewbob", ViewBob, def->ViewBob);
 }
 
 //===========================================================================
@@ -1892,7 +1893,7 @@ void P_CalcHeight (player_t *player)
 	{
 		bob = 0;
 	}
-	player->viewz = player->mo->Z() + player->viewheight + bob;
+	player->viewz = player->mo->Z() + player->viewheight + (bob * player->mo->ViewBob); // [SP] Allow DECORATE changes to view bobbing speed.
 	if (player->mo->Floorclip && player->playerstate != PST_DEAD
 		&& player->mo->Z() <= player->mo->floorz)
 	{

src/portal.cpp

@@ -1022,7 +1022,8 @@ void P_CreateLinkedPortals()
 		{
 			if (sectors[i].GetPortalType(j) == PORTS_LINKEDPORTAL && sectors[i].PortalGroup == 0)
 			{
-				CollectSectors(sectors[i].GetOppositePortalGroup(j), &sectors[i]);
+				auto p = sectors[i].GetPortal(j);
+				CollectSectors(p->mOrigin->PortalGroup, &sectors[i]);
 			}
 		}
 	}

src/r_data/colormaps.cpp

@@ -59,6 +59,7 @@ static bool R_CheckForFixedLights(const BYTE *colormaps);
 
 extern "C" {
 FDynamicColormap NormalLight;
+FDynamicColormap FullNormalLight; //[SP] Emulate GZDoom brightness
 }
 bool NormalLightHasFixedLights;
 
@@ -72,6 +73,7 @@ struct FakeCmap
 
 TArray<FakeCmap> fakecmaps;
 BYTE *realcolormaps;
+BYTE *realfbcolormaps; //[SP] For fullbright use
 size_t numfakecmaps;
 
 
@@ -459,6 +461,11 @@ void R_DeinitColormaps ()
 		delete[] realcolormaps;
 		realcolormaps = NULL;
 	}
+	if (realfbcolormaps != NULL)
+	{
+		delete[] realfbcolormaps;
+		realfbcolormaps = NULL;
+	}
 	FreeSpecialLights();
 }
 
@@ -548,9 +555,20 @@ void R_InitColormaps ()
 			}
 		}
 	}
+
+	// [SP] Create a copy of the colormap
+	if (!realfbcolormaps)
+	{
+		realfbcolormaps = new BYTE[256*NUMCOLORMAPS*fakecmaps.Size()];
+		memcpy(realfbcolormaps, realcolormaps, 256*NUMCOLORMAPS*fakecmaps.Size());
+	}
+
 	NormalLight.Color = PalEntry (255, 255, 255);
 	NormalLight.Fade = 0;
 	NormalLight.Maps = realcolormaps;
+	FullNormalLight.Color = PalEntry (255, 255, 255);
+	FullNormalLight.Fade = 0;
+	FullNormalLight.Maps = realfbcolormaps;
 	NormalLightHasFixedLights = R_CheckForFixedLights(realcolormaps);
 	numfakecmaps = fakecmaps.Size();
 

src/r_data/colormaps.h

@@ -80,6 +80,7 @@ extern BYTE DesaturateColormap[31][256];
 extern "C" 
 {
 extern FDynamicColormap NormalLight;
+extern FDynamicColormap FullNormalLight;
 }
 extern bool NormalLightHasFixedLights;
 

src/r_segs.cpp

@@ -57,6 +57,7 @@
 
 
 CVAR(Bool, r_np2, true, 0)
+EXTERN_CVAR(Bool, r_fullbrightignoresectorcolor);
 
 //CVAR (Int, ty, 8, 0)
 //CVAR (Int, tx, 8, 0)
@@ -313,7 +314,7 @@ void R_RenderMaskedSegRange (drawseg_t *ds, int x1, int x2)
 	rw_scalestep = ds->iscalestep;
 
 	if (fixedlightlev >= 0)
-		dc_colormap = basecolormap->Maps + fixedlightlev;
+		dc_colormap = (r_fullbrightignoresectorcolor) ? (FullNormalLight.Maps + fixedlightlev) : (basecolormap->Maps + fixedlightlev);
 	else if (fixedcolormap != NULL)
 		dc_colormap = fixedcolormap;
 
@@ -630,7 +631,7 @@ void R_RenderFakeWall(drawseg_t *ds, int x1, int x2, F3DFloor *rover)
 	}
 
 	if (fixedlightlev >= 0)
-		dc_colormap = basecolormap->Maps + fixedlightlev;
+		dc_colormap = (r_fullbrightignoresectorcolor) ? (FullNormalLight.Maps + fixedlightlev) : (basecolormap->Maps + fixedlightlev);
 	else if (fixedcolormap != NULL)
 		dc_colormap = fixedcolormap;
 
@@ -1788,7 +1789,7 @@ void R_RenderSegLoop ()
 	fixed_t xoffset = rw_offset;
 
 	if (fixedlightlev >= 0)
-		dc_colormap = basecolormap->Maps + fixedlightlev;
+		dc_colormap = (r_fullbrightignoresectorcolor) ? (FullNormalLight.Maps + fixedlightlev) : (basecolormap->Maps + fixedlightlev);
 	else if (fixedcolormap != NULL)
 		dc_colormap = fixedcolormap;
 
@@ -3185,13 +3186,13 @@ static void R_RenderDecal (side_t *wall, DBaseDecal *decal, drawseg_t *clipper,
 		rereadcolormap = false;
 	}
 
-	rw_light = rw_lightleft + (x1 - WallC.sx1) * rw_lightstep;
+	rw_light = rw_lightleft + (x1 - savecoord.sx1) * rw_lightstep;
 	if (fixedlightlev >= 0)
-		dc_colormap = usecolormap->Maps + fixedlightlev;
+		dc_colormap = (r_fullbrightignoresectorcolor) ? (FullNormalLight.Maps + fixedlightlev) : (usecolormap->Maps + fixedlightlev);
 	else if (fixedcolormap != NULL)
 		dc_colormap = fixedcolormap;
 	else if (!foggy && (decal->RenderFlags & RF_FULLBRIGHT))
-		dc_colormap = usecolormap->Maps;
+		dc_colormap = (r_fullbrightignoresectorcolor) ? FullNormalLight.Maps : usecolormap->Maps;
 	else
 		calclighting = true;
 

src/r_sky.cpp

@@ -77,10 +77,20 @@ void R_InitSkyMap ()
 	int skyheight;
 	FTexture *skytex1, *skytex2;
 
+	// Do not allow the null texture which has no bitmap and will crash.
+	if (sky1texture.isNull())
+	{
+		sky1texture = TexMan.CheckForTexture("-noflat-", FTexture::TEX_Any);
+	}
+	if (sky2texture.isNull())
+	{
+		sky2texture = TexMan.CheckForTexture("-noflat-", FTexture::TEX_Any);
+	}
+
 	skytex1 = TexMan(sky1texture, true);
 	skytex2 = TexMan(sky2texture, true);
 
-	if (skytex1 == NULL)
+	if (skytex1 == nullptr)
 		return;
 
 	if ((level.flags & LEVEL_DOUBLESKY) && skytex1->GetHeight() != skytex2->GetHeight())

src/textures/animations.cpp

@@ -1002,7 +1002,7 @@ void FTextureManager::UpdateAnimations (DWORD mstime)
 
 template<> FSerializer &Serialize(FSerializer &arc, const char *key, FDoorAnimation *&p, FDoorAnimation **def)
 {
-	FTextureID tex = p->BaseTexture;
+	FTextureID tex = p? p->BaseTexture : FNullTextureID();
 	Serialize(arc, key, tex, def ? &(*def)->BaseTexture : nullptr);
 	if (arc.isReading())
 	{

src/textures/multipatchtexture.cpp

@@ -48,6 +48,7 @@
 #include "v_palette.h"
 #include "v_video.h"
 #include "v_text.h"
+#include "cmdlib.h"
 #include "m_fixed.h"
 #include "textures/textures.h"
 #include "r_data/colormaps.h"
@@ -138,7 +139,6 @@ struct strifemaptexture_t
 struct FPatchLookup
 {
 	FString Name;
-	FTexture *Texture;
 };
 
 
@@ -166,6 +166,7 @@ public:
 	int GetSourceLump() { return DefinitionLump; }
 	FTexture *GetRedirect(bool wantwarped);
 	FTexture *GetRawTexture();
+	void ResolvePatches();
 
 protected:
 	BYTE *Pixels;
@@ -185,8 +186,18 @@ protected:
 		TexPart();
 	};
 
+	struct TexInit
+	{
+		FString TexName;
+		int UseType = TEX_Null;
+		bool Silent = false;
+		bool HasLine = false;
+		FScriptPosition sc;
+	};
+
 	int NumParts;
 	TexPart *Parts;
+	TexInit *Inits;
 	bool bRedirect:1;
 	bool bTranslucentPatches:1;
 
@@ -194,7 +205,7 @@ protected:
 
 private:
 	void CheckForHacks ();
-	void ParsePatch(FScanner &sc, TexPart & part, bool silent, int usetype);
+	void ParsePatch(FScanner &sc, TexPart & part, TexInit &init);
 };
 
 //==========================================================================
@@ -204,7 +215,7 @@ private:
 //==========================================================================
 
 FMultiPatchTexture::FMultiPatchTexture (const void *texdef, FPatchLookup *patchlookup, int maxpatchnum, bool strife, int deflumpnum)
-: Pixels (0), Spans(0), Parts(0), bRedirect(false), bTranslucentPatches(false)
+: Pixels (0), Spans(0), Parts(nullptr), Inits(nullptr), bRedirect(false), bTranslucentPatches(false)
 {
 	union
 	{
@@ -240,7 +251,8 @@ FMultiPatchTexture::FMultiPatchTexture (const void *texdef, FPatchLookup *patchl
 	}
 
 	UseType = FTexture::TEX_Wall;
-	Parts = NumParts > 0 ? new TexPart[NumParts] : NULL;
+	Parts = NumParts > 0 ? new TexPart[NumParts] : nullptr;
+	Inits = NumParts > 0 ? new TexInit[NumParts] : nullptr;
 	Width = SAFESHORT(mtexture.d->width);
 	Height = SAFESHORT(mtexture.d->height);
 	Name = (char *)mtexture.d->name;
@@ -272,17 +284,9 @@ FMultiPatchTexture::FMultiPatchTexture (const void *texdef, FPatchLookup *patchl
 		}
 		Parts[i].OriginX = LittleShort(mpatch.d->originx);
 		Parts[i].OriginY = LittleShort(mpatch.d->originy);
-		Parts[i].Texture = patchlookup[LittleShort(mpatch.d->patch)].Texture;
+		Parts[i].Texture = nullptr;
-		if (Parts[i].Texture == NULL)
+		Inits[i].TexName = patchlookup[LittleShort(mpatch.d->patch)].Name;
-		{
+		Inits[i].UseType = TEX_WallPatch;
-			Printf(TEXTCOLOR_RED "Unknown patch %s in texture %s\n", patchlookup[LittleShort(mpatch.d->patch)].Name.GetChars(), Name.GetChars());
-			NumParts--;
-			i--;
-		}
-		else
-		{
-			Parts[i].Texture->bKeepAround = true;
-		}
 		if (strife)
 			mpatch.s++;
 		else
@@ -295,17 +299,6 @@ FMultiPatchTexture::FMultiPatchTexture (const void *texdef, FPatchLookup *patchl
 
 	CheckForHacks ();
 
-	// If this texture is just a wrapper around a single patch, we can simply
-	// forward GetPixels() and GetColumn() calls to that patch.
-	if (NumParts == 1)
-	{
-		if (Parts->OriginX == 0 && Parts->OriginY == 0 &&
-			Parts->Texture->GetWidth() == Width &&
-			Parts->Texture->GetHeight() == Height)
-		{
-			bRedirect = true;
-		}
-	}
 	DefinitionLump = deflumpnum;
 }
 
@@ -327,6 +320,11 @@ FMultiPatchTexture::~FMultiPatchTexture ()
 		delete[] Parts;
 		Parts = NULL;
 	}
+	if (Inits != nullptr)
+	{
+		delete[] Inits;
+		Inits = nullptr;
+	}
 	if (Spans != NULL)
 	{
 		FreeSpans (Spans);
@@ -864,19 +862,6 @@ void FTextureManager::AddTexturesLump (const void *lumpdata, int lumpsize, int d
 			pnames.Read(pname, 8);
 			pname[8] = '\0';
 			patchlookup[i].Name = pname;
-			FTextureID j = CheckForTexture (patchlookup[i].Name, FTexture::TEX_WallPatch);
-			if (j.isValid())
-			{
-				patchlookup[i].Texture = Textures[j.GetIndex()].Texture;
-			}
-			else
-			{
-				// Shareware Doom has the same PNAMES lump as the registered
-				// Doom, so printing warnings for patches that don't really
-				// exist isn't such a good idea.
-				//Printf ("Patch %s not found.\n", patchlookup[i].Name);
-				patchlookup[i].Texture = NULL;
-			}
 		}
 	}
 
@@ -997,35 +982,13 @@ void FTextureManager::AddTexturesLumps (int lump1, int lump2, int patcheslump)
 //
 //==========================================================================
 
-void FMultiPatchTexture::ParsePatch(FScanner &sc, TexPart & part, bool silent, int usetype)
+void FMultiPatchTexture::ParsePatch(FScanner &sc, TexPart & part, TexInit &init)
 {
 	FString patchname;
+	int Mirror = 0;
 	sc.MustGetString();
 
-	FTextureID texno = TexMan.CheckForTexture(sc.String, usetype);
+	init.TexName = sc.String;
-	int Mirror = 0;
-
-	if (!texno.isValid())
-	{
-		if (strlen(sc.String) <= 8 && !strpbrk(sc.String, "./"))
-		{
-			int lumpnum = Wads.CheckNumForName(sc.String, usetype == TEX_MiscPatch? ns_graphics : ns_patches);
-			if (lumpnum >= 0)
-			{
-				part.Texture = FTexture::CreateTexture(lumpnum, usetype);
-				TexMan.AddTexture(part.Texture);
-			}
-		}
-	}
-	else
-	{
-		part.Texture = TexMan[texno];
-		bComplex |= part.Texture->bComplex;
-	}
-	if (part.Texture == NULL)
-	{
-		if (!silent) sc.ScriptMessage(TEXTCOLOR_RED "Unknown patch '%s' in texture '%s'\n", sc.String, Name.GetChars());
-	}
 	sc.MustGetStringName(",");
 	sc.MustGetNumber();
 	part.OriginX = sc.Number;
@@ -1208,6 +1171,7 @@ FMultiPatchTexture::FMultiPatchTexture (FScanner &sc, int usetype)
 : Pixels (0), Spans(0), Parts(0), bRedirect(false), bTranslucentPatches(false)
 {
 	TArray<TexPart> parts;
+	TArray<TexInit> inits;
 	bool bSilent = false;
 
 	bMultiPatch = true;
@@ -1268,16 +1232,51 @@ FMultiPatchTexture::FMultiPatchTexture (FScanner &sc, int usetype)
 			else if (sc.Compare("Patch"))
 			{
 				TexPart part;
-				ParsePatch(sc, part, bSilent, TEX_WallPatch);
+				TexInit init;
-				if (part.Texture != NULL) parts.Push(part);
+				ParsePatch(sc, part, init);
+				if (init.TexName.IsNotEmpty())
+				{
+					parts.Push(part);
+					init.UseType = TEX_WallPatch;
+					init.Silent = bSilent;
+					init.HasLine = true;
+					init.sc = sc;
+					inits.Push(init);
+				}
+				part.Texture = NULL;
+				part.Translation = NULL;
+			}
+			else if (sc.Compare("Sprite"))
+			{
+				TexPart part;
+				TexInit init;
+				ParsePatch(sc, part, init);
+				if (init.TexName.IsNotEmpty())
+				{
+					parts.Push(part);
+					init.UseType = TEX_Sprite;
+					init.Silent = bSilent;
+					init.HasLine = true;
+					init.sc = sc;
+					inits.Push(init);
+				}
 				part.Texture = NULL;
 				part.Translation = NULL;
 			}
 			else if (sc.Compare("Graphic"))
 			{
 				TexPart part;
-				ParsePatch(sc, part, bSilent, TEX_MiscPatch);
+				TexInit init;
-				if (part.Texture != NULL) parts.Push(part);
+				ParsePatch(sc, part, init);
+				if (init.TexName.IsNotEmpty())
+				{
+					parts.Push(part);
+					init.UseType = TEX_MiscPatch;
+					init.Silent = bSilent;
+					init.HasLine = true;
+					init.sc = sc;
+					inits.Push(init);
+				}
 				part.Texture = NULL;
 				part.Translation = NULL;
 			}
@@ -1298,21 +1297,10 @@ FMultiPatchTexture::FMultiPatchTexture (FScanner &sc, int usetype)
 		NumParts = parts.Size();
 		Parts = new TexPart[NumParts];
 		memcpy(Parts, &parts[0], NumParts * sizeof(*Parts));
-
+		Inits = new TexInit[NumParts];
-		//CalcBitSize ();
+		for (int i = 0; i < NumParts; i++)
-
-		// If this texture is just a wrapper around a single patch, we can simply
-		// forward GetPixels() and GetColumn() calls to that patch.
-		if (NumParts == 1)
 		{
-			if (Parts->OriginX == 0 && Parts->OriginY == 0 &&
+			Inits[i] = inits[i];
-				Parts->Texture->GetWidth() == Width &&
-				Parts->Texture->GetHeight() == Height &&
-				Parts->Rotate == 0 && 
-				!bComplex)
-			{
-				bRedirect = true;
-			}
 		}
 	}
 	
@@ -1329,6 +1317,58 @@ FMultiPatchTexture::FMultiPatchTexture (FScanner &sc, int usetype)
 }
 
 
+void FMultiPatchTexture::ResolvePatches()
+{
+	if (Inits != nullptr)
+	{
+		for (int i = 0; i < NumParts; i++)
+		{
+			FTextureID texno = TexMan.CheckForTexture(Inits[i].TexName, Inits[i].UseType);
+
+			if (!texno.isValid())
+			{
+				if (!Inits[i].Silent)
+				{
+					if (Inits[i].HasLine) Inits[i].sc.Message(MSG_WARNING, "Unknown patch '%s' in texture '%s'\n", Inits[i].TexName.GetChars(), Name.GetChars());
+					else Printf(TEXTCOLOR_YELLOW  "Unknown patch '%s' in texture '%s'\n", Inits[i].TexName.GetChars(), Name.GetChars());
+				}
+			}
+			else
+			{
+				Parts[i].Texture = TexMan[texno];
+				bComplex |= Parts[i].Texture->bComplex;
+				Parts[i].Texture->bKeepAround = true;
+			}
+		}
+		for (int i = 0; i < NumParts; i++)
+		{
+			if (Parts[i].Texture == nullptr)
+			{
+				memcpy(&Parts[i], &Parts[i + 1], NumParts - i - 1);
+				i--;
+				NumParts--;
+			}
+		}
+	}
+	delete[] Inits;
+	Inits = nullptr;
+
+	// If this texture is just a wrapper around a single patch, we can simply
+	// forward GetPixels() and GetColumn() calls to that patch.
+
+	if (NumParts == 1)
+	{
+		if (Parts->OriginX == 0 && Parts->OriginY == 0 &&
+			Parts->Texture->GetWidth() == Width &&
+			Parts->Texture->GetHeight() == Height &&
+			Parts->Rotate == 0 &&
+			!bComplex)
+		{
+			bRedirect = true;
+		}
+	}
+}
+
 
 void FTextureManager::ParseXTexture(FScanner &sc, int usetype)
 {

src/textures/texturemanager.cpp

@@ -981,6 +981,10 @@ void FTextureManager::Init()
 	{
 		AddTexturesForWad(i);
 	}
+	for (unsigned i = 0; i < Textures.Size(); i++)
+	{
+		Textures[i].Texture->ResolvePatches();
+	}
 
 	// Add one marker so that the last WAD is easier to handle and treat
 	// Build tiles as a completely separate block.

src/textures/textures.h

@@ -232,6 +232,7 @@ public:
 	int GetScaledTopOffset () { int foo = int((TopOffset * 2) / Scale.Y); return (foo >> 1) + (foo & 1); }
 	double GetScaledLeftOffsetDouble() { return LeftOffset / Scale.X; }
 	double GetScaledTopOffsetDouble() { return TopOffset / Scale.Y; }
+	virtual void ResolvePatches() {}
 
 	virtual void SetFrontSkyLayer();
 

src/thingdef/thingdef_properties.cpp

@@ -2945,6 +2945,26 @@ DEFINE_CLASS_PROPERTY_PREFIX(player, weaponslot, ISsssssssssssssssssssssssssssss
 	}
 }
 
+//==========================================================================
+//
+// [SP] Player.Viewbob
+//
+//==========================================================================
+DEFINE_CLASS_PROPERTY_PREFIX(player, viewbob, F, PlayerPawn)
+{
+	PROP_DOUBLE_PARM(z, 0);
+	// [SP] Hard limits. This is to prevent terrywads from making players sick.
+	//   Remember - this messes with a user option who probably has it set a
+	//   certain way for a reason. I think a 1.5 limit is pretty generous, but
+	//   it may be safe to increase it. I really need opinions from people who
+	//   could be affected by this.
+	if (z < 0.0 || z > 1.5)
+	{
+		I_Error("ViewBob must be between 0.0 and 1.5.");
+	}
+	defaults->ViewBob = z;
+}
+
 //==========================================================================
 //
 //==========================================================================

src/zscript/vmexec.cpp

@@ -11,21 +11,21 @@
 
 #if COMPGOTO
 #define OP(x)	x
-#define NEXTOP	do { unsigned op = pc->op; a = pc->a; pc++; goto *ops[op]; } while(0)
+#define NEXTOP	do { pc++; unsigned op = pc->op; a = pc->a; goto *ops[op]; } while(0)
 #else
 #define OP(x)	case OP_##x
-#define NEXTOP	break
+#define NEXTOP	pc++; break
 #endif
 
 #define luai_nummod(a,b)        ((a) - floor((a)/(b))*(b))
 
-#define A				(pc[-1].a)
+#define A				(pc[0].a)
-#define B				(pc[-1].b)
+#define B				(pc[0].b)
-#define C				(pc[-1].c)
+#define C				(pc[0].c)
-#define Cs				(pc[-1].cs)
+#define Cs				(pc[0].cs)
-#define BC				(pc[-1].i16u)
+#define BC				(pc[0].i16u)
-#define BCs				(pc[-1].i16)
+#define BCs				(pc[0].i16)
-#define ABCs			(pc[-1].i24)
+#define ABCs			(pc[0].i24)
 #define JMPOFS(x)		((x)->i24)
 
 #define KC				(konstd[C])
@@ -48,8 +48,8 @@
 
 #define CMPJMP(test) \
 	if ((test) == (a & CMP_CHECK)) { \
-		assert(pc->op == OP_JMP); \
+		assert(pc[1].op == OP_JMP); \
-		pc += 1 + JMPOFS(pc); \
+		pc += 1 + JMPOFS(pc+1); \
 	} else { \
 		pc += 1; \
 	}

src/zscript/vmexec.h

@@ -52,11 +52,17 @@ begin:
 	{
 #if !COMPGOTO
 	VM_UBYTE op;
-	for(;;) switch(op = pc->op, a = pc->a, pc++, op)
+	for(;;) switch(op = pc->op, a = pc->a, op)
 #else
+	pc--;
 	NEXTOP;
 #endif
 	{
+#if !COMPGOTO
+	default:
+		assert(0 && "Undefined opcode hit");
+		NEXTOP;
+#endif
 	OP(LI):
 		ASSERTD(a);
 		reg.d[a] = BCs;
@@ -367,13 +373,13 @@ begin:
 		}
 		NEXTOP;
 	OP(JMP):
-		pc += JMPOFS(pc - 1);
+		pc += JMPOFS(pc);
 		NEXTOP;
 	OP(IJMP):
 		ASSERTD(a);
 		pc += (BCs + reg.d[a]);
-		assert(pc->op == OP_JMP);
+		assert(pc[1].op == OP_JMP);
-		pc += 1 + JMPOFS(pc);
+		pc += 1 + JMPOFS(pc+1);
 		NEXTOP;
 	OP(PARAMI):
 		assert(f->NumParam < sfunc->MaxParam);
@@ -490,7 +496,7 @@ begin:
 			VMReturn returns[MAX_RETURNS];
 			int numret;
 
-			FillReturns(reg, f, returns, pc, C);
+			FillReturns(reg, f, returns, pc+1, C);
 			if (call->Native)
 			{
 				numret = static_cast<VMNativeFunction *>(call)->NativeCall(stack, reg.param + f->NumParam - B, B, returns, C);
@@ -603,8 +609,8 @@ begin:
 		{
 			THROW(X_TOO_MANY_TRIES);
 		}
-		assert((pc + JMPOFS(pc - 1))->op == OP_CATCH);
+		assert((pc + JMPOFS(pc) + 1)->op == OP_CATCH);
-		exception_frames[try_depth++] = pc + JMPOFS(pc - 1);
+		exception_frames[try_depth++] = pc + JMPOFS(pc) + 1;
 		NEXTOP;
 	OP(UNTRY):
 		assert(a <= try_depth);
@@ -704,8 +710,8 @@ begin:
 			}
 			if (cmp == (a & CMP_CHECK))
 			{
-				assert(pc->op == OP_JMP);
+				assert(pc[1].op == OP_JMP);
-				pc += 1 + JMPOFS(pc);
+				pc += 1 + JMPOFS(pc+1);
 			}
 			else
 			{

wadsrc/static/actors/shared/player.txt

@@ -33,6 +33,7 @@ Actor PlayerPawn : Actor native
 	Player.MugShotMaxHealth 0
 	Player.FlechetteType "ArtiPoisonBag3"
 	Player.AirCapacity 1
+	Player.ViewBob 1
 	Obituary "$OB_MPDEFAULT"
 }
 

wadsrc/static/language.enu

@@ -1787,6 +1787,7 @@ DSPLYMNU_PICKUPFADE				= "Pickup Flash Intensity";
 DSPLYMNU_PALLETEHACK			= "DirectDraw palette hack"; // Not used
 DSPLYMNU_ATTACHEDSURFACES		= "Use attached surfaces"; // Not used
 DSPLYMNU_SKYMODE				= "Sky render mode";
+DSPLYMNU_GZDFULLBRIGHT			= "Fullbright overrides sector color";
 DSPLYMNU_DRAWFUZZ				= "Use fuzz effect";
 DSPLYMNU_TRANSSOUL				= "Lost Soul translucency";
 DSPLYMNU_FAKECONTRAST			= "Use fake contrast";

wadsrc/static/menudef.txt

@@ -696,6 +696,7 @@ OptionMenu "VideoOptions"
 	}
 	
 	Option "$DSPLYMNU_SKYMODE",					"r_skymode", "SkyModes"
+	Option "$DSPLYMNU_GZDFULLBRIGHT",			"r_fullbrightignoresectorcolor", "OnOff"
 	Option "$DSPLYMNU_DRAWFUZZ",				"r_drawfuzz", "Fuzziness"
 	Slider "$DSPLYMNU_TRANSSOUL",				"transsouls", 0.25, 1.0, 0.05, 2
 	Option "$DSPLYMNU_FAKECONTRAST",			"r_fakecontrast", "Contrast"

wadsrc/static/shaders/glsl/main.fp

@@ -142,16 +142,19 @@ float diffuseContribution(vec3 lightDirection, vec3 normal)
 //
 //===========================================================================
 
-float pointLightAttenuation(vec4 lightpos)
+float pointLightAttenuation(vec4 lightpos, float attenuate)
 {
 	float attenuation = max(lightpos.w - distance(pixelpos.xyz, lightpos.xyz),0.0) / lightpos.w;
-	#if 0
+	if (attenuate == 0.0)
+	{
 		return attenuation;
-	#else
+	}
+	else
+	{
 		vec3 lightDirection = normalize(lightpos.xyz - pixelpos.xyz);
 		float diffuseAmount = diffuseContribution(lightDirection, normalize(vWorldNormal.xyz));
 		return attenuation * diffuseAmount;
-	#endif
+	}
 }
 
 //===========================================================================
@@ -229,7 +232,7 @@ vec4 getLightColor(float fogdist, float fogfactor)
 				vec4 lightpos = lights[i];
 				vec4 lightcolor = lights[i+1];
 				
-				lightcolor.rgb *= pointLightAttenuation(lightpos);
+				lightcolor.rgb *= pointLightAttenuation(lightpos, lightcolor.a);
 				dynlight.rgb += lightcolor.rgb;
 			}
 			//
@@ -240,7 +243,7 @@ vec4 getLightColor(float fogdist, float fogfactor)
 				vec4 lightpos = lights[i];
 				vec4 lightcolor = lights[i+1];
 				
-				lightcolor.rgb *= pointLightAttenuation(lightpos);
+				lightcolor.rgb *= pointLightAttenuation(lightpos, lightcolor.a);
 				dynlight.rgb -= lightcolor.rgb;
 			}
 		}
@@ -322,7 +325,7 @@ void main()
 						vec4 lightpos = lights[i];
 						vec4 lightcolor = lights[i+1];
 						
-						lightcolor.rgb *= pointLightAttenuation(lightpos);
+						lightcolor.rgb *= pointLightAttenuation(lightpos, lightcolor.a);
 						addlight.rgb += lightcolor.rgb;
 					}
 					frag.rgb = clamp(frag.rgb + desaturate(addlight).rgb, 0.0, 1.0);