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

# Conflicts: # src/r_bsp.cpp # src/r_swrenderer.cpp # src/r_swrenderer.h # src/sound/fmodsound.cpp # src/sound/fmodsound.h
2025-04-03 15:11:14 +00:00 · 2016-05-02 21:25:57 +08:00 · 2016-05-02 21:25:57 +08:00 · 9f9e4310a1
commit 9f9e4310a1
parent 601804f10b f9022f3054
55 changed files with 745 additions and 529 deletions
--- a/src/g_level.h
+++ b/src/g_level.h
@ -338,6 +338,7 @@ struct level_info_t

 	TArray<FSoundID> PrecacheSounds;
 	TArray<FString> PrecacheTextures;
+	TArray<FName> PrecacheClasses;

 	level_info_t() 
 	{ 
--- a/src/g_mapinfo.cpp
+++ b/src/g_mapinfo.cpp
@ -1083,6 +1083,18 @@ DEFINE_MAP_OPTION(PrecacheTextures, true)
 	} while (parse.sc.CheckString(","));
 }

+DEFINE_MAP_OPTION(PrecacheClasses, true)
+{
+	parse.ParseAssign();
+
+	do
+	{
+		parse.sc.MustGetString();
+		//the class list is not initialized here so all we can do is store the class's name.
+		info->PrecacheClasses.Push(parse.sc.String);
+	} while (parse.sc.CheckString(","));
+}
+
 DEFINE_MAP_OPTION(redirect, true)
 {
 	parse.ParseAssign();
--- a/src/g_shared/a_keys.cpp
+++ b/src/g_shared/a_keys.cpp
@ -22,7 +22,7 @@ struct OneKey
 		if (owner->IsKindOf(RUNTIME_CLASS(AKey)))
 		{
 			// P_GetMapColorForKey() checks the key directly
-			return owner->IsA(key);
+			return owner->IsA(key) || owner->GetSpecies() == key->TypeName;
 		}
 		else 
 		{
--- a/src/g_shared/shared_hud.cpp
+++ b/src/g_shared/shared_hud.cpp
@ -839,18 +839,26 @@ static void DrawCoordinates(player_t * CPlayer)
 	int xpos = vwidth - SmallFont->StringWidth("X: -00000")-6;
 	int ypos = 18;

+	screen->DrawText(SmallFont, hudcolor_titl, vwidth - 6 - SmallFont->StringWidth(level.MapName), ypos, level.MapName,
+		DTA_KeepRatio, true,
+		DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);
+
+	screen->DrawText(SmallFont, hudcolor_titl, vwidth - 6 - SmallFont->StringWidth(level.LevelName), ypos + h, level.LevelName,
+		DTA_KeepRatio, true,
+		DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);
+
 	mysnprintf(coordstr, countof(coordstr), "X: %d", int(pos.X));
-	screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos, coordstr,
+	screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos+2*h, coordstr,
 		DTA_KeepRatio, true,
 		DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);

 	mysnprintf(coordstr, countof(coordstr), "Y: %d", int(pos.Y));
-	screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos+h, coordstr,
+	screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos+3*h, coordstr,
 		DTA_KeepRatio, true,
 		DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);

 	mysnprintf(coordstr, countof(coordstr), "Z: %d", int(pos.Z));
-	screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos+2*h, coordstr,
+	screen->DrawText(SmallFont, hudcolor_xyco, xpos, ypos+4*h, coordstr,
 		DTA_KeepRatio, true,
 		DTA_VirtualWidth, vwidth, DTA_VirtualHeight, vheight, TAG_DONE);
 }
--- a/src/gl/compatibility/gl_20.cpp
+++ b/src/gl/compatibility/gl_20.cpp
@ -37,6 +37,7 @@
 **
 */
 #include "gl/system/gl_system.h"
+#include "menu/menu.h"
 #include "tarray.h"
 #include "doomtype.h"
 #include "m_argv.h"
@ -53,6 +54,54 @@
 #include "gl/renderer/gl_renderstate.h"
 #include "gl/scene/gl_drawinfo.h"

+
+//==========================================================================
+//
+// Do some tinkering with the menus so that certain options only appear
+// when they are actually valid.
+//
+//==========================================================================
+
+void gl_PatchMenu()
+{
+	if (gl.glslversion == 0)
+	{
+		// Radial fog and Doom lighting are not available in SM < 4 cards
+		// The way they are implemented does not work well on older hardware.
+
+		FOptionValues **opt = OptionValues.CheckKey("LightingModes");
+		if (opt != NULL) 
+		{
+			for(int i = (*opt)->mValues.Size()-1; i>=0; i--)
+			{
+				// Delete 'Doom' lighting mode
+				if ((*opt)->mValues[i].Value == 2.0 || (*opt)->mValues[i].Value == 8.0)
+				{
+					(*opt)->mValues.Delete(i);
+				}
+			}
+		}
+
+		opt = OptionValues.CheckKey("FogMode");
+		if (opt != NULL) 
+		{
+			for(int i = (*opt)->mValues.Size()-1; i>=0; i--)
+			{
+				// Delete 'Radial' fog mode
+				if ((*opt)->mValues[i].Value == 2.0)
+				{
+					(*opt)->mValues.Delete(i);
+				}
+			}
+		}
+
+		// disable features that don't work without shaders.
+		if (gl_lightmode == 2 || gl_lightmode == 8) gl_lightmode = 3;
+		if (gl_fogmode == 2) gl_fogmode = 1;
+	}
+}
+
+
 //==========================================================================
 //
 //
@ -499,4 +548,5 @@ void FGLRenderer::RenderMultipassStuff()
 		gl_drawinfo->dldrawlists[GLLDL_FLATS_FOGMASKED].DrawFlats(GLPASS_LIGHTTEX_ADDITIVE);
 	}
 	else gl_lights = false;
-}
+}
+
--- a/src/gl/data/gl_matrix.cpp
+++ b/src/gl/data/gl_matrix.cpp
@ -121,22 +121,17 @@ VSMatrix::loadMatrix(const float *aMatrix)
 #endif


-// gl Translate implementation with matrix selection
+// gl Translate implementation
 void 
 VSMatrix::translate(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z) 
 {
-	FLOATTYPE mat[16];
-
-	setIdentityMatrix(mat);
-	mat[12] = x;
-	mat[13] = y;
-	mat[14] = z;
-
-	multMatrix(mat);
+	mMatrix[12] = mMatrix[0] * x + mMatrix[4] * y + mMatrix[8] * z + mMatrix[12];
+	mMatrix[13] = mMatrix[1] * x + mMatrix[5] * y + mMatrix[9] * z + mMatrix[13];
+	mMatrix[14] = mMatrix[2] * x + mMatrix[6] * y + mMatrix[10] * z + mMatrix[14];
 }


-// gl Scale implementation with matrix selection
+// gl Scale implementation
 void 
 VSMatrix::scale(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z) 
 {
@ -146,7 +141,7 @@ VSMatrix::scale(FLOATTYPE x, FLOATTYPE y, FLOATTYPE z)
 }


