diff --git a/src/g_level.cpp b/src/g_level.cpp
index a0e380b086..928c9ab130 100644
--- a/src/g_level.cpp
+++ b/src/g_level.cpp
@@ -123,10 +123,11 @@ CUSTOM_CVAR(Bool, gl_notexturefill, false, CVAR_NOINITCALL)
 CUSTOM_CVAR(Int, gl_lightmode, 3, CVAR_ARCHIVE | CVAR_NOINITCALL)
 {
 	int newself = self;
-	if (newself > 4) newself = 8;	// use 8 for software lighting to avoid conflicts with the bit mask
-	if (newself < 0) newself = 0;
+	if (newself > 8) newself = 16;	// use 8 and 16 for software lighting to avoid conflicts with the bit mask
+	else if (newself > 4) newself = 8;
+	else if (newself < 0) newself = 0;
 	if (self != newself) self = newself;
-	else if ((level.info == nullptr || level.info->lightmode == -1)) level.lightmode = self;
+	else if ((level.info == nullptr || level.info->lightmode == ELightMode::NotSet)) level.lightmode = (ELightMode)*self;
 }
 
 
@@ -1522,7 +1523,7 @@ void G_InitLevelLocals ()
 
 	level.DefaultEnvironment = info->DefaultEnvironment;
 
-	level.lightmode = info->lightmode < 0? gl_lightmode : info->lightmode;
+	level.lightmode = info->lightmode == ELightMode::NotSet? (ELightMode)*gl_lightmode : info->lightmode;
 	level.brightfog = info->brightfog < 0? gl_brightfog : !!info->brightfog;
 	level.lightadditivesurfaces = info->lightadditivesurfaces < 0 ? gl_lightadditivesurfaces : !!info->lightadditivesurfaces;
 	level.notexturefill = info->notexturefill < 0 ? gl_notexturefill : !!info->notexturefill;
diff --git a/src/g_level.h b/src/g_level.h
index a98a8d415a..f512287d36 100644
--- a/src/g_level.h
+++ b/src/g_level.h
@@ -314,6 +314,19 @@ struct FExitText
 	}
 };
 
+enum class ELightMode : int8_t
+{
+	NotSet = -1,
+	LinearStandard = 0,
+	DoomBright = 1,
+	Doom = 2,
+	DoomDark = 3,
+	DoomLegacy = 4,
+	ZDoomSoftware = 8,
+	DoomSoftware = 16
+};
+
+
 struct level_info_t
 {
 	int			levelnum;
@@ -395,7 +408,7 @@ struct level_info_t
 	
 	TArray<FString> EventHandlers;
 
-	int8_t		lightmode;
+	ELightMode	lightmode;
 	int8_t		brightfog;
 	int8_t		lightadditivesurfaces;
 	int8_t		notexturefill;
diff --git a/src/g_levellocals.h b/src/g_levellocals.h
index 2d76c39b27..c9eceabb69 100644
--- a/src/g_levellocals.h
+++ b/src/g_levellocals.h
@@ -48,9 +48,9 @@
 
 struct FLevelLocals
 {
-	void Tick ();
+	void Tick();
 	void Mark();
-	void AddScroller (int secnum);
+	void AddScroller(int secnum);
 	void SetInterMusic(const char *nextmap);
 	void SetMusicVolume(float v);
 
@@ -88,7 +88,7 @@ struct FLevelLocals
 	TArray<node_t> gamenodes;
 	node_t *headgamenode;
 	TArray<uint8_t> rejectmatrix;
-	
+
 	static const int BODYQUESIZE = 32;
 	TObjPtr<AActor*> bodyque[BODYQUESIZE];
 	int bodyqueslot;
@@ -101,7 +101,7 @@ struct FLevelLocals
 	FDisplacementTable Displacements;
 	FPortalBlockmap PortalBlockmap;
 	TArray<FLinePortal*> linkedPortals;	// only the linked portals, this is used to speed up looking for them in P_CollectConnectedGroups.
-	TArray<FSectorPortalGroup *> portalGroups;	
+	TArray<FSectorPortalGroup *> portalGroups;
 	TArray<FLinePortalSpan> linePortalSpans;
 	FSectionContainer sections;
 	FCanvasTextureInfo canvasTextureInfo;
@@ -183,7 +183,7 @@ struct FLevelLocals
 	float		MusicVolume;
 
 	// Hardware render stuff that can either be set via CVAR or MAPINFO
-	int			lightmode;
+	ELightMode	lightmode;
 	bool		brightfog;
 	bool		lightadditivesurfaces;
 	bool		notexturefill;
@@ -194,7 +194,7 @@ struct FLevelLocals
 
 	node_t		*HeadNode() const
 	{
-		return nodes.Size() == 0? nullptr : &nodes[nodes.Size() - 1];
+		return nodes.Size() == 0 ? nullptr : &nodes[nodes.Size() - 1];
 	}
 	node_t		*HeadGamenode() const
 	{
@@ -204,9 +204,24 @@ struct FLevelLocals
 	// Returns true if level is loaded from saved game or is being revisited as a part of a hub
 	bool		IsReentering() const
 	{
-		return savegamerestore 
+		return savegamerestore
 			|| (info != nullptr && info->Snapshot.mBuffer != nullptr && info->isValid());
 	}
+
+	bool isSoftwareLighting() const
+	{
+		return lightmode >= ELightMode::ZDoomSoftware;
+	}
+
+	bool isDarkLightMode() const
+	{
+		return !!((int)lightmode & (int)ELightMode::Doom);
+	}
+
+	void SetFallbackLightMode()
+	{
+		lightmode = ELightMode::Doom;
+	}
 };
 
 extern FLevelLocals level;
diff --git a/src/g_mapinfo.cpp b/src/g_mapinfo.cpp
index d621b231c3..e79abf0c84 100644
--- a/src/g_mapinfo.cpp
+++ b/src/g_mapinfo.cpp
@@ -284,7 +284,7 @@ void level_info_t::Reset()
 	PrecacheSounds.Clear();
 
 	brightfog = -1;
-	lightmode = -1;
+	lightmode = ELightMode::NotSet;
 	notexturefill = -1;
 	lightadditivesurfaces = -1;
 	skyrotatevector = FVector3(0, 0, 1);
@@ -1381,9 +1381,9 @@ DEFINE_MAP_OPTION(lightmode, false)
 	parse.ParseAssign();
 	parse.sc.MustGetNumber();
 
-	if ((parse.sc.Number >= 0 && parse.sc.Number <= 4) || parse.sc.Number == 8)
+	if ((parse.sc.Number >= 0 && parse.sc.Number <= 4) || parse.sc.Number == 8 || parse.sc.Number == 16)
 	{
-		info->lightmode = uint8_t(parse.sc.Number);
+		info->lightmode = ELightMode(parse.sc.Number);
 	}
 	else
 	{
diff --git a/src/hwrenderer/scene/hw_drawinfo.cpp b/src/hwrenderer/scene/hw_drawinfo.cpp
index 35b1836e0c..06e962fff6 100644
--- a/src/hwrenderer/scene/hw_drawinfo.cpp
+++ b/src/hwrenderer/scene/hw_drawinfo.cpp
@@ -388,7 +388,7 @@ void HWViewpointUniforms::SetDefaults()
 	mNormalViewMatrix.loadIdentity();
 	mViewHeight = viewheight;
 	mGlobVis = (float)R_GetGlobVis(r_viewwindow, r_visibility) / 32.f;
-	mPalLightLevels = static_cast<int>(gl_bandedswlight) | (static_cast<int>(gl_fogmode) << 8);
+	mPalLightLevels = static_cast<int>(gl_bandedswlight) | (static_cast<int>(gl_fogmode) << 8) | (static_cast<int>(gl_lightmode) << 16);
 	mClipLine.X = -10000000.0f;
 	mShadowmapFilter = gl_shadowmap_filter;
 
diff --git a/src/hwrenderer/scene/hw_renderstate.cpp b/src/hwrenderer/scene/hw_renderstate.cpp
index 5aa8d9c3cb..721b87fd5c 100644
--- a/src/hwrenderer/scene/hw_renderstate.cpp
+++ b/src/hwrenderer/scene/hw_renderstate.cpp
@@ -127,7 +127,7 @@ void FRenderState::SetFog(int lightlevel, int rellight, bool fullbright, const F
 	}
 	else
 	{
-		if ((level.lightmode == 2 || (level.lightmode == 8 && cmap->BlendFactor > 0)) && fogcolor == 0)
+		if ((level.lightmode == ELightMode::Doom || (level.isSoftwareLighting() && cmap->BlendFactor > 0)) && fogcolor == 0)
 		{
 			float light = (float)hw_CalcLightLevel(lightlevel, rellight, false, cmap->BlendFactor);
 			SetShaderLight(light, lightlevel);
@@ -148,7 +148,7 @@ void FRenderState::SetFog(int lightlevel, int rellight, bool fullbright, const F
 		SetFog(fogcolor, fogdensity);
 
 		// Korshun: fullbright fog like in software renderer.
-		if (level.lightmode == 8 && cmap->BlendFactor == 0 && level.brightfog && fogdensity != 0 && fogcolor != 0)
+		if (level.isSoftwareLighting() && cmap->BlendFactor == 0 && level.brightfog && fogdensity != 0 && fogcolor != 0)
 		{
 			SetSoftLightLevel(255);
 		}
diff --git a/src/hwrenderer/scene/hw_renderstate.h b/src/hwrenderer/scene/hw_renderstate.h
index f494df34a0..d820c07ec8 100644
--- a/src/hwrenderer/scene/hw_renderstate.h
+++ b/src/hwrenderer/scene/hw_renderstate.h
@@ -326,7 +326,7 @@ public:
 
 	void SetSoftLightLevel(int llevel, int blendfactor = 0)
 	{
-		if (level.lightmode == 8 && blendfactor == 0) mLightParms[3] = llevel / 255.f;
+		if (level.isSoftwareLighting() && blendfactor == 0) mLightParms[3] = llevel / 255.f;
 		else mLightParms[3] = -1.f;
 	}
 
diff --git a/src/hwrenderer/scene/hw_skyportal.cpp b/src/hwrenderer/scene/hw_skyportal.cpp
index 0f0450165d..05b70e7fdb 100644
--- a/src/hwrenderer/scene/hw_skyportal.cpp
+++ b/src/hwrenderer/scene/hw_skyportal.cpp
@@ -164,10 +164,10 @@ void HWSkyPortal::DrawContents(HWDrawInfo *di, FRenderState &state)
 	auto &vp = di->Viewpoint;
 
 	// We have no use for Doom lighting special handling here, so disable it for this function.
-	int oldlightmode = ::level.lightmode;
-	if (::level.lightmode == 8)
+	auto oldlightmode = ::level.lightmode;
+	if (::level.isSoftwareLighting())
 	{
-		::level.lightmode = 2;
+		::level.SetFallbackLightMode();
 		state.SetSoftLightLevel(-1);
 	}
 
diff --git a/src/hwrenderer/scene/hw_weapon.cpp b/src/hwrenderer/scene/hw_weapon.cpp
index 1e18a6e2f8..8ec59a2813 100644
--- a/src/hwrenderer/scene/hw_weapon.cpp
+++ b/src/hwrenderer/scene/hw_weapon.cpp
@@ -106,8 +106,8 @@ void HWDrawInfo::DrawPSprite(HUDSprite *huds, FRenderState &state)
 
 void HWDrawInfo::DrawPlayerSprites(bool hudModelStep, FRenderState &state)
 {
-	int oldlightmode = level.lightmode;
-	if (!hudModelStep && level.lightmode == 8) level.lightmode = 2;	// Software lighting cannot handle 2D content so revert to lightmode 2 for that.
+	auto oldlightmode = level.lightmode;
+	if (!hudModelStep && level.isSoftwareLighting()) level.SetFallbackLightMode();	// Software lighting cannot handle 2D content.
 	for (auto &hudsprite : hudsprites)
 	{
 		if ((!!hudsprite.mframe) == hudModelStep)
@@ -260,7 +260,7 @@ static WeaponLighting GetWeaponLighting(sector_t *viewsector, const DVector3 &po
 
 		l.lightlevel = hw_CalcLightLevel(l.lightlevel, getExtraLight(), true, 0);
 
-		if (level.lightmode == 8 || l.lightlevel < 92)
+		if (level.isSoftwareLighting() || l.lightlevel < 92)
 		{
 			// Korshun: the way based on max possible light level for sector like in software renderer.
 			double min_L = 36.0 / 31.0 - ((l.lightlevel / 255.0) * (63.0 / 31.0)); // Lightlevel in range 0-63
@@ -498,8 +498,8 @@ void HWDrawInfo::PreparePlayerSprites(sector_t * viewsector, area_t in_area)
 
 	// hack alert! Rather than changing everything in the underlying lighting code let's just temporarily change
 	// light mode here to draw the weapon sprite.
-	int oldlightmode = level.lightmode;
-	if (level.lightmode == 8) level.lightmode = 2;
+	auto oldlightmode = level.lightmode;
+	if (level.isSoftwareLighting()) level.SetFallbackLightMode();
 
 	for (DPSprite *psp = player->psprites; psp != nullptr && psp->GetID() < PSP_TARGETCENTER; psp = psp->GetNext())
 	{
diff --git a/src/hwrenderer/utility/hw_lighting.cpp b/src/hwrenderer/utility/hw_lighting.cpp
index 83e2acd7df..8d7298b9fd 100644
--- a/src/hwrenderer/utility/hw_lighting.cpp
+++ b/src/hwrenderer/utility/hw_lighting.cpp
@@ -88,7 +88,7 @@ int hw_CalcLightLevel(int lightlevel, int rellight, bool weapon, int blendfactor
 
 	if (lightlevel == 0) return 0;
 
-	bool darklightmode = (level.lightmode & 2) || (level.lightmode == 8 && blendfactor > 0);
+	bool darklightmode = (level.isDarkLightMode()) || (level.isSoftwareLighting() && blendfactor > 0);
 
 	if (darklightmode && lightlevel < 192 && !weapon) 
 	{
@@ -130,7 +130,7 @@ PalEntry hw_CalcLightColor(int light, PalEntry pe, int blendfactor)
 
 	if (blendfactor == 0)
 	{
-		if (level.lightmode == 8)
+		if (level.isSoftwareLighting())
 		{
 			return pe;
 		}
@@ -174,10 +174,10 @@ float hw_GetFogDensity(int lightlevel, PalEntry fogcolor, int sectorfogdensity,
 {
 	float density;
 
-	int lightmode = level.lightmode;
-	if (lightmode == 8 && blendfactor > 0) lightmode = 2;	// The blendfactor feature does not work with software-style lighting.
+	auto lightmode = level.lightmode;
+	if (level.isSoftwareLighting() && blendfactor > 0) lightmode = ELightMode::Doom;	// The blendfactor feature does not work with software-style lighting.
 
-	if (lightmode & 4)
+	if (lightmode == ELightMode::DoomLegacy)
 	{
 		// uses approximations of Legacy's default settings.
 		density = level.fogdensity ? (float)level.fogdensity : 18;
@@ -190,9 +190,9 @@ float hw_GetFogDensity(int lightlevel, PalEntry fogcolor, int sectorfogdensity,
 	else if ((fogcolor.d & 0xffffff) == 0)
 	{
 		// case 2: black fog
-		if ((lightmode != 8 || blendfactor > 0) && !(level.flags3 & LEVEL3_NOLIGHTFADE))
+		if ((!level.isSoftwareLighting() || blendfactor > 0) && !(level.flags3 & LEVEL3_NOLIGHTFADE))
 		{
-			density = distfogtable[level.lightmode != 0][hw_ClampLight(lightlevel)];
+			density = distfogtable[level.lightmode != ELightMode::LinearStandard][hw_ClampLight(lightlevel)];
 		}
 		else
 		{
@@ -250,7 +250,7 @@ bool hw_CheckFog(sector_t *frontsector, sector_t *backsector)
 	else if (level.outsidefogdensity != 0 && APART(level.info->outsidefog) != 0xff && (fogcolor.d & 0xffffff) == (level.info->outsidefog & 0xffffff))
 	{
 	}
-	else  if (level.fogdensity!=0 || (level.lightmode & 4))
+	else  if (level.fogdensity!=0 || level.lightmode == ELightMode::DoomLegacy)
 	{
 		// case 3: level has fog density set
 	}
@@ -269,7 +269,7 @@ bool hw_CheckFog(sector_t *frontsector, sector_t *backsector)
 	{
 		return false;
 	}
-	else  if (level.fogdensity!=0 || (level.lightmode & 4))
+	else  if (level.fogdensity!=0 || level.lightmode == ELightMode::DoomLegacy)
 	{
 		// case 3: level has fog density set
 		return false;
diff --git a/src/v_2ddrawer.cpp b/src/v_2ddrawer.cpp
index 2a58f9f317..7b3fa19634 100644
--- a/src/v_2ddrawer.cpp
+++ b/src/v_2ddrawer.cpp
@@ -429,7 +429,7 @@ void F2DDrawer::AddPoly(FTexture *texture, FVector2 *points, int npoints,
 	double fadelevel;
 
 	// The hardware renderer's light modes 0, 1 and 4 use a linear light scale which must be used here as well. Otherwise the automap gets too dark.
-	if (vid_rendermode != 4 || (level.lightmode >= 2 && level.lightmode != 4))
+	if (vid_rendermode != 4 || level.isDarkLightMode() || level.isSoftwareLighting())
 	{
 		double map = (NUMCOLORMAPS * 2.) - ((lightlevel + 12) * (NUMCOLORMAPS / 128.));
 		fadelevel = clamp((map - 12) / NUMCOLORMAPS, 0.0, 1.0);
diff --git a/wadsrc/static/menudef.txt b/wadsrc/static/menudef.txt
index 4026e2bc04..1ff8697b35 100644
--- a/wadsrc/static/menudef.txt
+++ b/wadsrc/static/menudef.txt
@@ -2105,6 +2105,7 @@ OptionValue "LightingModes"
 	3, "$OPTVAL_DARK"
 	4, "$OPTVAL_LEGACY"
 	8, "$OPTVAL_SOFTWARE"
+	16, "$OPTVAL_VANILLA"
 }
 
 OptionValue "Precision"
diff --git a/wadsrc/static/shaders/glsl/main.fp b/wadsrc/static/shaders/glsl/main.fp
index 77855a85a6..e6ec4c63fe 100644
--- a/wadsrc/static/shaders/glsl/main.fp
+++ b/wadsrc/static/shaders/glsl/main.fp
@@ -119,17 +119,84 @@ vec4 getTexel(vec2 st)
 
 //===========================================================================
 //
-// Doom lighting equation exactly as calculated by zdoom.
+// Vanilla Doom wall colormap equation
+//
+//===========================================================================
+float R_WallColormap(float lightnum, float z)
+{
+	// R_ScaleFromGlobalAngle calculation
+	float projection = 160.0; // projection depends on SCREENBLOCKS!! 160 is the fullscreen value
+	vec2 line_v1 = pixelpos.xz; // in vanilla this is the first curline vertex
+	vec2 line_normal = vWorldNormal.xz;
+	float texscale = projection * clamp(dot(normalize(uCameraPos.xz - line_v1), line_normal), 0.0, 1.0) / z;
+
+	float lightz = clamp(16.0 * texscale, 0.0, 47.0);
+
+	// scalelight[lightnum][lightz] lookup
+	float startmap = (15.0 - lightnum) * 4.0;
+	return startmap - lightz * 0.5;
+}
+
+//===========================================================================
+//
+// Vanilla Doom plane colormap equation
+//
+//===========================================================================
+float R_PlaneColormap(float lightnum, float z)
+{
+	float lightz = clamp(z / 16.0f, 0.0, 127.0);
+
+	// zlight[lightnum][lightz] lookup
+	float startmap = (15.0 - lightnum) * 4.0;
+	float scale = 160.0 / (lightz + 1.0);
+	return startmap - scale * 0.5;
+}
+
+//===========================================================================
+//
+// zdoom colormap equation
+//
+//===========================================================================
+float R_ZDoomColormap(float light, float z)
+{
+	float L = light * 255.0;
+	float vis = min(uGlobVis / z, 24.0 / 32.0);
+	float shade = 2.0 - (L + 12.0) / 128.0;
+	float lightscale = shade - vis;
+	return lightscale * 31.0;
+}
+
+float R_DoomColormap(float light, float z)
+{
+	if ((uPalLightLevels >> 16) == 16) // gl_lightmode 16
+	{
+		float lightnum = clamp(light * 15.0, 0.0, 15.0);
+
+		if (dot(vWorldNormal.xyz, vWorldNormal.xyz) > 0.5)
+		{
+			return mix(R_WallColormap(lightnum, z), R_PlaneColormap(lightnum, z), abs(vWorldNormal.y));
+		}
+		else // vWorldNormal is not set on sprites
+		{
+			return R_PlaneColormap(lightnum, z);
+		}
+	}
+	else
+	{
+		return R_ZDoomColormap(light, z);
+	}
+}
+
+//===========================================================================
+//
+// Doom software lighting equation
 //
 //===========================================================================
 float R_DoomLightingEquation(float light)
 {
-	// L is the integer light level used in the game
-	float L = light * 255.0;
-
-	// z is the depth in view/eye space, positive going into the screen
+	// z is the depth in view space, positive going into the screen
 	float z;
-	if ((uPalLightLevels >> 8) == 2)
+	if (((uPalLightLevels >> 8)  & 0xff) == 2)
 	{
 		z = distance(pixelpos.xyz, uCameraPos.xyz);
 	}
@@ -138,17 +205,13 @@ float R_DoomLightingEquation(float light)
 		z = pixelpos.w;
 	}
 
-	// The zdoom light equation
-	float vis = min(uGlobVis / z, 24.0 / 32.0);
-	float shade = 2.0 - (L + 12.0) / 128.0;
-	float lightscale;
+	float colormap = R_DoomColormap(light, z);
+
 	if ((uPalLightLevels & 0xff) != 0)
-		lightscale = float(-floor(-(shade - vis) * 31.0) - 0.5) / 31.0;
-	else
-		lightscale = shade - vis;
+		colormap = floor(colormap) + 0.5;
 
 	// Result is the normalized colormap index (0 bright .. 1 dark)
-	return clamp(lightscale, 1.0 - light, 31.0 / 32.0);
+	return clamp(colormap, 0.0, 31.0) / 32.0;
 }
 
 //===========================================================================