-// gl Rotate implementation with matrix selection
+// gl Rotate implementation
 void 
 VSMatrix::rotate(FLOATTYPE angle, FLOATTYPE x, FLOATTYPE y, FLOATTYPE z)
 {
--- a/src/gl/models/gl_models.cpp
+++ b/src/gl/models/gl_models.cpp
@ -325,8 +325,8 @@ FTexture * LoadSkin(const char * path, const char * fn)

 static int ModelFrameHash(FSpriteModelFrame * smf)
 {
-	const DWORD *table = GetCRCTable ();
-	DWORD hash = 0xffffffff;
+	const uint32_t *table = GetCRCTable ();
+	uint32_t hash = 0xffffffff;

 	const char * s = (const char *)(&smf->type);	// this uses type, sprite and frame for hashing
 	const char * se= (const char *)(&smf->hashnext);
--- a/src/gl/models/gl_models_md3.cpp
+++ b/src/gl/models/gl_models_md3.cpp
@ -77,45 +77,45 @@ static void UnpackVector(unsigned short packed, float & nx, float & ny, float &
 #pragma pack(4)
 struct md3_header_t
 {
-	DWORD Magic;
-	DWORD Version;
+	uint32_t Magic;
+	uint32_t Version;
 	char Name[MAX_QPATH];
-	DWORD Flags;
-	DWORD Num_Frames;
-	DWORD Num_Tags;
-	DWORD Num_Surfaces;
-	DWORD Num_Skins;
-	DWORD Ofs_Frames;
-	DWORD Ofs_Tags;
-	DWORD Ofs_Surfaces;
-	DWORD Ofs_Eof;
+	uint32_t Flags;
+	uint32_t Num_Frames;
+	uint32_t Num_Tags;
+	uint32_t Num_Surfaces;
+	uint32_t Num_Skins;
+	uint32_t Ofs_Frames;
+	uint32_t Ofs_Tags;
+	uint32_t Ofs_Surfaces;
+	uint32_t Ofs_Eof;
 };

 struct md3_surface_t
 {
-	DWORD Magic;
+	uint32_t Magic;
 	char Name[MAX_QPATH];
-	DWORD Flags;
-	DWORD Num_Frames;
-	DWORD Num_Shaders;
-	DWORD Num_Verts;
-	DWORD Num_Triangles;
-	DWORD Ofs_Triangles;
-	DWORD Ofs_Shaders;
-	DWORD Ofs_Texcoord;
-	DWORD Ofs_XYZNormal;
-	DWORD Ofs_End;
+	uint32_t Flags;
+	uint32_t Num_Frames;
+	uint32_t Num_Shaders;
+	uint32_t Num_Verts;
+	uint32_t Num_Triangles;
+	uint32_t Ofs_Triangles;
+	uint32_t Ofs_Shaders;
+	uint32_t Ofs_Texcoord;
+	uint32_t Ofs_XYZNormal;
+	uint32_t Ofs_End;
 };

 struct md3_triangle_t
 {
-	DWORD vt_index[3];
+	uint32_t vt_index[3];
 };

 struct md3_shader_t
 {
 	char Name[MAX_QPATH];
-	DWORD index;
+	uint32_t index;
 };

 struct md3_texcoord_t
--- a/src/gl/renderer/gl_renderstate.h
+++ b/src/gl/renderer/gl_renderstate.h
@ -37,6 +37,7 @@ enum EEffect
 	EFF_SPHEREMAP,
 	EFF_BURN,
 	EFF_STENCIL,
+	EFF_GAMMACORRECTION,

 	MAX_EFFECTS
 };
--- a/src/gl/scene/gl_clipper.cpp
+++ b/src/gl/scene/gl_clipper.cpp
@ -396,27 +396,6 @@ void R_SetView()
 	viewy = FLOAT2FIXED(ViewPos.Y);
 }

-angle_t R_PointToPseudoAngle (fixed_t x, fixed_t y)
-{
-	double vecx = double(x-viewx);
-	double vecy = double(y-viewy);
-	
-	if (vecx == 0 && vecy == 0)
-	{
-		return 0;
-	}
-	else
-	{
-		double result = vecy / (fabs(vecx) + fabs(vecy));
-		if (vecx < 0)
-		{
-			result = 2.f - result;
-		}
-		return xs_Fix<30>::ToFix(result);
-	}
-}
-
-
 angle_t R_PointToPseudoAngle(double x, double y)
 {
 	double vecx = x - ViewPos.X;
@ -447,7 +426,7 @@ angle_t R_PointToPseudoAngle(double x, double y)
 //  if some part of the bbox might be visible.
 //
 //-----------------------------------------------------------------------------
-	static const int checkcoord[12][4] = // killough -- static const
+	static const BYTE checkcoord[12][4] = // killough -- static const
 	{
 	  {3,0,2,1},
 	  {3,0,2,0},
@ -462,17 +441,17 @@ angle_t R_PointToPseudoAngle(double x, double y)
 	  {2,1,3,0}
 	};

-bool Clipper::CheckBox(const fixed_t *bspcoord) 
+bool Clipper::CheckBox(const float *bspcoord) 
 {
 	angle_t angle1, angle2;

 	int        boxpos;
-	const int* check;
+	const BYTE* check;
 	
 	// Find the corners of the box
 	// that define the edges from current viewpoint.
-	boxpos = (viewx <= bspcoord[BOXLEFT] ? 0 : viewx < bspcoord[BOXRIGHT ] ? 1 : 2) +
-		(viewy >= bspcoord[BOXTOP ] ? 0 : viewy > bspcoord[BOXBOTTOM] ? 4 : 8);
+	boxpos = (ViewPos.X <= bspcoord[BOXLEFT] ? 0 : ViewPos.X < bspcoord[BOXRIGHT ] ? 1 : 2) +
+		(ViewPos.Y >= bspcoord[BOXTOP ] ? 0 : ViewPos.Y > bspcoord[BOXBOTTOM] ? 4 : 8);
 	
 	if (boxpos == 5) return true;
 	
--- a/src/gl/scene/gl_clipper.h
+++ b/src/gl/scene/gl_clipper.h
@ -129,13 +129,12 @@ public:
 		SafeRemoveClipRange(AngleToPseudo(startangle), AngleToPseudo(endangle));
 	}

-	bool CheckBox(const fixed_t *bspcoord);
+	bool CheckBox(const float *bspcoord);
 };


 extern Clipper clipper;

-angle_t R_PointToPseudoAngle (fixed_t x, fixed_t y);
 angle_t R_PointToPseudoAngle(double x, double y);
 void R_SetView();

--- a/src/gl/scene/gl_scene.cpp
+++ b/src/gl/scene/gl_scene.cpp
@ -74,6 +74,7 @@
 #include "gl/stereo3d/gl_stereo3d.h"
 #include "gl/stereo3d/scoped_view_shifter.h"
 #include "gl/textures/gl_material.h"
+#include "gl/textures/gl_skyboxtexture.h"
 #include "gl/utility/gl_clock.h"
 #include "gl/utility/gl_convert.h"
 #include "gl/utility/gl_templates.h"
@ -836,7 +837,7 @@ sector_t * FGLRenderer::RenderViewpoint (AActor * camera, GL_IRECT * bounds, flo
 		SetProjection( eye->GetProjection(fov, ratio, fovratio) );
 		// SetProjection(fov, ratio, fovratio);	// switch to perspective mode and set up clipper
 		SetViewAngle(ViewAngle);
-		// Stereo mode specific viewpoint adjustment - temporarily shifts global viewx, viewy, viewz
+		// Stereo mode specific viewpoint adjustment - temporarily shifts global ViewPos
 		eye->GetViewShift(GLRenderer->mAngles.Yaw.Degrees, viewShift);
 		s3d::ScopedViewShifter viewShifter(viewShift);
 		SetViewMatrix(ViewPos.X, ViewPos.Y, ViewPos.Z, false, false);
@ -978,6 +979,7 @@ struct FGLInterface : public FRenderer
 {
 	bool UsesColormap() const;
 	void PrecacheTexture(FTexture *tex, int cache);
+	void Precache(BYTE *texhitlist, TMap<PClassActor*, bool> &actorhitlist);
 	void RenderView(player_t *player);
 	void WriteSavePic (player_t *player, FILE *file, int width, int height);
 	void StateChanged(AActor *actor);
@ -1028,6 +1030,85 @@ void FGLInterface::PrecacheTexture(FTexture *tex, int cache)
 	}
 }

+void FGLInterface::Precache(BYTE *texhitlist, TMap<PClassActor*, bool> &actorhitlist)
+{
+	BYTE *spritelist = new BYTE[sprites.Size()];
+	TMap<PClassActor*, bool>::Iterator it(actorhitlist);
+	TMap<PClassActor*, bool>::Pair *pair;
+
+	// this isn't done by the main code so it needs to be done here first:
+	// check skybox textures and mark the separate faces as used
+	for (int i = 0; i<TexMan.NumTextures(); i++)
+	{
+		// HIT_Wall must be checked for MBF-style sky transfers. 
+		if (texhitlist[i] & (FTextureManager::HIT_Sky | FTextureManager::HIT_Wall))
+		{
+			FTexture *tex = TexMan.ByIndex(i);
+			if (tex->gl_info.bSkybox)
+			{
+				FSkyBox *sb = static_cast<FSkyBox*>(tex);
+				for (int i = 0; i<6; i++)
+				{
+					if (sb->faces[i])
+					{
+						int index = sb->faces[i]->id.GetIndex();
+						texhitlist[index] |= FTextureManager::HIT_Flat;
+					}
+				}
+			}
+		}
+	}
+
+
+
+
+
+	memset(spritelist, 0, sprites.Size());
+
+	while (it.NextPair(pair))
+	{
+		PClassActor *cls = pair->Key;
+
+		for (int i = 0; i < cls->NumOwnedStates; i++)
+		{
+			spritelist[cls->OwnedStates[i].sprite] = true;
+		}
+	}
+
+	// Precache textures (and sprites).
+
+	for (int i = (int)(sprites.Size() - 1); i >= 0; i--)
+	{
+		if (spritelist[i])
+		{
+			int j, k;
+			for (j = 0; j < sprites[i].numframes; j++)
+			{
+				const spriteframe_t *frame = &SpriteFrames[sprites[i].spriteframes + j];
+
+				for (k = 0; k < 16; k++)
+				{
+					FTextureID pic = frame->Texture[k];
+					if (pic.isValid())
+					{
+						texhitlist[pic.GetIndex()] = FTextureManager::HIT_Sprite;
+					}
+				}
+			}
+		}
+	}
+	delete[] spritelist;
+
+	TexMan.precacheTime = I_FPSTime();
+
+	int cnt = TexMan.NumTextures();
+	for (int i = cnt - 1; i >= 0; i--)
+	{
+		PrecacheTexture(TexMan.ByIndex(i), texhitlist[i]);
+	}
+}
+
+
 //==========================================================================
 //
 // DFrameBuffer :: StateChanged
--- a/src/gl/scene/gl_sprite.cpp
+++ b/src/gl/scene/gl_sprite.cpp
@ -73,6 +73,7 @@ CVAR(Float, gl_sclipthreshold, 10.0, CVAR_ARCHIVE)
 CVAR(Float, gl_sclipfactor, 1.8, CVAR_ARCHIVE)
 CVAR(Int, gl_particles_style, 2, CVAR_ARCHIVE | CVAR_GLOBALCONFIG) // 0 = square, 1 = round, 2 = smooth
 CVAR(Int, gl_billboard_mode, 0, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
+CVAR(Bool, gl_billboard_faces_camera, false, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
 CVAR(Bool, gl_billboard_particles, true, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
 CVAR(Int, gl_enhanced_nv_stealth, 3, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
 CUSTOM_CVAR(Int, gl_fuzztype, 0, CVAR_ARCHIVE)
@ -262,40 +263,60 @@ void GLSprite::Draw(int pass)
 				//&& GLRenderer->mViewActor != NULL
 				&& (gl_billboard_mode == 1 || (actor && actor->renderflags & RF_FORCEXYBILLBOARD))));

+			const bool drawBillboardFacingCamera = gl_billboard_faces_camera;
+
 			gl_RenderState.Apply();

-			Vector v1;
-			Vector v2;
-			Vector v3;
-			Vector v4;
+			FVector3 v1;
+			FVector3 v2;
+			FVector3 v3;
+			FVector3 v4;

-			if (drawWithXYBillboard)
+			if (drawWithXYBillboard || drawBillboardFacingCamera)
 			{
-				// Rotate the sprite about the vector starting at the center of the sprite
-				// triangle strip and with direction orthogonal to where the player is looking
-				// in the x/y plane.
+				// Compute center of sprite
 				float xcenter = (x1 + x2)*0.5;
 				float ycenter = (y1 + y2)*0.5;
 				float zcenter = (z1 + z2)*0.5;
-				float angleRad = (270. - GLRenderer->mAngles.Yaw).Radians();

 				Matrix3x4 mat;
 				mat.MakeIdentity();
-				mat.Translate(xcenter, zcenter, ycenter);
-				mat.Rotate(-sin(angleRad), 0, cos(angleRad), -GLRenderer->mAngles.Pitch.Degrees);
-				mat.Translate(-xcenter, -zcenter, -ycenter);
-				v1 = mat * Vector(x1, z1, y1);
-				v2 = mat * Vector(x2, z1, y2);
-				v3 = mat * Vector(x1, z2, y1);
-				v4 = mat * Vector(x2, z2, y2);
-			}
-			else
-			{
+				mat.Translate(xcenter, zcenter, ycenter); // move to sprite center

-				v1 = Vector(x1, z1, y1);
-				v2 = Vector(x2, z1, y2);
-				v3 = Vector(x1, z2, y1);
-				v4 = Vector(x2, z2, y2);
+				// Order of rotations matters. Perform yaw rotation (Y, face camera) before pitch (X, tilt up/down).
+				if (drawBillboardFacingCamera) {
+					// [CMB] Rotate relative to camera XY position, not just camera direction,
+					// which is nicer in VR
+					float xrel = xcenter - GLRenderer->mViewActor->X();
+					float yrel = ycenter - GLRenderer->mViewActor->Y();
+					float absAngleDeg = RAD2DEG(atan2(-yrel, xrel));
+					float counterRotationDeg = 270. - GLRenderer->mAngles.Yaw.Degrees; // counteracts existing sprite rotation
+					float relAngleDeg = counterRotationDeg + absAngleDeg;
+
+					mat.Rotate(0, 1, 0, relAngleDeg);
+				}
+
+				if (drawWithXYBillboard)
+				{
+					// Rotate the sprite about the vector starting at the center of the sprite
+					// triangle strip and with direction orthogonal to where the player is looking
+					// in the x/y plane.
+					float angleRad = (270. - GLRenderer->mAngles.Yaw).Radians();
+
+					mat.Rotate(-sin(angleRad), 0, cos(angleRad), -GLRenderer->mAngles.Pitch.Degrees);
+				}
+				mat.Translate(-xcenter, -zcenter, -ycenter); // retreat from sprite center
+				v1 = mat * FVector3(x1, z1, y1);
+				v2 = mat * FVector3(x2, z1, y2);
+				v3 = mat * FVector3(x1, z2, y1);
+				v4 = mat * FVector3(x2, z2, y2);
+			}
+			else // traditional "Y" billboard mode
+			{
+				v1 = FVector3(x1, z1, y1);
+				v2 = FVector3(x2, z1, y2);
+				v3 = FVector3(x1, z2, y1);
+				v4 = FVector3(x2, z2, y2);
 			}

 			FFlatVertex *ptr;
--- a/src/gl/shaders/gl_shader.cpp
+++ b/src/gl/shaders/gl_shader.cpp
@ -294,8 +294,11 @@ bool FShader::Load(const char * name, const char * vert_prog_lump, const char *
 	modelmatrix_index = glGetUniformLocation(hShader, "ModelMatrix");
 	texturematrix_index = glGetUniformLocation(hShader, "TextureMatrix");

-	int tempindex = glGetUniformBlockIndex(hShader, "LightBufferUBO");
-	if (tempindex != -1) glUniformBlockBinding(hShader, tempindex, LIGHTBUF_BINDINGPOINT);
+	if (LM_SOFTWARE != gl.lightmethod && !(gl.flags & RFL_SHADER_STORAGE_BUFFER))
+	{
+		int tempindex = glGetUniformBlockIndex(hShader, "LightBufferUBO");
+		if (tempindex != -1) glUniformBlockBinding(hShader, tempindex, LIGHTBUF_BINDINGPOINT);
+	}

 	glUseProgram(hShader);

@ -304,7 +307,7 @@ bool FShader::Load(const char * name, const char * vert_prog_lump, const char *
 	{
 		char stringbuf[20];
 		mysnprintf(stringbuf, 20, "texture%d", i);
-		tempindex = glGetUniformLocation(hShader, stringbuf);
+		int tempindex = glGetUniformLocation(hShader, stringbuf);
 		if (tempindex > 0) glUniform1i(tempindex, i - 1);
 	}

@ -430,6 +433,7 @@ static const FEffectShader effectshaders[]=
 	{ "spheremap", "shaders/glsl/main.vp", "shaders/glsl/main.fp", "shaders/glsl/func_normal.fp", "#define SPHEREMAP\n#define NO_ALPHATEST\n" },
 	{ "burn", "shaders/glsl/main.vp", "shaders/glsl/burn.fp", NULL, "#define SIMPLE\n#define NO_ALPHATEST\n" },
 	{ "stencil", "shaders/glsl/main.vp", "shaders/glsl/stencil.fp", NULL, "#define SIMPLE\n#define NO_ALPHATEST\n" },
+	{ "gammacorrection", "shaders/glsl/main.vp", "shaders/glsl/gammacorrection.fp", NULL, "#define SIMPLE\n" },
 };


--- a/src/gl/stereo3d/scoped_view_shifter.cpp
+++ b/src/gl/stereo3d/scoped_view_shifter.cpp
@ -1,6 +1,6 @@
 /*
 ** scoped_view_shifter.cpp
-** Stack-scoped class for temporarily changing player viewpoint global variables viewx, viewy, viewz.
+** Stack-scoped class for temporarily changing camera viewpoint
 ** Used for stereoscopic 3D.
 **
 **---------------------------------------------------------------------------
--- a/src/gl/stereo3d/scoped_view_shifter.h
+++ b/src/gl/stereo3d/scoped_view_shifter.h
@ -1,6 +1,6 @@
 /*
 ** scoped_view_shifter.h
-** Stack-scoped class for temporarily changing player viewpoint global variables viewx, viewy, viewz.
+** Stack-scoped class for temporarily changing camera viewpoint
 ** Used for stereoscopic 3D.
 **
 **---------------------------------------------------------------------------
@ -43,7 +43,7 @@
 namespace s3d {

 	/**
-	 * Temporarily shift viewx, viewy, viewz
+	 * Temporarily shift 
 	 */
 	class ScopedViewShifter
 	{
--- a/src/gl/system/gl_framebuffer.cpp
+++ b/src/gl/system/gl_framebuffer.cpp
@ -322,36 +322,6 @@ int OpenGLFrameBuffer::GetPageCount()
 }


-void OpenGLFrameBuffer::GetHitlist(BYTE *hitlist)
-{
-	Super::GetHitlist(hitlist);
-
-	// check skybox textures and mark the separate faces as used
-	for(int i=0;i<TexMan.NumTextures(); i++)
-	{
-		// HIT_Wall must be checked for MBF-style sky transfers. 
-		if (hitlist[i] & (FTextureManager::HIT_Sky|FTextureManager::HIT_Wall))
-		{
-			FTexture *tex = TexMan.ByIndex(i);
-			if (tex->gl_info.bSkybox)
-			{
-				FSkyBox *sb = static_cast<FSkyBox*>(tex);
-				for(int i=0;i<6;i++) 
-				{
-					if (sb->faces[i]) 
-					{
-						int index = sb->faces[i]->id.GetIndex();
-						hitlist[index] |= FTextureManager::HIT_Flat;
-					}
-				}
-			}
-		}
-	}
-
-
-	// check model skins
-}
-
 //==========================================================================
 //
 // DFrameBuffer :: CreatePalette
--- a/src/gl/system/gl_framebuffer.h
+++ b/src/gl/system/gl_framebuffer.h
@ -46,7 +46,6 @@ public:
 	void GetFlash(PalEntry &rgb, int &amount);
 	int GetPageCount();
 	bool Begin2D(bool copy3d);
-	void GetHitlist(BYTE *hitlist);
 	void GameRestart();

 	// Retrieves a buffer containing image data for a screenshot.
--- a/src/gl/system/gl_interface.cpp
+++ b/src/gl/system/gl_interface.cpp
@ -47,12 +47,10 @@
 #include "gl/system/gl_interface.h"
 #include "gl/system/gl_cvars.h"

+void gl_PatchMenu();
 static TArray<FString>  m_Extensions;
-
 RenderContext gl;

-int occlusion_type=0;
-
 //==========================================================================
 //
 // 
@ -273,6 +271,7 @@ void gl_LoadExtensions()
 	FUDGE_FUNC(glDeleteRenderbuffers, EXT);
 	FUDGE_FUNC(glRenderbufferStorage, EXT);
 	FUDGE_FUNC(glBindRenderbuffer, EXT);
+	gl_PatchMenu();
 }

 //==========================================================================
--- a/src/gl/textures/gl_material.cpp
+++ b/src/gl/textures/gl_material.cpp
@ -173,6 +173,8 @@ void FGLTexture::Clean(bool all)
 			delete mHwTexture;
 			mHwTexture = NULL;
 		}
+
+		lastSampler = 253;
 	}
 }

@ -315,10 +317,7 @@ const FHardwareTexture *FGLTexture::Bind(int texunit, int clampmode, int transla
 					// need to do software warping
 					FWarpTexture *wt = static_cast<FWarpTexture*>(tex);
 					unsigned char *warpbuffer = new unsigned char[w*h*4];
-					if (tex->bWarped != 2)
-						WarpBufferType1((DWORD*)warpbuffer, (const DWORD*)buffer, w, h, wt->WidthOffsetMultiplier, wt->HeightOffsetMultiplier, r_FrameTime, wt->Speed);
-					else
-						WarpBufferType2((DWORD*)warpbuffer, (const DWORD*)buffer, w, h, wt->WidthOffsetMultiplier, wt->HeightOffsetMultiplier, r_FrameTime, wt->Speed);
+					WarpBuffer((DWORD*)warpbuffer, (const DWORD*)buffer, w, h, wt->WidthOffsetMultiplier, wt->HeightOffsetMultiplier, r_FrameTime, wt->Speed, tex->bWarped);
 					delete[] buffer;
 					buffer = warpbuffer;
 					wt->GenTime = r_FrameTime;
--- a/src/gl/utility/gl_geometric.h
+++ b/src/gl/utility/gl_geometric.h
@ -239,6 +239,16 @@ public:
 		return result;
 	}

+	FVector3 operator *(const FVector3 &vec)
+	{
+		FVector3 result;
+
+		result.X = vec.X*m[0][0] + vec.Y*m[0][1] + vec.Z*m[0][2] + m[0][3];
+		result.Y = vec.X*m[1][0] + vec.Y*m[1][1] + vec.Z*m[1][2] + m[1][3];
+		result.Z = vec.X*m[2][0] + vec.Y*m[2][1] + vec.Z*m[2][2] + m[2][3];
+		return result;
+	}
+
 	void MultiplyVector(float *f3 , float *f3o)
 	{
 		float x = f3[0] * m[0][0] + f3[1] * m[0][1] + f3[2] * m[0][2] + m[0][3];
--- a/src/nodebuild.cpp
+++ b/src/nodebuild.cpp
@ -156,12 +156,12 @@ int FNodeBuilder::CreateNode (DWORD set, unsigned int count, fixed_t bbox[4])
 		D(PrintSet (1, set1));
 		D(Printf (PRINT_LOG, "(%d,%d) delta (%d,%d) from seg %d\n", node.x>>16, node.y>>16, node.dx>>16, node.dy>>16, splitseg));
 		D(PrintSet (2, set2));
-		node.intchildren[0] = CreateNode (set1, count1, node.bbox[0]);
-		node.intchildren[1] = CreateNode (set2, count2, node.bbox[1]);
-		bbox[BOXTOP] = MAX (node.bbox[0][BOXTOP], node.bbox[1][BOXTOP]);
-		bbox[BOXBOTTOM] = MIN (node.bbox[0][BOXBOTTOM], node.bbox[1][BOXBOTTOM]);
-		bbox[BOXLEFT] = MIN (node.bbox[0][BOXLEFT], node.bbox[1][BOXLEFT]);
-		bbox[BOXRIGHT] = MAX (node.bbox[0][BOXRIGHT], node.bbox[1][BOXRIGHT]);
+		node.intchildren[0] = CreateNode (set1, count1, node.nb_bbox[0]);
+		node.intchildren[1] = CreateNode (set2, count2, node.nb_bbox[1]);
+		bbox[BOXTOP] = MAX (node.nb_bbox[0][BOXTOP], node.nb_bbox[1][BOXTOP]);
+		bbox[BOXBOTTOM] = MIN (node.nb_bbox[0][BOXBOTTOM], node.nb_bbox[1][BOXBOTTOM]);
+		bbox[BOXLEFT] = MIN (node.nb_bbox[0][BOXLEFT], node.nb_bbox[1][BOXLEFT]);
+		bbox[BOXRIGHT] = MAX (node.nb_bbox[0][BOXRIGHT], node.nb_bbox[1][BOXRIGHT]);
 		return (int)Nodes.Push (node);
 	}
 	else
--- a/src/nodebuild_extract.cpp
+++ b/src/nodebuild_extract.cpp
@ -94,6 +94,13 @@ void FNodeBuilder::Extract (node_t *&outNodes, int &nodeCount,
 				outNodes[i].children[j] = outNodes + outNodes[i].intchildren[j];
 			}
 		}
+		for (int j = 0; j < 2; ++j)
+		{
+			for (int k = 0; k < 4; ++k)
+			{
+				outNodes[i].bbox[j][k] = FIXED2FLOAT(outNodes[i].nb_bbox[j][k]);
+			}
+		}
 	}

 	if (GLNodes)
@ -194,6 +201,13 @@ void FNodeBuilder::ExtractMini (FMiniBSP *bsp)
 				bsp->Nodes[i].children[j] = &bsp->Nodes[bsp->Nodes[i].intchildren[j]];
 			}
 		}
+		for (int j = 0; j < 2; ++j)
+		{
+			for (int k = 0; k < 4; ++k)
+			{
+				bsp->Nodes[i].bbox[j][k] = FIXED2FLOAT(bsp->Nodes[i].nb_bbox[j][k]);
+			}
+		}
 	}

 	if (GLNodes)
--- a/src/nodebuild_utility.cpp
+++ b/src/nodebuild_utility.cpp
@ -609,25 +609,25 @@ void FNodeBuilder::AddSegToBBox (fixed_t bbox[4], const FPrivSeg *seg)
 	if (v2->y > bbox[BOXTOP])		bbox[BOXTOP] = v2->y;
 }

-void FNodeBuilder::FLevel::FindMapBounds ()
+void FNodeBuilder::FLevel::FindMapBounds()
 {
-	fixed_t minx, maxx, miny, maxy;
+	double minx, maxx, miny, maxy;

-	minx = maxx = Vertices[0].fixX();
-	miny = maxy = Vertices[0].fixY();
+	minx = maxx = Vertices[0].fX();
+	miny = maxy = Vertices[0].fY();

 	for (int i = 1; i < NumVertices; ++i)
 	{
-			 if (Vertices[i].fixX() < minx) minx = Vertices[i].fixX();
-		else if (Vertices[i].fixX() > maxx) maxx = Vertices[i].fixX();
-			 if (Vertices[i].fixY() < miny) miny = Vertices[i].fixY();
-		else if (Vertices[i].fixY() > maxy) maxy = Vertices[i].fixY();
+		if (Vertices[i].fX() < minx) minx = Vertices[i].fX();
+		else if (Vertices[i].fX() > maxx) maxx = Vertices[i].fX();
+		if (Vertices[i].fY() < miny) miny = Vertices[i].fY();
+		else if (Vertices[i].fY() > maxy) maxy = Vertices[i].fY();
 	}

-	MinX = minx;
-	MinY = miny;
-	MaxX = maxx;
-	MaxY = maxy;
+	MinX = FLOAT2FIXED(minx);
+	MinY = FLOAT2FIXED(miny);
+	MaxX = FLOAT2FIXED(maxx);
+	MaxY = FLOAT2FIXED(maxy);
 }

 FNodeBuilder::IVertexMap::~IVertexMap()
--- a/src/p_enemy.cpp
+++ b/src/p_enemy.cpp
@ -3159,7 +3159,7 @@ AInventory *P_DropItem (AActor *source, PClassActor *type, int dropamount, int c
 			int style = sv_dropstyle;
 			if (style == 0)
 			{
-				style = (gameinfo.gametype == GAME_Strife) ? 2 : 1;
+				style = gameinfo.defaultdropstyle;
 			}
 			if (style == 2)
 			{
@ -3207,7 +3207,7 @@ AInventory *P_DropItem (AActor *source, PClassActor *type, int dropamount, int c
 void P_TossItem (AActor *item)
 {
 	int style = sv_dropstyle;
-	if (style==0) style= gameinfo.defaultdropstyle;
+	if (style==0) style = gameinfo.defaultdropstyle;
 	
 	if (style==2)
 	{
--- a/src/p_glnodes.cpp
+++ b/src/p_glnodes.cpp
@ -589,7 +589,7 @@ static bool LoadNodes (FileReader * lump)
 				}
 				for (k = 0; k < 4; k++)
 				{
-					no->bbox[j][k] = LittleShort(mn->bbox[j][k])<<FRACBITS;
+					no->bbox[j][k] = (float)LittleShort(mn->bbox[j][k]);
 				}
 			}
 		}
@ -649,7 +649,7 @@ static bool LoadNodes (FileReader * lump)
 				}
 				for (k = 0; k < 4; k++)
 				{
-					no->bbox[j][k] = LittleShort(mn->bbox[j][k])<<FRACBITS;
+					no->bbox[j][k] = (float)LittleShort(mn->bbox[j][k]);
 				}
 			}
 		}
@ -1135,7 +1135,7 @@ static void CreateCachedNodes(MapData *map)
 		{
 			for (int k = 0; k < 4; ++k)
 			{
-				WriteWord(ZNodes, nodes[i].bbox[j][k] >> FRACBITS);
+				WriteWord(ZNodes, (short)nodes[i].bbox[j][k]);
 			}
 		}

--- a/src/p_mobj.cpp
+++ b/src/p_mobj.cpp
@ -639,20 +639,23 @@ bool AActor::GiveInventory(PClassInventory *type, int amount, bool givecheat)

 	// This shouldn't count for the item statistics!
 	item->ClearCounters();
-	if (type->IsDescendantOf (RUNTIME_CLASS(ABasicArmorPickup)))
+	if (!givecheat || amount > 0)
 	{
-		static_cast<ABasicArmorPickup*>(item)->SaveAmount *= amount;
-	}
-	else if (type->IsDescendantOf (RUNTIME_CLASS(ABasicArmorBonus)))
-	{
-		static_cast<ABasicArmorBonus*>(item)->SaveAmount *= amount;
-	}
-	else
-	{
-		if (!givecheat)
-			item->Amount = amount;
+		if (type->IsDescendantOf (RUNTIME_CLASS(ABasicArmorPickup)))
+		{
+			static_cast<ABasicArmorPickup*>(item)->SaveAmount *= amount;
+		}
+		else if (type->IsDescendantOf (RUNTIME_CLASS(ABasicArmorBonus)))
+		{
+			static_cast<ABasicArmorBonus*>(item)->SaveAmount *= amount;
+		}
 		else
-			item->Amount = MIN (amount, item->MaxAmount);
+		{
+			if (!givecheat)
+				item->Amount = amount;
+			else
+				item->Amount = MIN (amount, item->MaxAmount);
+		}
 	}
 	if (!item->CallTryPickup (this))
 	{
--- a/src/p_setup.cpp
+++ b/src/p_setup.cpp
@ -1097,7 +1097,7 @@ void LoadZNodes(FileReaderBase &data, int glnodes)
 			{
 				SWORD coord;
 				data >> coord;
-				nodes[i].bbox[j][k] = coord << FRACBITS;
+				nodes[i].bbox[j][k] = coord;
 			}
 		}
 		for (int m = 0; m < 2; ++m)
@ -1641,7 +1641,7 @@ void P_LoadNodes (MapData * map)
 			}
 			for (k = 0; k < 4; k++)
 			{
-				no->bbox[j][k] = LittleShort(mn->bbox[j][k])<<FRACBITS;
+				no->bbox[j][k] = (float)LittleShort(mn->bbox[j][k]);
 			}
 		}
 	}
@ -3367,6 +3367,83 @@ void P_GetPolySpots (MapData * map, TArray<FNodeBuilder::FPolyStart> &spots, TAr
 	}
 }

+
+//===========================================================================
+//
+// P_PrecacheLevel
+//
+// Preloads all relevant graphics for the level.
+//
+//===========================================================================
+
+static void P_PrecacheLevel()
+{
+	int i;
+	BYTE *hitlist;
+	TMap<PClassActor *, bool> actorhitlist;
+	int cnt = TexMan.NumTextures();
+
+	if (demoplayback)
+		return;
+
+	hitlist = new BYTE[cnt];
+	memset(hitlist, 0, cnt);
+
+	AActor *actor;
+	TThinkerIterator<AActor> iterator;
+
+	while ((actor = iterator.Next()))
+	{
+		actorhitlist[actor->GetClass()] = true;
+	}
+
+	for (unsigned i = 0; i < level.info->PrecacheClasses.Size(); i++)
+	{
+		// level.info can only store names, no class pointers.
+		PClassActor *cls = PClass::FindActor(level.info->PrecacheClasses[i]);
+		if (cls != NULL) actorhitlist[cls] = true;
+	}
+
+	for (i = numsectors - 1; i >= 0; i--)
+	{
+		hitlist[sectors[i].GetTexture(sector_t::floor).GetIndex()] |= FTextureManager::HIT_Flat;
+		hitlist[sectors[i].GetTexture(sector_t::ceiling).GetIndex()] |= FTextureManager::HIT_Flat;
+	}
+
+	for (i = numsides - 1; i >= 0; i--)
+	{
+		hitlist[sides[i].GetTexture(side_t::top).GetIndex()] |= FTextureManager::HIT_Wall;
+		hitlist[sides[i].GetTexture(side_t::mid).GetIndex()] |= FTextureManager::HIT_Wall;
+		hitlist[sides[i].GetTexture(side_t::bottom).GetIndex()] |= FTextureManager::HIT_Wall;
+	}
+
+	// Sky texture is always present.
+	// Note that F_SKY1 is the name used to
+	//	indicate a sky floor/ceiling as a flat,
+	//	while the sky texture is stored like
+	//	a wall texture, with an episode dependant
+	//	name.
+
+	if (sky1texture.isValid())
+	{
+		hitlist[sky1texture.GetIndex()] |= FTextureManager::HIT_Sky;
+	}
+	if (sky2texture.isValid())
+	{
+		hitlist[sky2texture.GetIndex()] |= FTextureManager::HIT_Sky;
+	}
+
+	for (unsigned i = 0; i < level.info->PrecacheTextures.Size(); i++)
+	{
+		FTextureID tex = TexMan.CheckForTexture(level.info->PrecacheTextures[i], FTexture::TEX_Wall, FTextureManager::TEXMAN_Overridable | FTextureManager::TEXMAN_TryAny | FTextureManager::TEXMAN_ReturnFirst);
+		if (tex.Exists()) hitlist[tex.GetIndex()] |= FTextureManager::HIT_Wall;
+	}
+
+	Renderer->Precache(hitlist, actorhitlist);
+
+	delete[] hitlist;
+}
+
 extern polyblock_t **PolyBlockMap;

 void P_FreeLevelData ()
@ -4095,7 +4172,7 @@ void P_SetupLevel (const char *lumpname, int position)
 	// preload graphics and sounds
 	if (precache)
 	{
-		TexMan.PrecacheLevel ();
+		P_PrecacheLevel ();
 		S_PrecacheLevel ();
 	}
 	times[17].Unclock();
--- a/src/p_trace.cpp
+++ b/src/p_trace.cpp
@ -494,6 +494,17 @@ bool FTraceInfo::LineCheck(intercept_t *in, double dist, DVector3 hit)
 					// clip to the part of the sector we are in
 					if (hit.Z > ff_top)
 					{
+						// 3D floor height is the same as the floor height. We need to test a second spot to see if it is above or below
+						if (fabs(bf - ff_top) < EQUAL_EPSILON)
+						{
+							double cf = entersector->floorplane.ZatPoint(entersector->centerspot);
+							double ffc = rover->top.plane->ZatPoint(entersector->centerspot);
+							if (ffc > cf)
+							{
+								bf = ff_top - EQUAL_EPSILON;
+							}
+						}
+						
 						// above
 						if (bf < ff_top)
 						{
@ -505,6 +516,17 @@ bool FTraceInfo::LineCheck(intercept_t *in, double dist, DVector3 hit)
 					}
 					else if (hit.Z < ff_bottom)
 					{
+						// 3D floor height is the same as the ceiling height. We need to test a second spot to see if it is above or below
+						if (fabs(bc - ff_bottom) < EQUAL_EPSILON)
+						{
+							double cc = entersector->ceilingplane.ZatPoint(entersector->centerspot);
+							double fcc = rover->bottom.plane->ZatPoint(entersector->centerspot);
+							if (fcc < cc)
+							{
+								bc = ff_bottom + EQUAL_EPSILON;
+							}
+						}
+
 						//below
 						if (bc > ff_bottom)
 						{
--- a/src/po_man.cpp
+++ b/src/po_man.cpp
@ -1919,7 +1919,7 @@ static double PartitionDistance(FPolyVertex *vt, node_t *node)
 //
 //==========================================================================

-static void AddToBBox(fixed_t child[4], fixed_t parent[4])
+static void AddToBBox(float child[4], float parent[4])
 {
 	if (child[BOXTOP] > parent[BOXTOP])
 	{
@ -1945,10 +1945,10 @@ static void AddToBBox(fixed_t child[4], fixed_t parent[4])
 //
 //==========================================================================

-static void AddToBBox(FPolyVertex *v, fixed_t bbox[4])
+static void AddToBBox(FPolyVertex *v, float bbox[4])
 {
-	fixed_t x = FLOAT2FIXED(v->pos.X);
-	fixed_t y = FLOAT2FIXED(v->pos.Y);
+	float x = float(v->pos.X);
+	float y = float(v->pos.Y);
 	if (x < bbox[BOXLEFT])
 	{
 		bbox[BOXLEFT] = x;
@ -1973,7 +1973,7 @@ static void AddToBBox(FPolyVertex *v, fixed_t bbox[4])
 //
 //==========================================================================

-static void SplitPoly(FPolyNode *pnode, void *node, fixed_t bbox[4])
+static void SplitPoly(FPolyNode *pnode, void *node, float bbox[4])
 {
 	static TArray<FPolySeg> lists[2];
 	static const double POLY_EPSILON = 0.3125;
@ -2110,7 +2110,7 @@ static void SplitPoly(FPolyNode *pnode, void *node, fixed_t bbox[4])

 		// calculate bounding box for this polynode
 		assert(pnode->segs.Size() != 0);
-		fixed_t subbbox[4] = { FIXED_MIN, FIXED_MAX, FIXED_MAX, FIXED_MIN };
+		float subbbox[4] = { FLT_MIN, FLT_MAX, FLT_MAX, FLT_MIN };

 		for (unsigned i = 0; i < pnode->segs.Size(); ++i)
 		{
@ -2134,7 +2134,7 @@ void FPolyObj::CreateSubsectorLinks()
 	// Even though we don't care about it, we need to initialize this
 	// bounding box to something so that Valgrind won't complain about it
 	// when SplitPoly modifies it.
-	fixed_t dummybbox[4] = { 0 };
+	float dummybbox[4] = { 0 };

 	node->poly = this;
 	node->segs.Resize(Sidedefs.Size());
--- a/src/posix/cocoa/i_video.mm
+++ b/src/posix/cocoa/i_video.mm
@ -57,9 +57,12 @@
 #include "v_video.h"
 #include "version.h"

+#include "gl/system/gl_system.h"
+#include "gl/data/gl_vertexbuffer.h"
 #include "gl/renderer/gl_renderer.h"
 #include "gl/system/gl_framebuffer.h"
 #include "gl/system/gl_interface.h"
+#include "gl/textures/gl_samplers.h"
 #include "gl/utility/gl_clock.h"

 #undef Class
@ -1146,22 +1149,14 @@ void CocoaFrameBuffer::Flip()
 // ---------------------------------------------------------------------------


-static const uint32_t GAMMA_TABLE_ALPHA = 0xFF000000;
-
-
 SDLGLFB::SDLGLFB(void*, const int width, const int height, int, int, const bool fullscreen)
 : DFrameBuffer(width, height)
 , m_lock(-1)
 , m_isUpdatePending(false)
-, m_supportsGamma(true)
-, m_gammaProgram("gamma_correction")
-, m_gammaTexture(GAMMA_TABLE_SIZE, 1, true)
 {
 }

 SDLGLFB::SDLGLFB()
-: m_gammaProgram(nullptr)
-, m_gammaTexture(0, 0, false)
 {
 }

@ -1242,24 +1237,6 @@ void SDLGLFB::SwapBuffers()

 void SDLGLFB::SetGammaTable(WORD* table)
 {
-	const WORD* const red   = &table[  0];
-	const WORD* const green = &table[256];
-	const WORD* const blue  = &table[512];
-
-	for (size_t i = 0; i < GAMMA_TABLE_SIZE; ++i)
-	{
-		// Convert 16 bits colors to 8 bits by dividing on 256
-
-		const uint32_t r =   red[i] >> 8;
-		const uint32_t g = green[i] >> 8;
-		const uint32_t b =  blue[i] >> 8;
-
-		m_gammaTable[i] = GAMMA_TABLE_ALPHA + (b << 16) + (g << 8) + r;
-	}
-
-	m_gammaTexture.CreateTexture(
-		reinterpret_cast<unsigned char*>(m_gammaTable),
-		GAMMA_TABLE_SIZE, 1, false, 1, 0);
 }


@ -1275,38 +1252,38 @@ void BoundTextureSetFilter(const GLenum target, const GLint filter)
 	glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 }

+EXTERN_CVAR(Float, vid_brightness)
+EXTERN_CVAR(Float, vid_contrast)
+
 void BoundTextureDraw2D(const GLsizei width, const GLsizei height)
 {
-	const bool flipX = width  < 0;
-	const bool flipY = height < 0;
+	gl_RenderState.SetEffect(EFF_GAMMACORRECTION);
+	gl_RenderState.SetTextureMode(TM_OPAQUE);
+	gl_RenderState.AlphaFunc(GL_GEQUAL, 0.f);
+	gl_RenderState.SetColor(Gamma, vid_contrast, vid_brightness);
+	gl_RenderState.Apply();

-	const float u0 = flipX ? 1.0f : 0.0f;
-	const float v0 = flipY ? 1.0f : 0.0f;
-	const float u1 = flipX ? 0.0f : 1.0f;
-	const float v1 = flipY ? 0.0f : 1.0f;
+	static const float x  = 0.f;
+	static const float y  = 0.f;
+	const float w = float(width);
+	const float h = float(height);

-	const float x1 = 0.0f;
-	const float y1 = 0.0f;
-	const float x2 = abs(width );
-	const float y2 = abs(height);
+	static const float u1 = 0.f;
+	static const float v1 = 1.f;
+	static const float u2 = 1.f;
+	static const float v2 = 0.f;

-	glDisable(GL_BLEND);
-	glDisable(GL_ALPHA_TEST);
+	FFlatVertexBuffer* const vbo = GLRenderer->mVBO;
+	FFlatVertex* ptr = vbo->GetBuffer();

-	glBegin(GL_QUADS);
-	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-	glTexCoord2f(u0, v1);
-	glVertex2f(x1, y1);
-	glTexCoord2f(u1, v1);
-	glVertex2f(x2, y1);
-	glTexCoord2f(u1, v0);
-	glVertex2f(x2, y2);
-	glTexCoord2f(u0, v0);
-	glVertex2f(x1, y2);
-	glEnd();
+	ptr->Set(x,     y,     0, u1, v1); ++ptr;
+	ptr->Set(x,     y + h, 0, u1, v2); ++ptr;
+	ptr->Set(x + w, y,     0, u2, v1); ++ptr;
+	ptr->Set(x + w, y + h, 0, u2, v2); ++ptr;

-	glEnable(GL_ALPHA_TEST);
-	glEnable(GL_BLEND);
+	vbo->RenderCurrent(ptr, GL_TRIANGLE_STRIP);
+
+	gl_RenderState.SetEffect(EFF_NONE);
 }

 bool BoundTextureSaveAsPNG(const GLenum target, const char* const path)
@ -1390,7 +1367,7 @@ RenderTarget::RenderTarget(const GLsizei width, const GLsizei height)
 	glGenFramebuffersEXT(1, &m_ID);

 	Bind();
-	m_texture.CreateTexture(NULL, width, height, false, 0, 0);
+	m_texture.CreateTexture(NULL, width, height, 0, false, 0);
 	m_texture.BindToFrameBuffer();
 	Unbind();
 }
@ -1436,19 +1413,7 @@ CocoaOpenGLFrameBuffer::CocoaOpenGLFrameBuffer(void* hMonitor, int width, int he
 , m_renderTarget(width, height)
 {
 	SetSmoothPicture(gl_smooth_rendered);
-/*
-	// Setup uniform samplers for gamma correction shader

-	m_gammaProgram.Load("GammaCorrection", "shaders/glsl/main.vp",
-		"shaders/glsl/gamma_correction.fp", NULL, "");
-
-	const GLuint program = m_gammaProgram.GetHandle();
-
-	glUseProgram(program);
-	glUniform1i(glGetUniformLocation(program, "backbuffer"), 0);
-	glUniform1i(glGetUniformLocation(program, "gammaTable"), 1);
-	glUseProgram(0);
-*/
 	// Fill render target with black color

 	m_renderTarget.Bind();
@ -1502,9 +1467,7 @@ void CocoaOpenGLFrameBuffer::GetScreenshotBuffer(const BYTE*& buffer, int& pitch
 void CocoaOpenGLFrameBuffer::DrawRenderTarget()
 {
 	m_renderTarget.Unbind();
-
-	m_renderTarget.GetColorTexture().Bind(0, 0, 0);
-	m_gammaTexture.Bind(1, 0, 0);
+	m_renderTarget.GetColorTexture().Bind(0, 0, false);

 	if (rbOpts.dirty)
 	{
@ -1518,7 +1481,6 @@ void CocoaOpenGLFrameBuffer::DrawRenderTarget()

 	glViewport(rbOpts.shiftX, rbOpts.shiftY, rbOpts.width, rbOpts.height);

-	//m_gammaProgram.Bind();
 	BoundTextureDraw2D(Width, Height);

 	glViewport(0, 0, Width, Height);
@ -1528,7 +1490,7 @@ void CocoaOpenGLFrameBuffer::DrawRenderTarget()
 void CocoaOpenGLFrameBuffer::SetSmoothPicture(const bool smooth)
 {
 	FHardwareTexture& texture = m_renderTarget.GetColorTexture();
-	texture.Bind(0, 0, 0);
+	texture.Bind(0, 0, false);
 	BoundTextureSetFilter(GL_TEXTURE_2D, smooth ? GL_LINEAR : GL_NEAREST);
 }

--- a/src/posix/cocoa/sdlglvideo.h
+++ b/src/posix/cocoa/sdlglvideo.h
@ -68,14 +68,7 @@ protected:
 	int                 m_lock;
 	bool                m_isUpdatePending;

-	bool                m_supportsGamma;
-
-	FShader             m_gammaProgram;
-	FHardwareTexture    m_gammaTexture;
-
-	static const size_t GAMMA_TABLE_SIZE = 256;
-	uint32_t            m_gammaTable[GAMMA_TABLE_SIZE];
-
+	static const bool   m_supportsGamma = true;

 	SDLGLFB();

--- a/src/r_data/voxels.cpp
+++ b/src/r_data/voxels.cpp
@ -501,25 +501,33 @@ static void VOX_ReadOptions(FScanner &sc, VoxelOptions &opts)
 		}
 		else if (sc.Compare("spin"))
 		{
+			int mul = 1;
 			sc.MustGetToken('=');
+			if (sc.CheckToken('-')) mul = -1;
 			sc.MustGetToken(TK_IntConst);
-			opts.DroppedSpin = opts.PlacedSpin = sc.Number;
+			opts.DroppedSpin = opts.PlacedSpin = sc.Number*mul;
 		}
 		else if (sc.Compare("placedspin"))
 		{
+			int mul = 1;
 			sc.MustGetToken('=');
+			if (sc.CheckToken('-')) mul = -1;
 			sc.MustGetToken(TK_IntConst);
-			opts.PlacedSpin = sc.Number;
+			opts.PlacedSpin = sc.Number*mul;
 		}
 		else if (sc.Compare("droppedspin"))
 		{
+			int mul = 1;
 			sc.MustGetToken('=');
+			if (sc.CheckToken('-')) mul = -1;
 			sc.MustGetToken(TK_IntConst);
-			opts.DroppedSpin = sc.Number;
+			opts.DroppedSpin = sc.Number*mul;
 		}
 		else if (sc.Compare("angleoffset"))
 		{
+			int mul = 1;
 			sc.MustGetToken('=');
+			if (sc.CheckToken('-')) mul = -1;
 			sc.MustGetAnyToken();
 			if (sc.TokenType == TK_IntConst)
 			{
@ -529,7 +537,7 @@ static void VOX_ReadOptions(FScanner &sc, VoxelOptions &opts)
 			{
 				sc.TokenMustBe(TK_FloatConst);
 			}
-			opts.AngleOffset = sc.Float + 90.;
+			opts.AngleOffset = mul * sc.Float + 90.;
 		}
 		else if (sc.Compare("overridepalette"))
 		{
--- a/src/r_defs.h
+++ b/src/r_defs.h
@ -1476,7 +1476,11 @@ struct node_t
 	fixed_t		y;
 	fixed_t		dx;
 	fixed_t		dy;
-	fixed_t		bbox[2][4];		// Bounding box for each child.
+	union
+	{
+		float	bbox[2][4];		// Bounding box for each child.
+		fixed_t	nb_bbox[2][4];	// Used by nodebuilder.
+	};
 	float		len;
 	union
 	{
--- a/src/r_plane.cpp
+++ b/src/r_plane.cpp
@ -1624,7 +1624,7 @@ void R_DrawTiltedPlane (visplane_t *pl, double _xscale, double _yscale, fixed_t
 	double lxscale, lyscale;
 	double xscale, yscale;
 	FVector3 p, m, n;
-	DAngle ang;
+	double ang, planeang, cosine, sine;
 	double zeroheight;

 	if (alpha <= 0)
@ -1640,37 +1640,44 @@ void R_DrawTiltedPlane (visplane_t *pl, double _xscale, double _yscale, fixed_t

 	pviewx = xs_ToFixed(32 - ds_xbits, pl->xform.xOffs * pl->xform.xScale);
 	pviewy = xs_ToFixed(32 - ds_ybits, pl->xform.yOffs * pl->xform.yScale);
+	planeang = (pl->xform.Angle + pl->xform.baseAngle).Radians();

 	// p is the texture origin in view space
 	// Don't add in the offsets at this stage, because doing so can result in
 	// errors if the flat is rotated.
-	ang = DAngle(270.) - ViewAngle;
-	p[0] = ViewPos.X * ang.Cos() - ViewPos.Y * ang.Sin();
-	p[2] = ViewPos.X * ang.Sin() + ViewPos.Y * ang.Cos();
+	ang = M_PI*3/2 - ViewAngle.Radians();
+	cosine = cos(ang), sine = sin(ang);
+	p[0] = ViewPos.X * cosine - ViewPos.Y * sine;
+	p[2] = ViewPos.X * sine + ViewPos.Y * cosine;
 	p[1] = pl->height.ZatPoint(0.0, 0.0) - ViewPos.Z;

 	// m is the v direction vector in view space
-	ang = DAngle(180.) - ViewAngle;
-	m[0] = yscale * cos(ang.Radians());
-	m[2] = yscale * sin(ang.Radians());
+	ang = ang - M_PI / 2 - planeang;
+	cosine = cos(ang), sine = sin(ang);
+	m[0] = yscale * cosine;
+	m[2] = yscale * sine;
 //	m[1] = pl->height.ZatPointF (0, iyscale) - pl->height.ZatPointF (0,0));
 //	VectorScale2 (m, 64.f/VectorLength(m));

 	// n is the u direction vector in view space
-	ang += 90;
-	n[0] = -xscale * cos(ang.Radians());
-	n[2] = -xscale * sin(ang.Radians());
+#if 0
+	//let's use the sin/cosine we already know instead of computing new ones
+	ang += M_PI/2
+	n[0] = -xscale * cos(ang);
+	n[2] = -xscale * sin(ang);
+#else
+	n[0] = xscale * sine;
+	n[2] = -xscale * cosine;
+#endif
 //	n[1] = pl->height.ZatPointF (ixscale, 0) - pl->height.ZatPointF (0,0));
 //	VectorScale2 (n, 64.f/VectorLength(n));

 	// This code keeps the texture coordinates constant across the x,y plane no matter
 	// how much you slope the surface. Use the commented-out code above instead to keep
 	// the textures a constant size across the surface's plane instead.
-	ang = pl->xform.Angle + pl->xform.baseAngle;
-	double cosine = cos(ang.Radians()), sine = sin(ang.Radians());
+	cosine = cos(planeang), sine = sin(planeang);
 	m[1] = pl->height.ZatPoint(ViewPos.X + yscale * sine, ViewPos.Y + yscale * cosine) - zeroheight;
-	ang += 90;
-	n[1] = pl->height.ZatPoint(ViewPos.X + xscale * sine, ViewPos.Y + xscale * cosine) - zeroheight;
+	n[1] = pl->height.ZatPoint(ViewPos.X - xscale * cosine, ViewPos.Y + xscale * sine) - zeroheight;

 	plane_su = p ^ m;
 	plane_sv = p ^ n;
--- a/src/r_renderer.h
+++ b/src/r_renderer.h
@ -28,7 +28,7 @@ struct FRenderer
 	virtual bool UsesColormap() const = 0;

 	// precache one texture
-	virtual void PrecacheTexture(FTexture *tex, int cache) = 0;
+	virtual void Precache(BYTE *texhitlist, TMap<PClassActor*, bool> &actorhitlist) = 0;

 	// render 3D view
 	virtual void RenderView(player_t *player) = 0;
--- a/src/r_segs.cpp
+++ b/src/r_segs.cpp
@ -2016,9 +2016,9 @@ void R_NewWall (bool needlights)
 	midtexture = toptexture = bottomtexture = 0;

 	if (sidedef == linedef->sidedef[0] &&
-		(linedef->isVisualPortal() || (linedef->special == Line_Mirror && r_drawmirrors))) // [ZZ] compatibility with r_drawmirrors cvar that existed way before portals
+		(linedef->special == Line_Mirror && r_drawmirrors)) // [ZZ] compatibility with r_drawmirrors cvar that existed way before portals
 	{
-		markfloor = markceiling = true; // act like an one-sided wall here (todo: check how does this work with transparency)
+		markfloor = markceiling = true; // act like a one-sided wall here (todo: check how does this work with transparency)
 		rw_markportal = true;
 	}
 	else if (backsector == NULL)
@ -2027,7 +2027,11 @@ void R_NewWall (bool needlights)
 		// a single sided line is terminal, so it must mark ends
 		markfloor = markceiling = true;
 		// [RH] Horizon lines do not need to be textured
-		if (linedef->special != Line_Horizon)
+		if (linedef->isVisualPortal())
+		{
+			rw_markportal = true;
+		}
+		else if (linedef->special != Line_Horizon)
 		{
 			midtexture = TexMan(sidedef->GetTexture(side_t::mid), true);
 			rw_offset_mid = FLOAT2FIXED(sidedef->GetTextureXOffset(side_t::mid));
@ -2102,8 +2106,12 @@ void R_NewWall (bool needlights)
 			rw_frontlowertop = backsector->GetPlaneTexZ(sector_t::ceiling);
 		}

-		if ((rw_backcz1 <= rw_frontfz1 && rw_backcz2 <= rw_frontfz2) ||
-			(rw_backfz1 >= rw_frontcz1 && rw_backfz2 >= rw_frontcz2))
+		if (linedef->isVisualPortal())
+		{
+			markceiling = markfloor = true;
+		}
+		else if ((rw_backcz1 <= rw_frontfz1 && rw_backcz2 <= rw_frontfz2) ||
+				 (rw_backfz1 >= rw_frontcz1 && rw_backfz2 >= rw_frontcz2))
 		{
 			// closed door
 			markceiling = markfloor = true;
@ -2260,6 +2268,7 @@ void R_NewWall (bool needlights)
 				rw_bottomtexturemid += rowoffset;
 			}
 		}
+		rw_markportal = linedef->isVisualPortal();
 	}

 	// if a floor / ceiling plane is on the wrong side of the view plane,
--- a/src/s_advsound.cpp
+++ b/src/s_advsound.cpp
@ -500,6 +500,7 @@ int S_AddSoundLump (const char *logicalname, int lump)
 	sfxinfo_t newsfx;

 	newsfx.data.Clear();
+    newsfx.data3d.Clear();
 	newsfx.name = logicalname;
 	newsfx.lumpnum = lump;
 	newsfx.next = 0;
--- a/src/s_sound.cpp
+++ b/src/s_sound.cpp
@ -99,6 +99,7 @@ extern float S_GetMusicVolume (const char *music);

 // PRIVATE FUNCTION PROTOTYPES ---------------------------------------------

+static void S_LoadSound3D(sfxinfo_t *sfx);
 static bool S_CheckSoundLimit(sfxinfo_t *sfx, const FVector3 &pos, int near_limit, float limit_range, AActor *actor, int channel);
 static bool S_IsChannelUsed(AActor *actor, int channel, int *seen);
 static void S_ActivatePlayList(bool goBack);
@ -547,8 +548,11 @@ void S_UnloadSound (sfxinfo_t *sfx)
 {
 	if (sfx->data.isValid())
 	{
+        if(sfx->data3d.isValid() && sfx->data != sfx->data3d)
+            GSnd->UnloadSound(sfx->data3d);
 		GSnd->UnloadSound(sfx->data);
 		sfx->data.Clear();
+        sfx->data3d.Clear();
 		DPrintf("Unloaded sound \"%s\" (%td)\n", sfx->name.GetChars(), sfx - &S_sfx[0]);
 	}
 }
@ -1099,9 +1103,10 @@ static FSoundChan *S_StartSound(AActor *actor, const sector_t *sec, const FPolyO

 		if (attenuation > 0)
 		{
+            S_LoadSound3D(sfx);
 			SoundListener listener;
 			S_SetListener(listener, players[consoleplayer].camera);
-			chan = (FSoundChan*)GSnd->StartSound3D (sfx->data, &listener, float(volume), rolloff, float(attenuation), pitch, basepriority, pos, vel, channel, startflags, NULL);
+            chan = (FSoundChan*)GSnd->StartSound3D (sfx->data3d, &listener, float(volume), rolloff, float(attenuation), pitch, basepriority, pos, vel, channel, startflags, NULL);
 		}
 		else
 		{
@ -1195,12 +1200,13 @@ void S_RestartSound(FSoundChan *chan)
 			return;
 		}

+        S_LoadSound3D(sfx);
 		SoundListener listener;
 		S_SetListener(listener, players[consoleplayer].camera);

 		chan->ChanFlags &= ~(CHAN_EVICTED|CHAN_ABSTIME);
-		ochan = (FSoundChan*)GSnd->StartSound3D(sfx->data, &listener, chan->Volume, &chan->Rolloff, chan->DistanceScale, chan->Pitch,
-			chan->Priority, pos, vel, chan->EntChannel, startflags, chan);
+        ochan = (FSoundChan*)GSnd->StartSound3D(sfx->data3d, &listener, chan->Volume, &chan->Rolloff, chan->DistanceScale, chan->Pitch,
+            chan->Priority, pos, vel, chan->EntChannel, startflags, chan);
 	}
 	else
 	{
@ -1340,31 +1346,35 @@ sfxinfo_t *S_LoadSound(sfxinfo_t *sfx)
 			BYTE *sfxdata = new BYTE[size];
 			wlump.Read(sfxdata, size);
 			SDWORD dmxlen = LittleLong(((SDWORD *)sfxdata)[1]);
+            std::pair<SoundHandle,bool> snd;

 			// If the sound is voc, use the custom loader.
 			if (strncmp ((const char *)sfxdata, "Creative Voice File", 19) == 0)
 			{
-				sfx->data = GSnd->LoadSoundVoc(sfxdata, size);
+				snd = GSnd->LoadSoundVoc(sfxdata, size);
 			}
 			// If the sound is raw, just load it as such.
 			else if (sfx->bLoadRAW)
 			{
-				sfx->data = GSnd->LoadSoundRaw(sfxdata, size, sfx->RawRate, 1, 8, sfx->LoopStart);
+				snd = GSnd->LoadSoundRaw(sfxdata, size, sfx->RawRate, 1, 8, sfx->LoopStart);
 			}
 			// Otherwise, try the sound as DMX format.
 			else if (((BYTE *)sfxdata)[0] == 3 && ((BYTE *)sfxdata)[1] == 0 && dmxlen <= size - 8)
 			{
 				int frequency = LittleShort(((WORD *)sfxdata)[1]);
 				if (frequency == 0) frequency = 11025;
-				sfx->data = GSnd->LoadSoundRaw(sfxdata+8, dmxlen, frequency, 1, 8, sfx->LoopStart);
+				snd = GSnd->LoadSoundRaw(sfxdata+8, dmxlen, frequency, 1, 8, sfx->LoopStart);
 			}
 			// If that fails, let the sound system try and figure it out.
 			else
 			{
-				sfx->data = GSnd->LoadSound(sfxdata, size);
+				snd = GSnd->LoadSound(sfxdata, size);
 			}
-
 			delete[] sfxdata;
+
+            sfx->data = snd.first;
+            if(snd.second)
+                sfx->data3d = sfx->data;
 		}

 		if (!sfx->data.isValid())
@ -1380,6 +1390,53 @@ sfxinfo_t *S_LoadSound(sfxinfo_t *sfx)
 	return sfx;
 }

+static void S_LoadSound3D(sfxinfo_t *sfx)
+{
+    if (GSnd->IsNull()) return;
+
+    if(sfx->data3d.isValid())
+        return;
+
+    unsigned int i;
+
+    DPrintf("Loading monoized sound \"%s\" (%td)\n", sfx->name.GetChars(), sfx - &S_sfx[0]);
+
+    int size = Wads.LumpLength(sfx->lumpnum);
+    if(size <= 0) return;
+
+    FWadLump wlump = Wads.OpenLumpNum(sfx->lumpnum);
+    BYTE *sfxdata = new BYTE[size];
+    wlump.Read(sfxdata, size);
+    SDWORD dmxlen = LittleLong(((SDWORD *)sfxdata)[1]);
+    std::pair<SoundHandle,bool> snd;
+
+    // If the sound is voc, use the custom loader.
+    if (strncmp ((const char *)sfxdata, "Creative Voice File", 19) == 0)
+    {
+        snd = GSnd->LoadSoundVoc(sfxdata, size, true);
+    }
+    // If the sound is raw, just load it as such.
+    else if (sfx->bLoadRAW)
+    {
+        snd = GSnd->LoadSoundRaw(sfxdata, size, sfx->RawRate, 1, 8, sfx->LoopStart, true);
+    }
+    // Otherwise, try the sound as DMX format.
+    else if (((BYTE *)sfxdata)[0] == 3 && ((BYTE *)sfxdata)[1] == 0 && dmxlen <= size - 8)
+    {
+        int frequency = LittleShort(((WORD *)sfxdata)[1]);
+        if (frequency == 0) frequency = 11025;
+        snd = GSnd->LoadSoundRaw(sfxdata+8, dmxlen, frequency, 1, 8, sfx->LoopStart, -1, true);
+    }
+    // If that fails, let the sound system try and figure it out.
+    else
+    {
+        snd = GSnd->LoadSound(sfxdata, size, true);
+    }
+    delete[] sfxdata;
+
+    sfx->data3d = snd.first;
+}
+
 //==========================================================================
 //
 // S_CheckSingular
--- a/src/s_sound.h
+++ b/src/s_sound.h
@ -37,6 +37,9 @@ struct sfxinfo_t
 	// Next field is for use by the system sound interface.
 	// A non-null data means the sound has been loaded.
 	SoundHandle	data;
+    // Also for the sound interface. Used for 3D positional
+    // sounds, may be the same as data.
+    SoundHandle data3d;

 	FString		name;					// [RH] Sound name defined in SNDINFO
 	int 		lumpnum;				// lump number of sfx
--- a/src/sound/i_sound.cpp
+++ b/src/sound/i_sound.cpp
@ -132,15 +132,15 @@ public:
 	void SetMusicVolume (float volume)
 	{
 	}
-	SoundHandle LoadSound(BYTE *sfxdata, int length)
+	std::pair<SoundHandle,bool> LoadSound(BYTE *sfxdata, int length, bool monoize)
 	{
 		SoundHandle retval = { NULL };
-		return retval;
+		return std::make_pair(retval, true);
 	}
-	SoundHandle LoadSoundRaw(BYTE *sfxdata, int length, int frequency, int channels, int bits, int loopstart, int loopend)
+	std::pair<SoundHandle,bool> LoadSoundRaw(BYTE *sfxdata, int length, int frequency, int channels, int bits, int loopstart, int loopend, bool monoize)
 	{
 		SoundHandle retval = { NULL };
-		return retval;
+        return std::make_pair(retval, true);
 	}
 	void UnloadSound (SoundHandle sfx)
 	{
@ -425,7 +425,7 @@ FString SoundStream::GetStats()
 //
 //==========================================================================

-SoundHandle SoundRenderer::LoadSoundVoc(BYTE *sfxdata, int length)
+std::pair<SoundHandle,bool> SoundRenderer::LoadSoundVoc(BYTE *sfxdata, int length, bool monoize)
 {
 	BYTE * data = NULL;
 	int len, frequency, channels, bits, loopstart, loopend;
@ -569,7 +569,7 @@ SoundHandle SoundRenderer::LoadSoundVoc(BYTE *sfxdata, int length)
 		}

 	} while (false);
-	SoundHandle retval = LoadSoundRaw(data, len, frequency, channels, bits, loopstart, loopend);
+	std::pair<SoundHandle,bool> retval = LoadSoundRaw(data, len, frequency, channels, bits, loopstart, loopend, monoize);
 	if (data) delete[] data;
 	return retval;
 }
--- a/src/sound/i_sound.h
+++ b/src/sound/i_sound.h
@ -95,9 +95,10 @@ public:
 	virtual bool IsNull() { return false; }
 	virtual void SetSfxVolume (float volume) = 0;
 	virtual void SetMusicVolume (float volume) = 0;
-	virtual SoundHandle LoadSound(BYTE *sfxdata, int length) = 0;
-	SoundHandle LoadSoundVoc(BYTE *sfxdata, int length);
-	virtual SoundHandle LoadSoundRaw(BYTE *sfxdata, int length, int frequency, int channels, int bits, int loopstart, int loopend = -1) = 0;
+    // Returns a pair containing a sound handle and a boolean indicating the sound can be used in 3D.
+	virtual std::pair<SoundHandle,bool> LoadSound(BYTE *sfxdata, int length, bool monoize=false) = 0;
+	std::pair<SoundHandle,bool> LoadSoundVoc(BYTE *sfxdata, int length, bool monoize=false);
+	virtual std::pair<SoundHandle,bool> LoadSoundRaw(BYTE *sfxdata, int length, int frequency, int channels, int bits, int loopstart, int loopend = -1, bool monoize = false) = 0;
 	virtual void UnloadSound (SoundHandle sfx) = 0;	// unloads a sound from memory
 	virtual unsigned int GetMSLength(SoundHandle sfx) = 0;	// Gets the length of a sound at its default frequency
 	virtual unsigned int GetSampleLength(SoundHandle sfx) = 0;	// Gets the length of a sound at its default frequency
--- a/src/sound/i_soundinternal.h
+++ b/src/sound/i_soundinternal.h
@ -91,6 +91,11 @@ struct SoundHandle

 	bool isValid() const { return data != NULL; }
 	void Clear() { data = NULL; }
+
+	bool operator==(const SoundHandle &rhs) const
+	{ return data == rhs.data; }
+	bool operator!=(const SoundHandle &rhs) const
+	{ return !(*this == rhs); }
 };

 struct FISoundChannel
--- a/src/sound/oalsound.cpp
+++ b/src/sound/oalsound.cpp
@ -1019,11 +1019,11 @@ float OpenALSoundRenderer::GetOutputRate()
 }


-SoundHandle OpenALSoundRenderer::LoadSoundRaw(BYTE *sfxdata, int length, int frequency, int channels, int bits, int loopstart, int loopend)
+std::pair<SoundHandle,bool> OpenALSoundRenderer::LoadSoundRaw(BYTE *sfxdata, int length, int frequency, int channels, int bits, int loopstart, int loopend, bool monoize)
 {
    SoundHandle retval = { NULL };

-    if(length == 0) return retval;
+    if(length == 0) return std::make_pair(retval, true);

    if(bits == -8)
    {
@ -1033,6 +1033,33 @@ SoundHandle OpenALSoundRenderer::LoadSoundRaw(BYTE *sfxdata, int length, int fre
        bits = -bits;
    }

+    if(channels > 1 && monoize)
+    {
+        size_t frames = length / channels * 8 / bits;
+        if(bits == 16)
+        {
+            for(size_t i = 0;i < frames;i++)
+            {
+                int sum = 0;
+                for(int c = 0;c < channels;c++)
+                    sum = ((short*)sfxdata)[i*channels + c];
+                ((short*)sfxdata)[i] = sum / channels;
+            }
+        }
+        else if(bits == 8)
+        {
+            for(size_t i = 0;i < frames;i++)
+            {
+                int sum = 0;
+                for(int c = 0;c < channels;c++)
+                    sum = sfxdata[i*channels + c] - 128;
+                sfxdata[i] = (sum / channels) + 128;
+            }
+        }
+        length /= channels;
+        channels = 1;
+    }
+
    ALenum format = AL_NONE;
    if(bits == 16)
    {
@ -1048,7 +1075,7 @@ SoundHandle OpenALSoundRenderer::LoadSoundRaw(BYTE *sfxdata, int length, int fre
    if(format == AL_NONE || frequency <= 0)
    {
        Printf("Unhandled format: %d bit, %d channel, %d hz\n", bits, channels, frequency);
-        return retval;
+        return std::make_pair(retval, true);
    }
    length -= length%(channels*bits/8);

@ -1061,7 +1088,7 @@ SoundHandle OpenALSoundRenderer::LoadSoundRaw(BYTE *sfxdata, int length, int fre
        Printf("Failed to buffer data: %s\n", alGetString(err));
        alDeleteBuffers(1, &buffer);
        getALError();
-        return retval;
+        return std::make_pair(retval, true);
    }

    if((loopstart > 0 || loopend > 0) && AL.SOFT_loop_points)
@ -1085,10 +1112,10 @@ SoundHandle OpenALSoundRenderer::LoadSoundRaw(BYTE *sfxdata, int length, int fre
    }

    retval.data = MAKE_PTRID(buffer);
-    return retval;
+    return std::make_pair(retval, channels==1);
 }

-SoundHandle OpenALSoundRenderer::LoadSound(BYTE *sfxdata, int length)
+std::pair<SoundHandle,bool> OpenALSoundRenderer::LoadSound(BYTE *sfxdata, int length, bool monoize)
 {
    SoundHandle retval = { NULL };
    MemoryReader reader((const char*)sfxdata, length);
@ -1098,15 +1125,15 @@ SoundHandle OpenALSoundRenderer::LoadSound(BYTE *sfxdata, int length)
    int srate;

    SoundDecoder *decoder = CreateDecoder(&reader);
-    if(!decoder) return retval;
+    if(!decoder) return std::make_pair(retval, true);

    decoder->getInfo(&srate, &chans, &type);
-    if(chans == ChannelConfig_Mono)
+    if(chans == ChannelConfig_Mono || monoize)
    {
        if(type == SampleType_UInt8) format = AL_FORMAT_MONO8;
        if(type == SampleType_Int16) format = AL_FORMAT_MONO16;
    }
-    if(chans == ChannelConfig_Stereo)
+    else if(chans == ChannelConfig_Stereo)
    {
        if(type == SampleType_UInt8) format = AL_FORMAT_STEREO8;
        if(type == SampleType_Int16) format = AL_FORMAT_STEREO16;
@ -1117,10 +1144,28 @@ SoundHandle OpenALSoundRenderer::LoadSound(BYTE *sfxdata, int length)
        Printf("Unsupported audio format: %s, %s\n", GetChannelConfigName(chans),
               GetSampleTypeName(type));
        delete decoder;
-        return retval;
+        return std::make_pair(retval, true);
    }

    TArray<char> data = decoder->readAll();
+    if(chans != ChannelConfig_Mono && monoize)
+    {
+        // TODO: Handle this better if ChannelConfig ever gets more channel configurations.
+        size_t frames = data.Size() / 2 / (type == SampleType_Int16 ? 2 : 1);
+        if(type == SampleType_Int16)
+        {
+            short *sfxdata = (short*)&data[0];
+            for(size_t i = 0;i < frames;i++)
+                sfxdata[i] = (sfxdata[i*2 + 0]-0 + sfxdata[i*2 + 1]-0)/2;
+        }
+        else if(type == SampleType_UInt8)
+        {
+            BYTE *sfxdata = (BYTE*)&data[0];
+            for(size_t i = 0;i < frames;i++)
+                sfxdata[i] = (sfxdata[i*2 + 0]-128 + sfxdata[i*2 + 1]-128)/2 + 128;
+        }
+        data.Resize(data.Size()/2);
+    }

    ALuint buffer = 0;
    alGenBuffers(1, &buffer);
@ -1133,12 +1178,12 @@ SoundHandle OpenALSoundRenderer::LoadSound(BYTE *sfxdata, int length)
        alDeleteBuffers(1, &buffer);
        getALError();
        delete decoder;
-        return retval;
+        return std::make_pair(retval, true);
    }

    retval.data = MAKE_PTRID(buffer);
    delete decoder;
-    return retval;
+    return std::make_pair(retval, (chans == ChannelConfig_Mono || monoize));
 }

 void OpenALSoundRenderer::UnloadSound(SoundHandle sfx)
--- a/src/sound/oalsound.h
+++ b/src/sound/oalsound.h
@ -71,8 +71,8 @@ public:

 	virtual void SetSfxVolume(float volume);
 	virtual void SetMusicVolume(float volume);
-	virtual SoundHandle LoadSound(BYTE *sfxdata, int length);
-	virtual SoundHandle LoadSoundRaw(BYTE *sfxdata, int length, int frequency, int channels, int bits, int loopstart, int loopend = -1);
+	virtual std::pair<SoundHandle,bool> LoadSound(BYTE *sfxdata, int length, bool monoize);
+	virtual std::pair<SoundHandle,bool> LoadSoundRaw(BYTE *sfxdata, int length, int frequency, int channels, int bits, int loopstart, int loopend = -1, bool monoize = false);
 	virtual void UnloadSound(SoundHandle sfx);
 	virtual unsigned int GetMSLength(SoundHandle sfx);
 	virtual unsigned int GetSampleLength(SoundHandle sfx);
--- a/src/textures/animations.cpp
+++ b/src/textures/animations.cpp
@ -219,7 +219,7 @@ void FTextureManager::InitAnimated (void)
 			// SMMU-style swirly hack? Don't apply on already-warping texture
 			if (animspeed > 65535 && tex1 != NULL && !tex1->bWarped)
 			{
-				FTexture *warper = new FWarp2Texture (tex1);
+				FTexture *warper = new FWarpTexture (tex1, 2);
 				ReplaceTexture (pic1, warper, false);
 			}
 			// These tests were not really relevant for swirling textures, or even potentially
@ -617,9 +617,7 @@ void FTextureManager::ParseWarp(FScanner &sc)
 		// don't warp a texture more than once
 		if (!warper->bWarped)
 		{
-			if (type2) warper = new FWarp2Texture (warper);
-			else warper = new FWarpTexture (warper);
-
+			warper = new FWarpTexture (warper, type2? 2:1);
 			ReplaceTexture (picnum, warper, false);
 		}

--- a/src/textures/texturemanager.cpp
+++ b/src/textures/texturemanager.cpp
@ -1226,46 +1226,6 @@ int FTextureManager::CountLumpTextures (int lumpnum)
 	return 0;
 }

-//===========================================================================
-//
-// R_PrecacheLevel
-//
-
-// Preloads all relevant graphics for the level.
-//
-//===========================================================================
-
-void FTextureManager::PrecacheLevel (void)
-{
-	BYTE *hitlist;
-	int cnt = NumTextures();
-
-	if (demoplayback)
-		return;
-
-	precacheTime = I_FPSTime();
-
-	hitlist = new BYTE[cnt];
-	memset (hitlist, 0, cnt);
-
-	screen->GetHitlist(hitlist);
-
-	for (unsigned i = 0; i < level.info->PrecacheTextures.Size(); i++)
-	{
-		FTextureID tex = TexMan.CheckForTexture(level.info->PrecacheTextures[i], FTexture::TEX_Wall, FTextureManager::TEXMAN_Overridable|FTextureManager::TEXMAN_TryAny|FTextureManager::TEXMAN_ReturnFirst);
-		if (tex.Exists()) hitlist[tex.GetIndex()] |= FTextureManager::HIT_Wall;
-	}
-
-	for (int i = cnt - 1; i >= 0; i--)
-	{
-		Renderer->PrecacheTexture(ByIndex(i), hitlist[i]);
-	}
-
-	delete[] hitlist;
-}
-
-
-

 //==========================================================================
 //
--- a/src/textures/textures.h
+++ b/src/textures/textures.h
@ -448,7 +448,6 @@ public:
 	void UnloadAll ();

 	int NumTextures () const { return (int)Textures.Size(); }
-	void PrecacheLevel (void);

 	void WriteTexture (FArchive &arc, int picnum);
 	int ReadTexture (FArchive &arc);
@ -540,7 +539,7 @@ public:
 class FWarpTexture : public FTexture
 {
 public:
-	FWarpTexture (FTexture *source);
+	FWarpTexture (FTexture *source, int warptype);
 	~FWarpTexture ();

 	virtual int CopyTrueColorPixels(FBitmap *bmp, int x, int y, int rotate=0, FCopyInfo *inf = NULL);
@ -567,16 +566,6 @@ protected:
 	void SetupMultipliers (int width, int height); // [mxd]
 };

-// [GRB] Eternity-like warping
-class FWarp2Texture : public FWarpTexture
-{
-public:
-	FWarp2Texture (FTexture *source);
-
-protected:
-	void MakeTexture (DWORD time);
-};
-
 // A texture that can be drawn to.
 class DSimpleCanvas;
 class AActor;
--- a/src/textures/warpbuffer.h
+++ b/src/textures/warpbuffer.h
@ -1,61 +1,63 @@

 template<class TYPE> 
-void WarpBufferType1(TYPE *Pixels, const TYPE *source, int width, int height, int xmul, int ymul, unsigned time, float Speed)
-{
-	TYPE *buffer = (TYPE *)alloca(sizeof(TYPE) * MAX(width, height));
-	int ymask = height - 1;
-	int x, y;
-
-	// [mxd] Rewrote to fix animation for NPo2 textures
-	unsigned timebase = unsigned(time * Speed * 32 / 28);
-	for (y = height - 1; y >= 0; y--)
-	{
-		int xf = (TexMan.sintable[((timebase + y*ymul) >> 2)&TexMan.SINMASK] >> 11) % width;
-		if (xf < 0) xf += width;
-		int xt = xf;
-		const TYPE *sourcep = source + y;
-		TYPE *dest = Pixels + y;
-		for (xt = width; xt; xt--, xf = (xf + 1) % width, dest += height)
-			*dest = sourcep[xf + ymask * xf];
-	}
-	timebase = unsigned(time * Speed * 23 / 28);
-	for (x = width - 1; x >= 0; x--)
-	{
-		int yf = (TexMan.sintable[((time + (x + 17)*xmul) >> 2)&TexMan.SINMASK] >> 11) % height;
-		if (yf < 0) yf += height;
-		int yt = yf;
-		const TYPE *sourcep = Pixels + (x + ymask * x);
-		TYPE *dest = buffer;
-		for (yt = height; yt; yt--, yf = (yf + 1) % height)
-			*dest++ = sourcep[yf];
-		memcpy(Pixels + (x + ymask*x), buffer, height * sizeof(TYPE));
-	}
-}
-
-
-template<class TYPE>
-void WarpBufferType2(TYPE *Pixels, const TYPE *source, int width, int height, int xmul, int ymul, unsigned time, float Speed)
+void WarpBuffer(TYPE *Pixels, const TYPE *source, int width, int height, int xmul, int ymul, unsigned time, float Speed, int warptype)
 {
 	int ymask = height - 1;
 	int x, y;

-	unsigned timebase = unsigned(time * Speed * 40 / 28);
-	// [mxd] Rewrote to fix animation for NPo2 textures
-	for (x = 0; x < width; x++)
+	if (warptype == 1)
 	{
-		TYPE *dest = Pixels + (x + ymask * x);
-		for (y = 0; y < height; y++)
+		TYPE *buffer = (TYPE *)alloca(sizeof(TYPE) * MAX(width, height));
+		// [mxd] Rewrote to fix animation for NPo2 textures
+		unsigned timebase = unsigned(time * Speed * 32 / 28);
+		for (y = height - 1; y >= 0; y--)
 		{
-			int xt = (x + 128
-				+ ((TexMan.sintable[((y*ymul + timebase * 5 + 900) >> 2) & TexMan.SINMASK]) >> 13)
-				+ ((TexMan.sintable[((x*xmul + timebase * 4 + 300) >> 2) & TexMan.SINMASK]) >> 13)) % width;
-
-			int yt = (y + 128
-				+ ((TexMan.sintable[((y*ymul + timebase * 3 + 700) >> 2) & TexMan.SINMASK]) >> 13)
-				+ ((TexMan.sintable[((x*xmul + timebase * 4 + 1200) >> 2) & TexMan.SINMASK]) >> 13)) % height;
-
-			*dest++ = source[(xt + ymask * xt) + yt];
+			int xf = (TexMan.sintable[((timebase + y*ymul) >> 2)&TexMan.SINMASK] >> 11) % width;
+			if (xf < 0) xf += width;
+			int xt = xf;
+			const TYPE *sourcep = source + y;
+			TYPE *dest = Pixels + y;
+			for (xt = width; xt; xt--, xf = (xf + 1) % width, dest += height)
+				*dest = sourcep[xf + ymask * xf];
+		}
+		timebase = unsigned(time * Speed * 23 / 28);
+		for (x = width - 1; x >= 0; x--)
+		{
+			int yf = (TexMan.sintable[((time + (x + 17)*xmul) >> 2)&TexMan.SINMASK] >> 11) % height;
+			if (yf < 0) yf += height;
+			int yt = yf;
+			const TYPE *sourcep = Pixels + (x + ymask * x);
+			TYPE *dest = buffer;
+			for (yt = height; yt; yt--, yf = (yf + 1) % height)
+				*dest++ = sourcep[yf];
+			memcpy(Pixels + (x + ymask*x), buffer, height * sizeof(TYPE));
 		}
 	}
+	else if (warptype == 2)
+	{
+		unsigned timebase = unsigned(time * Speed * 40 / 28);
+		// [mxd] Rewrote to fix animation for NPo2 textures
+		for (x = 0; x < width; x++)
+		{
+			TYPE *dest = Pixels + (x + ymask * x);
+			for (y = 0; y < height; y++)
+			{
+				int xt = (x + 128
+					+ ((TexMan.sintable[((y*ymul + timebase * 5 + 900) >> 2) & TexMan.SINMASK]) >> 13)
+					+ ((TexMan.sintable[((x*xmul + timebase * 4 + 300) >> 2) & TexMan.SINMASK]) >> 13)) % width;
+
+				int yt = (y + 128
+					+ ((TexMan.sintable[((y*ymul + timebase * 3 + 700) >> 2) & TexMan.SINMASK]) >> 13)
+					+ ((TexMan.sintable[((x*xmul + timebase * 4 + 1200) >> 2) & TexMan.SINMASK]) >> 13)) % height;
+
+				*dest++ = source[(xt + ymask * xt) + yt];
+			}
+		}
+	}
+	else
+	{
+		// should never happen, just in case...
+		memcpy(Pixels, source, width*height * sizeof(TYPE));
+	}
 }

--- a/src/textures/warptexture.cpp
+++ b/src/textures/warptexture.cpp
@ -41,12 +41,12 @@
 #include "warpbuffer.h"


-FWarpTexture::FWarpTexture (FTexture *source)
+FWarpTexture::FWarpTexture (FTexture *source, int warptype)
 : GenTime (0), SourcePic (source), Pixels (0), Spans (0), Speed (1.f)
 {
 	CopyInfo(source);
 	SetupMultipliers(128, 128); // [mxd]
-	bWarped = 1;
+	bWarped = warptype;
 }

 FWarpTexture::~FWarpTexture ()
@ -137,7 +137,7 @@ void FWarpTexture::MakeTexture(DWORD time)
 	}

 	GenTime = time;
-	WarpBufferType1(Pixels, otherpix, Width, Height, WidthOffsetMultiplier, HeightOffsetMultiplier, time, Speed);
+	WarpBuffer(Pixels, otherpix, Width, Height, WidthOffsetMultiplier, HeightOffsetMultiplier, time, Speed, bWarped);
 }

 // [mxd] Non power of 2 textures need different offset multipliers, otherwise warp animation won't sync across texture
@ -162,32 +162,6 @@ int FWarpTexture::NextPo2 (int v)
 	return ++v;
 }

-// [GRB] Eternity-like warping
-FWarp2Texture::FWarp2Texture (FTexture *source)
-: FWarpTexture (source)
-{
-	SetupMultipliers(256, 128); // [mxd]
-	bWarped = 2;
-}
-
-void FWarp2Texture::MakeTexture (DWORD time)
-{
-	const BYTE *otherpix = SourcePic->GetPixels ();
-
-	if (Pixels == NULL)
-	{
-		Pixels = new BYTE[Width * Height];
-	}
-	if (Spans != NULL)
-	{
-		FreeSpans (Spans);
-		Spans = NULL;
-	}
-
-	GenTime = time;
-	WarpBufferType2(Pixels, otherpix, Width, Height, WidthOffsetMultiplier, HeightOffsetMultiplier, time, Speed);
-}
-
 //==========================================================================
 //
 // FMultiPatchTexture :: TexPart :: TexPart
--- a/src/v_video.cpp
+++ b/src/v_video.cpp
@ -1208,83 +1208,6 @@ void DFrameBuffer::WipeCleanup()
 	wipe_Cleanup();
 }

-//===========================================================================
-//
-// Create texture hitlist
-//
-//===========================================================================
-
-void DFrameBuffer::GetHitlist(BYTE *hitlist)
-{
-	BYTE *spritelist;
-	int i;
-
-	spritelist = new BYTE[sprites.Size()];
-	
-	// Precache textures (and sprites).
-	memset (spritelist, 0, sprites.Size());
-
-	{
-		AActor *actor;
-		TThinkerIterator<AActor> iterator;
-
-		while ( (actor = iterator.Next ()) )
-			spritelist[actor->sprite] = 1;
-	}
-
-	for (i = (int)(sprites.Size () - 1); i >= 0; i--)
-	{
-		if (spritelist[i])
-		{
-			int j, k;
-			for (j = 0; j < sprites[i].numframes; j++)
-			{
-				const spriteframe_t *frame = &SpriteFrames[sprites[i].spriteframes + j];
-
-				for (k = 0; k < 16; k++)
-				{
-					FTextureID pic = frame->Texture[k];
-					if (pic.isValid())
-					{
-						hitlist[pic.GetIndex()] = FTextureManager::HIT_Sprite;
-					}
-				}
-			}
-		}
-	}
-
-	delete[] spritelist;
-
-	for (i = numsectors - 1; i >= 0; i--)
-	{
-		hitlist[sectors[i].GetTexture(sector_t::floor).GetIndex()] = 
-			hitlist[sectors[i].GetTexture(sector_t::ceiling).GetIndex()] |= FTextureManager::HIT_Flat;
-	}
-
-	for (i = numsides - 1; i >= 0; i--)
-	{
-		hitlist[sides[i].GetTexture(side_t::top).GetIndex()] =
-		hitlist[sides[i].GetTexture(side_t::mid).GetIndex()] =
-		hitlist[sides[i].GetTexture(side_t::bottom).GetIndex()] |= FTextureManager::HIT_Wall;
-	}
-
-	// Sky texture is always present.
-	// Note that F_SKY1 is the name used to
-	//	indicate a sky floor/ceiling as a flat,
-	//	while the sky texture is stored like
-	//	a wall texture, with an episode dependant
-	//	name.
-
-	if (sky1texture.isValid())
-	{
-		hitlist[sky1texture.GetIndex()] |= FTextureManager::HIT_Sky;
-	}
-	if (sky2texture.isValid())
-	{
-		hitlist[sky2texture.GetIndex()] |= FTextureManager::HIT_Sky;
-	}
-}
-
 //==========================================================================
 //
 // DFrameBuffer :: GameRestart
--- a/src/v_video.h
+++ b/src/v_video.h
@ -395,8 +395,7 @@ public:
 	virtual FNativePalette *CreatePalette(FRemapTable *remap);

 	// Precaches or unloads a texture
-	virtual void GetHitlist(BYTE *hitlist);
-
+	
 	// Report a game restart
 	virtual void GameRestart();

--- a/wadsrc/static/language.enu
+++ b/wadsrc/static/language.enu
@ -2607,6 +2607,7 @@ GLPREFMNU_SPRCLIP 				= "Adjust sprite clipping";
 GLPREFMNU_SPRBLEND 				= "Smooth sprite edges";
 GLPREFMNU_FUZZSTYLE 			= "Fuzz Style";
 GLPREFMNU_SPRBILLBOARD 			= "Sprite billboard";
+GLPREFMNU_SPRBILLFACECAMERA 	= "Sprites face camera";
 GLPREFMNU_PARTICLESTYLE 		= "Particle style";
 GLPREFMNU_AMBLIGHT 				= "Ambient light level";
 GLPREFMNU_RENDERQUALITY 		= "Rendering quality";
--- a/wadsrc/static/menudef.z
+++ b/wadsrc/static/menudef.z
@ -184,6 +184,7 @@ OptionMenu "GLPrefOptions"
 	Option "$GLPREFMNU_SPRBLEND",				gl_sprite_blend,				"OnOff"
 	Option "$GLPREFMNU_FUZZSTYLE",				gl_fuzztype,					"FuzzStyle"
 	Option "$GLPREFMNU_SPRBILLBOARD",			gl_billboard_mode,				"BillboardModes"
+	Option "$GLPREFMNU_SPRBILLFACECAMERA",		gl_billboard_faces_camera,		"OnOff"
 	Option "$GLPREFMNU_PARTICLESTYLE",			gl_particles_style,				"Particles"
 	Slider "$GLPREFMNU_AMBLIGHT",				gl_light_ambient,				1.0, 255.0, 5.0
 	Option "$GLPREFMNU_RENDERQUALITY",			gl_render_precise,				"Precision"
--- a/wadsrc/static/shaders/glsl/gammacorrection.fp
+++ b/wadsrc/static/shaders/glsl/gammacorrection.fp
@ -0,0 +1,30 @@
+uniform sampler2D tex;
+
+in vec4 vTexCoord;
+in vec4 vColor;
+
+out vec4 FragColor;
+
+void main()
+{
+	vec3 color = texture(tex, vTexCoord.st).rgb;
+
+//	/* DEBUG */ if (vTexCoord.x > 0.5)
+	{
+		// Apply contrast
+		float contrast = clamp(vColor.y, 0.1, 3.0);
+		color = color.rgb * contrast - (contrast - 1.0) * 0.5;
+
+		// Apply gamma
+		float gamma = clamp(vColor.x, 0.1, 4.0);
+		color = sign(color) * pow(abs(color), vec3(1.0 / gamma));
+
+		// Apply brightness
+		float brightness = clamp(vColor.z, -0.8, 0.8);
+		color += brightness * 0.5;
+
+		color = clamp(color, 0.0, 1.0);
+	}
+
+	FragColor = vec4(color, 1.0);
+}