X-Git-Url: https://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_rmain.c;h=de6689ab564c48746528f67f499092409d705dcb;hp=00ef62a831ace8b82d0eba90432527ece3b2d217;hb=a255e13ec710fbfbf541ef09b2195253dea80658;hpb=64b4047514a2138edd912dd3aaf9ceb601d77f4e

diff --git a/gl_rmain.c b/gl_rmain.c
index 00ef62a8..de6689ab 100644
--- a/gl_rmain.c
+++ b/gl_rmain.c
@@ -61,6 +61,8 @@ cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels
 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this)"};
 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
+cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
+cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "2", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
 
 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
@@ -76,7 +78,19 @@ cvar_t r_glsl = {CVAR_SAVE, "r_glsl", "1", "enables use of OpenGL 2.0 pixel shad
 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
+cvar_t r_glsl_water = {CVAR_SAVE, "r_glsl_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"};
+cvar_t r_glsl_water_clippingplanebias = {CVAR_SAVE, "r_glsl_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
+cvar_t r_glsl_water_resolutionmultiplier = {CVAR_SAVE, "r_glsl_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"};
+cvar_t r_glsl_water_refractcolor_r = {CVAR_SAVE, "r_glsl_water_refractcolor_r", "1", "water color tint for refraction"};
+cvar_t r_glsl_water_refractcolor_g = {CVAR_SAVE, "r_glsl_water_refractcolor_g", "1", "water color tint for refraction"};
+cvar_t r_glsl_water_refractcolor_b = {CVAR_SAVE, "r_glsl_water_refractcolor_b", "1", "water color tint for refraction"};
+cvar_t r_glsl_water_reflectcolor_r = {CVAR_SAVE, "r_glsl_water_reflectcolor_r", "1", "water color tint for reflection"};
+cvar_t r_glsl_water_reflectcolor_g = {CVAR_SAVE, "r_glsl_water_reflectcolor_g", "1", "water color tint for reflection"};
+cvar_t r_glsl_water_reflectcolor_b = {CVAR_SAVE, "r_glsl_water_reflectcolor_b", "1", "water color tint for reflection"};
+cvar_t r_glsl_water_refractdistort = {CVAR_SAVE, "r_glsl_water_refractdistort", "0.01", "how much water refractions shimmer"};
+cvar_t r_glsl_water_reflectdistort = {CVAR_SAVE, "r_glsl_water_reflectdistort", "0.01", "how much water reflections shimmer"};
 cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
+cvar_t r_glsl_contrastboost = {CVAR_SAVE, "r_glsl_contrastboost", "1", "by how much to multiply the contrast in dark areas (1 is no change)"};
 
 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"};
 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
@@ -104,6 +118,8 @@ cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture
 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
 
+extern qboolean v_flipped_state;
+
 typedef struct r_glsl_bloomshader_s
 {
 	int program;
@@ -133,11 +149,40 @@ static struct r_bloomstate_s
 }
 r_bloomstate;
 
+typedef struct r_waterstate_waterplane_s
+{
+	rtexture_t *texture_refraction;
+	rtexture_t *texture_reflection;
+	mplane_t plane;
+}
+r_waterstate_waterplane_t;
+
+#define MAX_WATERPLANES 16
+
+static struct r_waterstate_s
+{
+	qboolean enabled;
+
+	qboolean renderingscene; // true while rendering a refraction or reflection texture, disables water surfaces
+
+	int waterwidth, waterheight;
+	int texturewidth, textureheight;
+
+	int maxwaterplanes; // same as MAX_WATERPLANES
+	int numwaterplanes;
+	r_waterstate_waterplane_t waterplanes[MAX_WATERPLANES];
+
+	float screenscale[2];
+	float screencenter[2];
+}
+r_waterstate;
+
 // shadow volume bsp struct with automatically growing nodes buffer
 svbsp_t r_svbsp;
 
 rtexture_t *r_texture_blanknormalmap;
 rtexture_t *r_texture_white;
+rtexture_t *r_texture_grey128;
 rtexture_t *r_texture_black;
 rtexture_t *r_texture_notexture;
 rtexture_t *r_texture_whitecube;
@@ -213,7 +258,7 @@ float FogPoint_World(const vec3_t p)
 
 float FogPoint_Model(const vec3_t p)
 {
-	int fogmasktableindex = (int)(VectorDistance((p), rsurface_modelorg) * r_refdef.fogmasktabledistmultiplier);
+	int fogmasktableindex = (int)(VectorDistance((p), rsurface.modelorg) * r_refdef.fogmasktabledistmultiplier);
 	return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
 }
 
@@ -230,6 +275,11 @@ static void R_BuildBlankTextures(void)
 	data[2] = 255;
 	data[3] = 255;
 	r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
+	data[0] = 128;
+	data[1] = 128;
+	data[2] = 128;
+	data[3] = 255;
+	r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
 	data[0] = 0;
 	data[1] = 0;
 	data[2] = 0;
@@ -391,6 +441,12 @@ static const char *builtinshaderstring =
 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
 "\n"
+"#ifdef USEWATER\n"
+"varying vec4 ModelViewProjectionPosition;\n"
+"//varying vec4 ModelViewProjectionPosition_svector;\n"
+"//varying vec4 ModelViewProjectionPosition_tvector;\n"
+"#endif\n"
+"\n"
 "\n"
 "\n"
 "\n"
@@ -447,9 +503,18 @@ static const char *builtinshaderstring =
 "	VectorR = gl_MultiTexCoord3.xyz;\n"
 "#endif\n"
 "\n"
-"	// transform vertex to camera space, using ftransform to match non-VS\n"
+"//#ifdef USEWATER\n"
+"//	ModelViewProjectionPosition = gl_Vertex * gl_ModelViewProjectionMatrix;\n"
+"//	//ModelViewProjectionPosition_svector = (gl_Vertex + vec4(gl_MultiTexCoord1.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
+"//	//ModelViewProjectionPosition_tvector = (gl_Vertex + vec4(gl_MultiTexCoord2.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
+"//#endif\n"
+"\n"
+"// transform vertex to camera space, using ftransform to match non-VS\n"
 "	// rendering\n"
 "	gl_Position = ftransform();\n"
+"#ifdef USEWATER\n"
+"	ModelViewProjectionPosition = gl_Position;\n"
+"#endif\n"
 "}\n"
 "\n"
 "#endif // VERTEX_SHADER\n"
@@ -472,6 +537,8 @@ static const char *builtinshaderstring =
 "uniform sampler2D Texture_Lightmap;\n"
 "uniform sampler2D Texture_Deluxemap;\n"
 "uniform sampler2D Texture_Glow;\n"
+"uniform sampler2D Texture_Reflection;\n"
+"uniform sampler2D Texture_Refraction;\n"
 "\n"
 "uniform myhvec3 LightColor;\n"
 "uniform myhvec3 AmbientColor;\n"
@@ -481,8 +548,19 @@ static const char *builtinshaderstring =
 "uniform myhvec3 Color_Shirt;\n"
 "uniform myhvec3 FogColor;\n"
 "\n"
+"#ifdef USEWATER\n"
+"uniform vec4 DistortScaleRefractReflect;\n"
+"uniform vec4 ScreenScaleRefractReflect;\n"
+"uniform vec4 ScreenCenterRefractReflect;\n"
+"uniform myhvec3 RefractColor;\n"
+"uniform myhvec3 ReflectColor;\n"
+"#endif\n"
+"\n"
 "uniform myhalf GlowScale;\n"
 "uniform myhalf SceneBrightness;\n"
+"#ifdef USECONTRASTBOOST\n"
+"uniform myhalf ContrastBoostCoeff;\n"
+"#endif\n"
 "\n"
 "uniform float OffsetMapping_Scale;\n"
 "uniform float OffsetMapping_Bias;\n"
@@ -647,7 +725,28 @@ static const char *builtinshaderstring =
 "	color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
 "#endif\n"
 "\n"
+"#ifdef USEWATER\n"
+"#ifdef MODE_LIGHTSOURCE\n"
+"	color.rgb *= color.a;\n"
+"#else\n"
+"	myhalf Fresnel = myhalf(max(pow(min(1, 1.0 - normalize(EyeVector).z), 5), 0.1));\n"
+"	vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
+"	//vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
+"	vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect;\n"
+"	color.rgb = mix(mix(myhvec3(texture2D(Texture_Refraction, ScreenTexCoord.xy)) * RefractColor, myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor, Fresnel), color.rgb, color.a);\n"
+"	//color.rgb = myhvec3(texture2D(Texture_Refraction, ScreenTexCoord.xy)); // testing only\n"
+"	//color.rgb = myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)); // testing only\n"
+"	//vec4 RefractionPosition = ModelViewProjectionPosition + ModelViewProjectionPosition_svector * distort.x + ModelViewProjectionPosition_tvector * distort.y;\n"
+"	//vec4 ReflectionPosition = ModelViewProjectionPosition + ModelViewProjectionPosition_svector * distort.w + ModelViewProjectionPosition_tvector * distort.z;\n"
+"	//color.rgb += mix(myhvec3(texture2DProj(Texture_Refraction, RefractionPosition)) * RefractColor, myhvec3(texture2DProj(Texture_Reflection, ReflectionPosition)) * ReflectColor, Fresnel);\n"
+"#endif\n"
+"#endif\n"
+"\n"
+"#ifdef USECONTRASTBOOST\n"
+"	color.rgb = color.rgb * SceneBrightness / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
+"#else\n"
 "	color.rgb *= SceneBrightness;\n"
+"#endif\n"
 "\n"
 "	gl_FragColor = vec4(color);\n"
 "}\n"
@@ -662,10 +761,12 @@ const char *permutationinfo[][2] =
 	{"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
 	{"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
 	{"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
+	{"#define USEWATER\n", " water"},
 	{"#define USEGLOW\n", " glow"},
 	{"#define USEFOG\n", " fog"},
 	{"#define USECOLORMAPPING\n", " colormapping"},
 	{"#define USEDIFFUSE\n", " diffuse"},
+	{"#define USECONTRASTBOOST\n", " contrastboost"},
 	{"#define USESPECULAR\n", " specular"},
 	{"#define USECUBEFILTER\n", " cubefilter"},
 	{"#define USEOFFSETMAPPING\n", " offsetmapping"},
@@ -759,6 +860,8 @@ void R_GLSL_CompilePermutation(const char *filename, int permutation)
 		p->loc_Texture_Lightmap    = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
 		p->loc_Texture_Deluxemap   = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
 		p->loc_Texture_Glow        = qglGetUniformLocationARB(p->program, "Texture_Glow");
+		p->loc_Texture_Refraction  = qglGetUniformLocationARB(p->program, "Texture_Refraction");
+		p->loc_Texture_Reflection  = qglGetUniformLocationARB(p->program, "Texture_Reflection");
 		p->loc_FogColor            = qglGetUniformLocationARB(p->program, "FogColor");
 		p->loc_LightPosition       = qglGetUniformLocationARB(p->program, "LightPosition");
 		p->loc_EyePosition         = qglGetUniformLocationARB(p->program, "EyePosition");
@@ -777,6 +880,12 @@ void R_GLSL_CompilePermutation(const char *filename, int permutation)
 		p->loc_DiffuseColor        = qglGetUniformLocationARB(p->program, "DiffuseColor");
 		p->loc_SpecularColor       = qglGetUniformLocationARB(p->program, "SpecularColor");
 		p->loc_LightDir            = qglGetUniformLocationARB(p->program, "LightDir");
+		p->loc_ContrastBoostCoeff  = qglGetUniformLocationARB(p->program, "ContrastBoostCoeff");
+		p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
+		p->loc_ScreenScaleRefractReflect = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
+		p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
+		p->loc_RefractColor        = qglGetUniformLocationARB(p->program, "RefractColor");
+		p->loc_ReflectColor        = qglGetUniformLocationARB(p->program, "ReflectColor");
 		// initialize the samplers to refer to the texture units we use
 		if (p->loc_Texture_Normal >= 0)    qglUniform1iARB(p->loc_Texture_Normal, 0);
 		if (p->loc_Texture_Color >= 0)     qglUniform1iARB(p->loc_Texture_Color, 1);
@@ -789,11 +898,13 @@ void R_GLSL_CompilePermutation(const char *filename, int permutation)
 		if (p->loc_Texture_Deluxemap >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap, 8);
 		if (p->loc_Texture_Glow >= 0)      qglUniform1iARB(p->loc_Texture_Glow, 9);
 		if (p->loc_Texture_Attenuation >= 0) qglUniform1iARB(p->loc_Texture_Attenuation, 10);
+		if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction, 11);
+		if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection, 12);
 		CHECKGLERROR
 		qglUseProgramObjectARB(0);CHECKGLERROR
 	}
 	else
-		Con_Printf("permutation%s failed for shader %s, some features may not work properly!\n", permutationname, "glsl/default.glsl");
+		Con_Printf("permutation%s failed for shader %s, some features may not work properly!\n", permutationname, filename);
 	if (shaderstring)
 		Mem_Free(shaderstring);
 }
@@ -807,6 +918,28 @@ void R_GLSL_Restart_f(void)
 	memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
 }
 
+void R_GLSL_DumpShader_f(void)
+{
+	int i;
+
+	qfile_t *file = FS_Open("glsl/default.glsl", "w", false, false);
+	if(!file)
+	{
+		Con_Printf("failed to write to glsl/default.glsl\n");
+		return;
+	}
+
+	FS_Print(file, "// The engine may define the following macros:\n");
+	FS_Print(file, "// #define VERTEX_SHADER\n// #define GEOMETRY_SHADER\n// #define FRAGMENT_SHADER\n");
+	for (i = 0;permutationinfo[i][0];i++)
+		FS_Printf(file, "// %s", permutationinfo[i][0]);
+	FS_Print(file, "\n");
+	FS_Print(file, builtinshaderstring);
+	FS_Close(file);
+
+	Con_Printf("glsl/default.glsl written\n");
+}
+
 extern rtexture_t *r_shadow_attenuationgradienttexture;
 extern rtexture_t *r_shadow_attenuation2dtexture;
 extern rtexture_t *r_shadow_attenuation3dtexture;
@@ -818,14 +951,15 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 	// fragment shader on features that are not being used
 	const char *shaderfilename = NULL;
 	unsigned int permutation = 0;
+	rtexture_t *nmap;
 	r_glsl_permutation = NULL;
 	// TODO: implement geometry-shader based shadow volumes someday
-	if (r_shadow_rtlight)
+	if (rsurface.rtlight)
 	{
 		// light source
 		shaderfilename = "glsl/default.glsl";
 		permutation = SHADERPERMUTATION_MODE_LIGHTSOURCE | SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER;
-		if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
+		if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
 			permutation |= SHADERPERMUTATION_CUBEFILTER;
 		if (diffusescale > 0)
 			permutation |= SHADERPERMUTATION_DIFFUSE;
@@ -833,7 +967,7 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 			permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
 		if (r_refdef.fogenabled)
 			permutation |= SHADERPERMUTATION_FOG;
-		if (rsurface_texture->colormapping)
+		if (rsurface.texture->colormapping)
 			permutation |= SHADERPERMUTATION_COLORMAPPING;
 		if (r_glsl_offsetmapping.integer)
 		{
@@ -841,17 +975,21 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 			if (r_glsl_offsetmapping_reliefmapping.integer)
 				permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
 		}
+		if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
+			permutation |= SHADERPERMUTATION_CONTRASTBOOST;
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+			permutation |= SHADERPERMUTATION_USEWATER;
 	}
-	else if (rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
+	else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
 	{
 		// bright unshaded geometry
 		shaderfilename = "glsl/default.glsl";
 		permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER;
-		if (rsurface_texture->currentskinframe->glow)
+		if (rsurface.texture->currentskinframe->glow)
 			permutation |= SHADERPERMUTATION_GLOW;
 		if (r_refdef.fogenabled)
 			permutation |= SHADERPERMUTATION_FOG;
-		if (rsurface_texture->colormapping)
+		if (rsurface.texture->colormapping)
 			permutation |= SHADERPERMUTATION_COLORMAPPING;
 		if (r_glsl_offsetmapping.integer)
 		{
@@ -859,6 +997,10 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 			if (r_glsl_offsetmapping_reliefmapping.integer)
 				permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
 		}
+		if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
+			permutation |= SHADERPERMUTATION_CONTRASTBOOST;
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+			permutation |= SHADERPERMUTATION_USEWATER;
 	}
 	else if (modellighting)
 	{
@@ -866,13 +1008,13 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 		shaderfilename = "glsl/default.glsl";
 		permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER;
 		permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTION;
-		if (rsurface_texture->currentskinframe->glow)
+		if (rsurface.texture->currentskinframe->glow)
 			permutation |= SHADERPERMUTATION_GLOW;
 		if (specularscale > 0)
 			permutation |= SHADERPERMUTATION_SPECULAR;
 		if (r_refdef.fogenabled)
 			permutation |= SHADERPERMUTATION_FOG;
-		if (rsurface_texture->colormapping)
+		if (rsurface.texture->colormapping)
 			permutation |= SHADERPERMUTATION_COLORMAPPING;
 		if (r_glsl_offsetmapping.integer)
 		{
@@ -880,16 +1022,20 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 			if (r_glsl_offsetmapping_reliefmapping.integer)
 				permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
 		}
+		if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
+			permutation |= SHADERPERMUTATION_CONTRASTBOOST;
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+			permutation |= SHADERPERMUTATION_USEWATER;
 	}
 	else
 	{
 		// lightmapped wall
 		shaderfilename = "glsl/default.glsl";
 		permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER;
-		if (r_glsl_deluxemapping.integer >= 1 && rsurface_uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
+		if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
 		{
 			// deluxemapping (light direction texture)
-			if (rsurface_uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
+			if (rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
 				permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_MODELSPACE;
 			else
 				permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
@@ -908,11 +1054,11 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 			// ordinary lightmapping
 			permutation |= 0;
 		}
-		if (rsurface_texture->currentskinframe->glow)
+		if (rsurface.texture->currentskinframe->glow)
 			permutation |= SHADERPERMUTATION_GLOW;
 		if (r_refdef.fogenabled)
 			permutation |= SHADERPERMUTATION_FOG;
-		if (rsurface_texture->colormapping)
+		if (rsurface.texture->colormapping)
 			permutation |= SHADERPERMUTATION_COLORMAPPING;
 		if (r_glsl_offsetmapping.integer)
 		{
@@ -920,6 +1066,10 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 			if (r_glsl_offsetmapping_reliefmapping.integer)
 				permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
 		}
+		if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
+			permutation |= SHADERPERMUTATION_CONTRASTBOOST;
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+			permutation |= SHADERPERMUTATION_USEWATER;
 	}
 	if (!r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].program)
 	{
@@ -929,14 +1079,18 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 		{
 			// remove features until we find a valid permutation
 			unsigned int i;
-			for (i = SHADERPERMUTATION_MASK;;i>>=1)
+			for (i = (SHADERPERMUTATION_MAX >> 1);;i>>=1)
 			{
 				if (!i)
-					return 0; // utterly failed
+				{
+					Con_Printf("OpenGL 2.0 shaders disabled - unable to find a working shader permutation fallback on this driver (set r_glsl 1 if you want to try again)\n");
+					Cvar_SetValueQuick(&r_glsl, 0);
+					return 0; // no bit left to clear
+				}
 				// reduce i more quickly whenever it would not remove any bits
-				if (permutation < i)
+				if (!(permutation & i))
 					continue;
-				permutation &= i;
+				permutation &= ~i;
 				if (!r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].compiled)
 					R_GLSL_CompilePermutation(shaderfilename, permutation);
 				if (r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].program)
@@ -947,11 +1101,11 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 	r_glsl_permutation = r_glsl_permutations + (permutation & SHADERPERMUTATION_MASK);
 	CHECKGLERROR
 	qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
-	R_Mesh_TexMatrix(0, &rsurface_texture->currenttexmatrix);
+	R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
 	if (permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE)
 	{
-		if (r_glsl_permutation->loc_Texture_Cube >= 0 && r_shadow_rtlight) R_Mesh_TexBindCubeMap(3, R_GetTexture(r_shadow_rtlight->currentcubemap));
-		if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, r_shadow_entitylightorigin[0], r_shadow_entitylightorigin[1], r_shadow_entitylightorigin[2]);
+		if (r_glsl_permutation->loc_Texture_Cube >= 0 && rsurface.rtlight) R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap));
+		if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
 		if (permutation & SHADERPERMUTATION_DIFFUSE)
 		{
 			if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
@@ -971,13 +1125,13 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 	else if (permutation & SHADERPERMUTATION_MODE_LIGHTDIRECTION)
 	{
 		if (r_glsl_permutation->loc_AmbientColor >= 0)
-			qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface_entity->modellight_ambient[0] * ambientscale, rsurface_entity->modellight_ambient[1] * ambientscale, rsurface_entity->modellight_ambient[2] * ambientscale);
+			qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface.modellight_ambient[0] * ambientscale, rsurface.modellight_ambient[1] * ambientscale, rsurface.modellight_ambient[2] * ambientscale);
 		if (r_glsl_permutation->loc_DiffuseColor >= 0)
-			qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface_entity->modellight_diffuse[0] * diffusescale, rsurface_entity->modellight_diffuse[1] * diffusescale, rsurface_entity->modellight_diffuse[2] * diffusescale);
+			qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface.modellight_diffuse[0] * diffusescale, rsurface.modellight_diffuse[1] * diffusescale, rsurface.modellight_diffuse[2] * diffusescale);
 		if (r_glsl_permutation->loc_SpecularColor >= 0)
-			qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface_entity->modellight_diffuse[0] * specularscale, rsurface_entity->modellight_diffuse[1] * specularscale, rsurface_entity->modellight_diffuse[2] * specularscale);
+			qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface.modellight_diffuse[0] * specularscale, rsurface.modellight_diffuse[1] * specularscale, rsurface.modellight_diffuse[2] * specularscale);
 		if (r_glsl_permutation->loc_LightDir >= 0)
-			qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface_entity->modellight_lightdir[0], rsurface_entity->modellight_lightdir[1], rsurface_entity->modellight_lightdir[2]);
+			qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
 	}
 	else
 	{
@@ -985,45 +1139,70 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl
 		if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f);
 		if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f);
 	}
-	if (r_glsl_permutation->loc_Texture_Normal >= 0) R_Mesh_TexBind(0, R_GetTexture(rsurface_texture->currentskinframe->nmap));
-	if (r_glsl_permutation->loc_Texture_Color >= 0) R_Mesh_TexBind(1, R_GetTexture(rsurface_texture->basetexture));
-	if (r_glsl_permutation->loc_Texture_Gloss >= 0) R_Mesh_TexBind(2, R_GetTexture(rsurface_texture->glosstexture));
-	//if (r_glsl_permutation->loc_Texture_Cube >= 0 && permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE) R_Mesh_TexBindCubeMap(3, R_GetTexture(r_shadow_rtlight->currentcubemap));
+	nmap = rsurface.texture->currentskinframe->nmap;
+	if (gl_lightmaps.integer)
+		nmap = r_texture_blanknormalmap;
+	if (r_glsl_permutation->loc_Texture_Normal >= 0) R_Mesh_TexBind(0, R_GetTexture(nmap));
+	if (r_glsl_permutation->loc_Texture_Color >= 0) R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture));
+	if (r_glsl_permutation->loc_Texture_Gloss >= 0) R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture));
+	//if (r_glsl_permutation->loc_Texture_Cube >= 0 && permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE) R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap));
 	if (r_glsl_permutation->loc_Texture_Attenuation >= 0) R_Mesh_TexBind(10, R_GetTexture(r_shadow_attenuationgradienttexture));
 	if (r_glsl_permutation->loc_Texture_FogMask >= 0) R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
-	if (r_glsl_permutation->loc_Texture_Pants >= 0) R_Mesh_TexBind(5, R_GetTexture(rsurface_texture->currentskinframe->pants));
-	if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(6, R_GetTexture(rsurface_texture->currentskinframe->shirt));
+	if (r_glsl_permutation->loc_Texture_Pants >= 0) R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants));
+	if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt));
 	//if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
 	//if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
-	if (r_glsl_permutation->loc_Texture_Glow >= 0) R_Mesh_TexBind(9, R_GetTexture(rsurface_texture->currentskinframe->glow));
+	if (r_glsl_permutation->loc_Texture_Glow >= 0) R_Mesh_TexBind(9, R_GetTexture(rsurface.texture->currentskinframe->glow));
+	if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
+	if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
 	if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
-	if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale);
+	if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
+	{
+		// The formula used is actually:
+		//   color.rgb *= SceneBrightness;
+		//   color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
+		// I simplify that to
+		//   color.rgb *= [[SceneBrightness * ContrastBoost]];
+		//   color.rgb /= [[(ContrastBoost - 1) / ContrastBoost]] * color.rgb + 1;
+		// and Black:
+		//   color.rgb = [[SceneBrightness * ContrastBoost]] / ([[(ContrastBoost - 1) * SceneBrightness]] + 1 / color.rgb);
+		// and do [[calculations]] here in the engine
+		qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, (r_glsl_contrastboost.value - 1) * r_view.colorscale);
+		if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale * r_glsl_contrastboost.value);
+	}
+	else
+		if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale);
 	if (r_glsl_permutation->loc_FogColor >= 0)
 	{
 		// additive passes are only darkened by fog, not tinted
-		if (r_shadow_rtlight || (rsurface_texture->currentmaterialflags & MATERIALFLAG_ADD))
+		if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD))
 			qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
 		else
 			qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
 	}
-	if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface_modelorg[0], rsurface_modelorg[1], rsurface_modelorg[2]);
+	if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
 	if (r_glsl_permutation->loc_Color_Pants >= 0)
 	{
-		if (rsurface_texture->currentskinframe->pants)
-			qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface_entity->colormap_pantscolor[0], rsurface_entity->colormap_pantscolor[1], rsurface_entity->colormap_pantscolor[2]);
+		if (rsurface.texture->currentskinframe->pants)
+			qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
 		else
 			qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
 	}
 	if (r_glsl_permutation->loc_Color_Shirt >= 0)
 	{
-		if (rsurface_texture->currentskinframe->shirt)
-			qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface_entity->colormap_shirtcolor[0], rsurface_entity->colormap_shirtcolor[1], rsurface_entity->colormap_shirtcolor[2]);
+		if (rsurface.texture->currentskinframe->shirt)
+			qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
 		else
 			qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
 	}
 	if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
-	if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface_texture->specularpower);
+	if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
 	if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
+	if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_DistortScaleRefractReflect, r_glsl_water_refractdistort.value, r_glsl_water_refractdistort.value, r_glsl_water_reflectdistort.value, r_glsl_water_reflectdistort.value);
+	if (r_glsl_permutation->loc_ScreenScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);
+	if (r_glsl_permutation->loc_ScreenCenterRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);
+	if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_RefractColor, r_glsl_water_refractcolor_r.value, r_glsl_water_refractcolor_g.value, r_glsl_water_refractcolor_b.value);
+	if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_ReflectColor, r_glsl_water_reflectcolor_r.value, r_glsl_water_reflectcolor_g.value, r_glsl_water_reflectcolor_b.value);
 	CHECKGLERROR
 	return permutation;
 }
@@ -1169,7 +1348,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
 
 	basepixels_width = image_width;
 	basepixels_height = image_height;
-	skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);
+	skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);
 
 	if (textureflags & TEXF_ALPHA)
 	{
@@ -1187,7 +1366,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
 				pixels[j+2] = 255;
 				pixels[j+3] = basepixels[j+3];
 			}
-			skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);
+			skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);
 			Mem_Free(pixels);
 		}
 	}
@@ -1197,7 +1376,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
 	{
 		if ((pixels = loadimagepixels(va("%s_norm", skinframe->basename), false, 0, 0)) != NULL)
 		{
-			skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);
+			skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
 			Mem_Free(pixels);
 			pixels = NULL;
 		}
@@ -1205,7 +1384,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
 		{
 			pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
 			Image_HeightmapToNormalmap(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
-			skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);
+			skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
 			Mem_Free(pixels);
 			Mem_Free(bumppixels);
 		}
@@ -1213,17 +1392,17 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
 		{
 			pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
 			Image_HeightmapToNormalmap(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
-			skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);
+			skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
 			Mem_Free(pixels);
 		}
 	}
 	// _luma is supported for tenebrae compatibility
 	// (I think it's a very stupid name, but oh well)
 	// _glow is the preferred name
-	if (loadglow          && ((pixels = loadimagepixels(va("%s_glow", skinframe->basename), false, 0, 0)) != NULL || (pixels = loadimagepixels(va("%s_luma", skinframe->basename), false, 0, 0)) != NULL)) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);Mem_Free(pixels);pixels = NULL;}
-	if (loadgloss         && (pixels = loadimagepixels(va("%s_gloss", skinframe->basename), false, 0, 0)) != NULL) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);Mem_Free(pixels);pixels = NULL;}
-	if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_pants", skinframe->basename), false, 0, 0)) != NULL) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);Mem_Free(pixels);pixels = NULL;}
-	if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_shirt", skinframe->basename), false, 0, 0)) != NULL) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);Mem_Free(pixels);pixels = NULL;}
+	if (loadglow          && ((pixels = loadimagepixels(va("%s_glow", skinframe->basename), false, 0, 0)) != NULL || (pixels = loadimagepixels(va("%s_luma", skinframe->basename), false, 0, 0)) != NULL)) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
+	if (loadgloss         && (pixels = loadimagepixels(va("%s_gloss", skinframe->basename), false, 0, 0)) != NULL) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
+	if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_pants", skinframe->basename), false, 0, 0)) != NULL) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
+	if (loadpantsandshirt && (pixels = loadimagepixels(va("%s_shirt", skinframe->basename), false, 0, 0)) != NULL) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_RGBA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
 
 	if (basepixels)
 		Mem_Free(basepixels);
@@ -1280,10 +1459,10 @@ skinframe_t *R_SkinFrame_LoadInternal(const char *name, int textureflags, int lo
 			temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
 			temp2 = temp1 + width * height * 4;
 			Image_HeightmapToNormalmap(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
-			skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_RGBA, textureflags | TEXF_ALPHA, NULL);
+			skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_RGBA, skinframe->textureflags | TEXF_ALPHA, NULL);
 			Mem_Free(temp1);
 		}
-		skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_RGBA, textureflags, NULL);
+		skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_RGBA, skinframe->textureflags, NULL);
 		if (textureflags & TEXF_ALPHA)
 		{
 			for (i = 3;i < width * height * 4;i += 4)
@@ -1295,7 +1474,7 @@ skinframe_t *R_SkinFrame_LoadInternal(const char *name, int textureflags, int lo
 				memcpy(fogpixels, skindata, width * height * 4);
 				for (i = 0;i < width * height * 4;i += 4)
 					fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
-				skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_RGBA, textureflags, NULL);
+				skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_RGBA, skinframe->textureflags, NULL);
 				Mem_Free(fogpixels);
 			}
 		}
@@ -1314,20 +1493,20 @@ skinframe_t *R_SkinFrame_LoadInternal(const char *name, int textureflags, int lo
 				Image_Copy8bitRGBA(skindata, temp1, width * height, palette ? palette : palette_complete);
 				Image_HeightmapToNormalmap(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
 			}
-			skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_RGBA, textureflags | TEXF_ALPHA, NULL);
+			skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_RGBA, skinframe->textureflags | TEXF_ALPHA, NULL);
 			Mem_Free(temp1);
 		}
 		// use either a custom palette, or the quake palette
-		skinframe->base = skinframe->merged = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_merged", skinframe->basename), palette ? palette : (loadglowtexture ? palette_nofullbrights : ((textureflags & TEXF_ALPHA) ? palette_transparent : palette_complete)), textureflags, true); // all
+		skinframe->base = skinframe->merged = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_merged", skinframe->basename), palette ? palette : (loadglowtexture ? palette_nofullbrights : ((skinframe->textureflags & TEXF_ALPHA) ? palette_transparent : palette_complete)), skinframe->textureflags, true); // all
 		if (!palette && loadglowtexture)
-			skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_onlyfullbrights, textureflags, false); // glow
+			skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_onlyfullbrights, skinframe->textureflags, false); // glow
 		if (!palette && loadpantsandshirt)
 		{
-			skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_pantsaswhite, textureflags, false); // pants
-			skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_shirtaswhite, textureflags, false); // shirt
+			skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_pantsaswhite, skinframe->textureflags, false); // pants
+			skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_shirtaswhite, skinframe->textureflags, false); // shirt
 		}
 		if (skinframe->pants || skinframe->shirt)
-			skinframe->base = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_nospecial", skinframe->basename),loadglowtexture ? palette_nocolormapnofullbrights : palette_nocolormap, textureflags, false); // no special colors
+			skinframe->base = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_nospecial", skinframe->basename),loadglowtexture ? palette_nocolormapnofullbrights : palette_nocolormap, skinframe->textureflags, false); // no special colors
 		if (textureflags & TEXF_ALPHA)
 		{
 			// if not using a custom alphapalette, use the quake one
@@ -1337,7 +1516,7 @@ skinframe_t *R_SkinFrame_LoadInternal(const char *name, int textureflags, int lo
 				if (((unsigned char *)alphapalette)[skindata[i]*4+3] < 255)
 					break;
 			if (i < width * height)
-				skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), alphapalette, textureflags, true); // fog mask
+				skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), alphapalette, skinframe->textureflags, true); // fog mask
 		}
 	}
 
@@ -1397,6 +1576,7 @@ void gl_main_start(void)
 	}
 	R_BuildFogTexture();
 	memset(&r_bloomstate, 0, sizeof(r_bloomstate));
+	memset(&r_waterstate, 0, sizeof(r_waterstate));
 	memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
 	memset(&r_svbsp, 0, sizeof (r_svbsp));
 }
@@ -1416,10 +1596,12 @@ void gl_main_shutdown(void)
 	R_FreeTexturePool(&r_main_texturepool);
 	r_texture_blanknormalmap = NULL;
 	r_texture_white = NULL;
+	r_texture_grey128 = NULL;
 	r_texture_black = NULL;
 	r_texture_whitecube = NULL;
 	r_texture_normalizationcube = NULL;
 	memset(&r_bloomstate, 0, sizeof(r_bloomstate));
+	memset(&r_waterstate, 0, sizeof(r_waterstate));
 	R_GLSL_Restart_f();
 }
 
@@ -1453,6 +1635,7 @@ void GL_Main_Init(void)
 	r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
 
 	Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
+	Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
 	// FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
 	if (gamemode == GAME_NEHAHRA)
 	{
@@ -1491,11 +1674,24 @@ void GL_Main_Init(void)
 	Cvar_RegisterVariable(&r_shadows);
 	Cvar_RegisterVariable(&r_shadows_throwdistance);
 	Cvar_RegisterVariable(&r_q1bsp_skymasking);
+	Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
+	Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
 	Cvar_RegisterVariable(&r_textureunits);
 	Cvar_RegisterVariable(&r_glsl);
 	Cvar_RegisterVariable(&r_glsl_offsetmapping);
 	Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
 	Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
+	Cvar_RegisterVariable(&r_glsl_water);
+	Cvar_RegisterVariable(&r_glsl_water_resolutionmultiplier);
+	Cvar_RegisterVariable(&r_glsl_water_clippingplanebias);
+	Cvar_RegisterVariable(&r_glsl_water_refractcolor_r);
+	Cvar_RegisterVariable(&r_glsl_water_refractcolor_g);
+	Cvar_RegisterVariable(&r_glsl_water_refractcolor_b);
+	Cvar_RegisterVariable(&r_glsl_water_reflectcolor_r);
+	Cvar_RegisterVariable(&r_glsl_water_reflectcolor_g);
+	Cvar_RegisterVariable(&r_glsl_water_reflectcolor_b);
+	Cvar_RegisterVariable(&r_glsl_water_refractdistort);
+	Cvar_RegisterVariable(&r_glsl_water_reflectdistort);
 	Cvar_RegisterVariable(&r_glsl_deluxemapping);
 	Cvar_RegisterVariable(&r_lerpsprites);
 	Cvar_RegisterVariable(&r_lerpmodels);
@@ -1509,6 +1705,7 @@ void GL_Main_Init(void)
 	Cvar_RegisterVariable(&r_bloom_colorsubtract);
 	Cvar_RegisterVariable(&r_hdr);
 	Cvar_RegisterVariable(&r_hdr_scenebrightness);
+	Cvar_RegisterVariable(&r_glsl_contrastboost);
 	Cvar_RegisterVariable(&r_hdr_glowintensity);
 	Cvar_RegisterVariable(&r_hdr_range);
 	Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
@@ -1575,7 +1772,7 @@ int R_CullBox(const vec3_t mins, const vec3_t maxs)
 {
 	int i;
 	mplane_t *p;
-	for (i = 0;i < 4;i++)
+	for (i = 0;i < r_view.numfrustumplanes;i++)
 	{
 		p = r_view.frustum + i;
 		switch(p->signbits)
@@ -1712,7 +1909,7 @@ static void R_View_UpdateEntityVisible (void)
 	if (!r_drawentities.integer)
 		return;
 
-	renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : (chase_active.integer ? 0 : RENDER_EXTERIORMODEL);
+	renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
 	if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
 	{
 		// worldmodel can check visibility
@@ -1774,8 +1971,8 @@ int R_DrawBrushModelsSky (void)
 	return sky;
 }
 
-void R_DrawNoModel(entity_render_t *ent);
-void R_DrawModels(void)
+static void R_DrawNoModel(entity_render_t *ent);
+static void R_DrawModels(void)
 {
 	int i;
 	entity_render_t *ent;
@@ -1796,7 +1993,7 @@ void R_DrawModels(void)
 	}
 }
 
-void R_DrawModelsDepth(void)
+static void R_DrawModelsDepth(void)
 {
 	int i;
 	entity_render_t *ent;
@@ -1815,8 +2012,28 @@ void R_DrawModelsDepth(void)
 	}
 }
 
+static void R_DrawModelsAddWaterPlanes(void)
+{
+	int i;
+	entity_render_t *ent;
+
+	if (!r_drawentities.integer)
+		return;
+
+	for (i = 0;i < r_refdef.numentities;i++)
+	{
+		if (!r_viewcache.entityvisible[i])
+			continue;
+		ent = r_refdef.entities[i];
+		r_refdef.stats.entities++;
+		if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
+			ent->model->DrawAddWaterPlanes(ent);
+	}
+}
+
 static void R_View_SetFrustum(void)
 {
+	int i;
 	double slopex, slopey;
 
 	// break apart the view matrix into vectors for various purposes
@@ -1887,33 +2104,51 @@ static void R_View_SetFrustum(void)
 
 
 
-	slopex = 1.0 / r_view.frustum_x;
-	slopey = 1.0 / r_view.frustum_y;
-	VectorMA(r_view.forward, -slopex, r_view.left, r_view.frustum[0].normal);
-	VectorMA(r_view.forward,  slopex, r_view.left, r_view.frustum[1].normal);
-	VectorMA(r_view.forward, -slopey, r_view.up  , r_view.frustum[2].normal);
-	VectorMA(r_view.forward,  slopey, r_view.up  , r_view.frustum[3].normal);
-	VectorCopy(r_view.forward, r_view.frustum[4].normal);
-	VectorNormalize(r_view.frustum[0].normal);
-	VectorNormalize(r_view.frustum[1].normal);
-	VectorNormalize(r_view.frustum[2].normal);
-	VectorNormalize(r_view.frustum[3].normal);
-	r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
-	r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
-	r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
-	r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
-	r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
-	PlaneClassify(&r_view.frustum[0]);
-	PlaneClassify(&r_view.frustum[1]);
-	PlaneClassify(&r_view.frustum[2]);
-	PlaneClassify(&r_view.frustum[3]);
-	PlaneClassify(&r_view.frustum[4]);
-
-	// calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
-	VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
-	VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward,  1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[1]);
-	VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left,  1024 * slopey, r_view.up, r_view.frustumcorner[2]);
-	VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward,  1024 * slopex, r_view.left,  1024 * slopey, r_view.up, r_view.frustumcorner[3]);
+	if (r_view.useperspective)
+	{
+		slopex = 1.0 / r_view.frustum_x;
+		slopey = 1.0 / r_view.frustum_y;
+		VectorMA(r_view.forward, -slopex, r_view.left, r_view.frustum[0].normal);
+		VectorMA(r_view.forward,  slopex, r_view.left, r_view.frustum[1].normal);
+		VectorMA(r_view.forward, -slopey, r_view.up  , r_view.frustum[2].normal);
+		VectorMA(r_view.forward,  slopey, r_view.up  , r_view.frustum[3].normal);
+		VectorCopy(r_view.forward, r_view.frustum[4].normal);
+
+		// calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
+		VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
+		VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward,  1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[1]);
+		VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left,  1024 * slopey, r_view.up, r_view.frustumcorner[2]);
+		VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward,  1024 * slopex, r_view.left,  1024 * slopey, r_view.up, r_view.frustumcorner[3]);
+
+		r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
+		r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
+		r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
+		r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
+		r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
+	}
+	else
+	{
+		VectorScale(r_view.left, -r_view.ortho_x, r_view.frustum[0].normal);
+		VectorScale(r_view.left,  r_view.ortho_x, r_view.frustum[1].normal);
+		VectorScale(r_view.up, -r_view.ortho_y, r_view.frustum[2].normal);
+		VectorScale(r_view.up,  r_view.ortho_y, r_view.frustum[3].normal);
+		VectorCopy(r_view.forward, r_view.frustum[4].normal);
+		r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal) + r_view.ortho_x;
+		r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal) + r_view.ortho_x;
+		r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal) + r_view.ortho_y;
+		r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal) + r_view.ortho_y;
+		r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
+	}
+	r_view.numfrustumplanes = 5;
+
+	if (r_view.useclipplane)
+	{
+		r_view.numfrustumplanes = 6;
+		r_view.frustum[5] = r_view.clipplane;
+	}
+
+	for (i = 0;i < r_view.numfrustumplanes;i++)
+		PlaneClassify(r_view.frustum + i);
 
 	// LordHavoc: note to all quake engine coders, Quake had a special case
 	// for 90 degrees which assumed a square view (wrong), so I removed it,
@@ -1948,18 +2183,30 @@ static void R_View_SetFrustum(void)
 void R_View_Update(void)
 {
 	R_View_SetFrustum();
-	R_View_WorldVisibility();
+	R_View_WorldVisibility(r_view.useclipplane);
 	R_View_UpdateEntityVisible();
 }
 
-void R_SetupView(const matrix4x4_t *matrix)
+void R_SetupView(void)
 {
-	if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
+	if (!r_view.useperspective)
+		GL_SetupView_Mode_Ortho(-r_view.ortho_x, -r_view.ortho_y, r_view.ortho_x, r_view.ortho_y, -r_refdef.farclip, r_refdef.farclip);
+	else if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
 		GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
 	else
 		GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
 
-	GL_SetupView_Orientation_FromEntity(matrix);
+	GL_SetupView_Orientation_FromEntity(&r_view.matrix);
+
+	if (r_view.useclipplane)
+	{
+		// LordHavoc: couldn't figure out how to make this approach the
+		vec_t dist = r_view.clipplane.dist - r_glsl_water_clippingplanebias.value;
+		vec_t viewdist = DotProduct(r_view.origin, r_view.clipplane.normal);
+		if (viewdist < r_view.clipplane.dist + r_glsl_water_clippingplanebias.value)
+			dist = r_view.clipplane.dist;
+		GL_SetupView_ApplyCustomNearClipPlane(r_view.clipplane.normal[0], r_view.clipplane.normal[1], r_view.clipplane.normal[2], dist);
+	}
 }
 
 void R_ResetViewRendering2D(void)
@@ -1985,7 +2232,7 @@ void R_ResetViewRendering2D(void)
 	GL_DepthTest(false);
 	R_Mesh_Matrix(&identitymatrix);
 	R_Mesh_ResetTextureState();
-	qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
+	GL_PolygonOffset(0, 0);
 	qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
 	qglDepthFunc(GL_LEQUAL);CHECKGLERROR
 	qglDisable(GL_STENCIL_TEST);CHECKGLERROR
@@ -2006,7 +2253,7 @@ void R_ResetViewRendering3D(void)
 
 	// GL is weird because it's bottom to top, r_view.y is top to bottom
 	qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
-	R_SetupView(&r_view.matrix);
+	R_SetupView();
 	GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
 	GL_Color(1, 1, 1, 1);
 	GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
@@ -2018,14 +2265,14 @@ void R_ResetViewRendering3D(void)
 	GL_DepthTest(true);
 	R_Mesh_Matrix(&identitymatrix);
 	R_Mesh_ResetTextureState();
-	qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
+	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 	qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
 	qglDepthFunc(GL_LEQUAL);CHECKGLERROR
 	qglDisable(GL_STENCIL_TEST);CHECKGLERROR
 	qglStencilMask(~0);CHECKGLERROR
 	qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
 	qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
-	GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
+	GL_CullFace(r_view.cullface_back);
 }
 
 /*
@@ -2089,7 +2336,170 @@ void R_ResetViewRendering3D(void)
 "#endif // FRAGMENT_SHADER\n"
 */
 
-void R_RenderScene(void);
+void R_RenderScene(qboolean addwaterplanes);
+
+static void R_Water_StartFrame(void)
+{
+	int i;
+	int texturewidth, textureheight;
+	r_waterstate_waterplane_t *p;
+
+	r_waterstate.maxwaterplanes = 0;
+
+	// set waterwidth and waterheight to the water resolution that will be
+	// used (often less than the screen resolution for faster rendering)
+	r_waterstate.waterwidth = (int)bound(1, r_view.width * r_glsl_water_resolutionmultiplier.value, r_view.width);
+	r_waterstate.waterheight = (int)bound(1, r_view.height * r_glsl_water_resolutionmultiplier.value, r_view.height);
+
+	// calculate desired texture sizes
+	if (gl_support_arb_texture_non_power_of_two)
+	{
+		texturewidth = r_waterstate.waterwidth;
+		textureheight = r_waterstate.waterheight;
+	}
+	else
+	{
+		for (texturewidth   = 1;texturewidth   < r_waterstate.waterwidth ;texturewidth   *= 2);
+		for (textureheight  = 1;textureheight  < r_waterstate.waterheight;textureheight  *= 2);
+	}
+
+	if (!r_glsl_water.integer)
+		texturewidth = textureheight = 0;
+
+	// allocate textures as needed
+	if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
+	{
+		for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
+		{
+			if (p->texture_refraction)
+				R_FreeTexture(p->texture_refraction);
+			p->texture_refraction = NULL;
+			if (p->texture_reflection)
+				R_FreeTexture(p->texture_reflection);
+			p->texture_reflection = NULL;
+		}
+		r_waterstate.texturewidth = texturewidth;
+		r_waterstate.textureheight = textureheight;
+	}
+
+	if ((!texturewidth && !textureheight) || texturewidth > gl_max_texture_size || textureheight > gl_max_texture_size)
+	{
+		// can't use water if the parameters are too weird
+		// can't use water if the card does not support the texture size
+		memset(&r_waterstate, 0, sizeof(r_waterstate));
+		return;
+	}
+
+	r_waterstate.enabled = true;
+
+	r_waterstate.maxwaterplanes = MAX_WATERPLANES;
+
+	// set up variables that will be used in shader setup
+	r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
+	r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
+	r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
+	r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
+}
+
+static void R_Water_AddWaterPlane(msurface_t *surface)
+{
+	int triangleindex, planeindex;
+	const int *e;
+	vec3_t vert[3];
+	vec3_t normal;
+	r_waterstate_waterplane_t *p;
+	// just use the first triangle with a valid normal for any decisions
+	VectorClear(normal);
+	for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
+	{
+		Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
+		Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
+		Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
+		TriangleNormal(vert[0], vert[1], vert[2], normal);
+		if (VectorLength2(normal) >= 0.001)
+			break;
+	}
+	for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
+		if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
+			break;
+	// if this triangle does not fit any known plane rendered this frame, render textures for it
+	if (planeindex >= r_waterstate.numwaterplanes && planeindex < r_waterstate.maxwaterplanes)
+	{
+		// store the new plane
+		r_waterstate.numwaterplanes++;
+		VectorCopy(normal, p->plane.normal);
+		VectorNormalize(p->plane.normal);
+		p->plane.dist = DotProduct(vert[0], p->plane.normal);
+		PlaneClassify(&p->plane);
+		// flip the plane if it does not face the viewer
+		if (PlaneDiff(r_view.origin, &p->plane) < 0)
+		{
+			VectorNegate(p->plane.normal, p->plane.normal);
+			p->plane.dist *= -1;
+			PlaneClassify(&p->plane);
+		}
+	}
+}
+
+static void R_Water_ProcessPlanes(void)
+{
+	r_view_t originalview;
+	int planeindex;
+	r_waterstate_waterplane_t *p;
+
+	for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
+	{
+		if (!p->texture_refraction)
+		{
+			p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
+			p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
+		}
+
+		originalview = r_view;
+		r_view.showdebug = false;
+		r_view.width = r_waterstate.waterwidth;
+		r_view.height = r_waterstate.waterheight;
+		r_view.useclipplane = true;
+
+		r_view.clipplane = p->plane;
+		VectorNegate(r_view.clipplane.normal, r_view.clipplane.normal);
+		r_view.clipplane.dist = -r_view.clipplane.dist;
+		PlaneClassify(&r_view.clipplane);
+		r_waterstate.renderingscene = true;
+		// render the normal view scene and copy into texture
+		// (except that a clipping plane should be used to hide everything on one side of the water, and the viewer's weapon model should be omitted)
+		R_RenderScene(false);
+
+		// copy view into the screen texture
+		R_Mesh_TexBind(0, R_GetTexture(p->texture_refraction));
+		GL_ActiveTexture(0);
+		CHECKGLERROR
+		qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
+
+		// render reflected scene and copy into texture
+		Matrix4x4_Reflect(&r_view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
+		r_view.clipplane = p->plane;
+		// reverse the cullface settings for this render
+		r_view.cullface_front = GL_FRONT;
+		r_view.cullface_back = GL_BACK;
+
+		R_ResetViewRendering3D();
+		R_ClearScreen();
+
+		R_RenderScene(false);
+
+		R_Mesh_TexBind(0, R_GetTexture(p->texture_reflection));
+		GL_ActiveTexture(0);
+		CHECKGLERROR
+		qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
+
+		R_ResetViewRendering3D();
+		R_ClearScreen();
+
+		r_view = originalview;
+		r_waterstate.renderingscene = false;
+	}
+}
 
 void R_Bloom_StartFrame(void)
 {
@@ -2248,7 +2658,7 @@ void R_Bloom_MakeTexture(void)
 	CHECKGLERROR
 	qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
 
-	for (x = 1;x < r_bloom_colorexponent.value;)
+	for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
 	{
 		x *= 2;
 		r = bound(0, r_bloom_colorexponent.value / x, 1);
@@ -2354,10 +2764,13 @@ void R_HDR_RenderBloomTexture(void)
 	// TODO: add exposure compensation features
 	// TODO: add fp16 framebuffer support
 
+	r_view.showdebug = false;
 	r_view.colorscale = r_bloom_colorscale.value * r_hdr_scenebrightness.value;
 	if (r_hdr.integer)
 		r_view.colorscale /= r_hdr_range.value;
-	R_RenderScene();
+	r_waterstate.numwaterplanes = 0;
+	R_RenderScene(r_waterstate.enabled);
+	r_view.showdebug = true;
 
 	R_ResetViewRendering2D();
 
@@ -2440,7 +2853,7 @@ static void R_BlendView(void)
 	}
 }
 
-void R_RenderScene(void);
+void R_RenderScene(qboolean addwaterplanes);
 
 matrix4x4_t r_waterscrollmatrix;
 
@@ -2463,7 +2876,7 @@ void R_UpdateVariables(void)
 	r_refdef.rtworld = r_shadow_realtime_world.integer;
 	r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
 	r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
-	r_refdef.rtdlightshadows = r_refdef.rtdlight && (r_refdef.rtworld ? r_shadow_realtime_world_dlightshadows.integer : r_shadow_realtime_dlight_shadows.integer) && gl_stencil;
+	r_refdef.rtdlightshadows = r_refdef.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil;
 	r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
 	if (r_showsurfaces.integer)
 	{
@@ -2526,28 +2939,28 @@ void R_RenderView(void)
 
 	R_Shadow_UpdateWorldLightSelection();
 
+	R_Bloom_StartFrame();
+	R_Water_StartFrame();
+
 	CHECKGLERROR
 	if (r_timereport_active)
 		R_TimeReport("setup");
 
-	R_View_Update();
-	if (r_timereport_active)
-		R_TimeReport("visibility");
-
 	R_ResetViewRendering3D();
 
 	R_ClearScreen();
 	if (r_timereport_active)
 		R_TimeReport("clear");
 
-	R_Bloom_StartFrame();
+	r_view.showdebug = true;
 
 	// this produces a bloom texture to be used in R_BlendView() later
 	if (r_hdr.integer)
 		R_HDR_RenderBloomTexture();
 
 	r_view.colorscale = r_hdr_scenebrightness.value;
-	R_RenderScene();
+	r_waterstate.numwaterplanes = 0;
+	R_RenderScene(r_waterstate.enabled);
 
 	R_BlendView();
 	if (r_timereport_active)
@@ -2564,18 +2977,50 @@ extern void R_DrawPortals (void);
 extern cvar_t cl_locs_show;
 static void R_DrawLocs(void);
 static void R_DrawEntityBBoxes(void);
-void R_RenderScene(void)
+void R_RenderScene(qboolean addwaterplanes)
 {
+	if (addwaterplanes)
+	{
+		R_ResetViewRendering3D();
+
+		R_View_Update();
+		if (r_timereport_active)
+			R_TimeReport("watervisibility");
+
+		if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->Draw)
+		{
+			r_refdef.worldmodel->DrawAddWaterPlanes(r_refdef.worldentity);
+			if (r_timereport_active)
+				R_TimeReport("waterworld");
+		}
+
+		// don't let sound skip if going slow
+		if (r_refdef.extraupdate)
+			S_ExtraUpdate ();
+
+		R_DrawModelsAddWaterPlanes();
+		if (r_timereport_active)
+			R_TimeReport("watermodels");
+
+		R_Water_ProcessPlanes();
+		if (r_timereport_active)
+			R_TimeReport("waterscenes");
+	}
+
+	R_ResetViewRendering3D();
+
 	// don't let sound skip if going slow
 	if (r_refdef.extraupdate)
 		S_ExtraUpdate ();
 
-	R_ResetViewRendering3D();
-
 	R_MeshQueue_BeginScene();
 
 	R_SkyStartFrame();
 
+	R_View_Update();
+	if (r_timereport_active)
+		R_TimeReport("visibility");
+
 	Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.time) * 0.025 * r_waterscroll.value, sin(r_refdef.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
 
 	if (cl.csqc_vidvars.drawworld)
@@ -2667,25 +3112,28 @@ void R_RenderScene(void)
 	}
 	VM_CL_AddPolygonsToMeshQueue();
 
-	if (cl_locs_show.integer)
+	if (r_view.showdebug)
 	{
-		R_DrawLocs();
-		if (r_timereport_active)
-			R_TimeReport("showlocs");
-	}
+		if (cl_locs_show.integer)
+		{
+			R_DrawLocs();
+			if (r_timereport_active)
+				R_TimeReport("showlocs");
+		}
 
-	if (r_drawportals.integer)
-	{
-		R_DrawPortals();
-		if (r_timereport_active)
-			R_TimeReport("portals");
-	}
+		if (r_drawportals.integer)
+		{
+			R_DrawPortals();
+			if (r_timereport_active)
+				R_TimeReport("portals");
+		}
 
-	if (r_showbboxes.value > 0)
-	{
-		R_DrawEntityBBoxes();
-		if (r_timereport_active)
-			R_TimeReport("bboxes");
+		if (r_showbboxes.value > 0)
+		{
+			R_DrawEntityBBoxes();
+			if (r_timereport_active)
+				R_TimeReport("bboxes");
+		}
 	}
 
 	if (gl_support_fragment_shader)
@@ -2732,6 +3180,7 @@ void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, floa
 	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	GL_DepthMask(false);
 	GL_DepthRange(0, 1);
+	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 	R_Mesh_Matrix(&identitymatrix);
 	R_Mesh_ResetTextureState();
 
@@ -2785,7 +3234,7 @@ static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtligh
 		color[3] *= r_showbboxes.value;
 		color[3] = bound(0, color[3], 1);
 		GL_DepthTest(!r_showdisabledepthtest.integer);
-		GL_CullFace(GL_BACK);
+		GL_CullFace(r_view.cullface_front);
 		R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
 	}
 	SV_VM_End();
@@ -2868,8 +3317,9 @@ void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight
 		GL_DepthMask(true);
 	}
 	GL_DepthRange(0, (ent->flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
+	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 	GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
-	GL_CullFace((ent->effects & EF_DOUBLESIDED) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+	GL_CullFace((ent->effects & EF_DOUBLESIDED) ? GL_NONE : r_view.cullface_back);
 	R_Mesh_VertexPointer(nomodelvertex3f, 0, 0);
 	if (r_refdef.fogenabled)
 	{
@@ -2905,7 +3355,7 @@ void R_DrawNoModel(entity_render_t *ent)
 	vec3_t org;
 	Matrix4x4_OriginFromMatrix(&ent->matrix, org);
 	//if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
-		R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, r_shadow_rtlight);
+		R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
 	//else
 	//	R_DrawNoModelCallback(ent, 0);
 }
@@ -2952,8 +3402,19 @@ void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_
 
 	R_Mesh_Matrix(&identitymatrix);
 	GL_BlendFunc(blendfunc1, blendfunc2);
+
+	if(v_flipped_state)
+	{
+		scalex1 = -scalex1;
+		scalex2 = -scalex2;
+		GL_CullFace(r_view.cullface_front);
+	}
+	else
+		GL_CullFace(r_view.cullface_back);
+
 	GL_DepthMask(false);
 	GL_DepthRange(0, depthshort ? 0.0625 : 1);
+	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 	GL_DepthTest(!depthdisable);
 
 	vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
@@ -3126,10 +3587,46 @@ static void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1,
 	layer->color[3] = a;
 }
 
+static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
+{
+	double index, f;
+	index = parms[2] + r_refdef.time * parms[3];
+	index -= floor(index);
+	switch (func)
+	{
+	default:
+	case Q3WAVEFUNC_NONE:
+	case Q3WAVEFUNC_NOISE:
+	case Q3WAVEFUNC_COUNT:
+		f = 0;
+		break;
+	case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
+	case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
+	case Q3WAVEFUNC_SAWTOOTH: f = index;break;
+	case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
+	case Q3WAVEFUNC_TRIANGLE:
+		index *= 4;
+		f = index - floor(index);
+		if (index < 1)
+			f = f;
+		else if (index < 2)
+			f = 1 - f;
+		else if (index < 3)
+			f = -f;
+		else
+			f = -(1 - f);
+		break;
+	}
+	return (float)(parms[0] + parms[1] * f);
+}
+
 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
 {
 	int i;
 	model_t *model = ent->model;
+	float f;
+	float tcmat[12];
+	q3shaderinfo_layer_tcmod_t *tcmod;
 
 	// switch to an alternate material if this is a q1bsp animated material
 	{
@@ -3150,7 +3647,7 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
 		{
 			// use an alternate animation if the entity's frame is not 0,
 			// and only if the texture has an alternate animation
-			if (ent->frame != 0 && t->anim_total[1])
+			if (ent->frame2 != 0 && t->anim_total[1])
 				t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[1]) : 0];
 			else
 				t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[0]) : 0];
@@ -3165,7 +3662,7 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
 		{
 			strlcpy(r_qwskincache[i], cl.scores[i].qw_skin, sizeof(r_qwskincache[i]));
 			Con_DPrintf("loading skins/%s\n", r_qwskincache[i]);
-			r_qwskincache_skinframe[i] = R_SkinFrame_LoadExternal(va("skins/%s", r_qwskincache[i]), TEXF_PRECACHE | (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP, developer.integer > 0);
+			r_qwskincache_skinframe[i] = R_SkinFrame_LoadExternal(va("skins/%s", r_qwskincache[i]), TEXF_PRECACHE | (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS, developer.integer > 0);
 		}
 		t->currentskinframe = r_qwskincache_skinframe[i];
 		if (t->currentskinframe == NULL)
@@ -3179,7 +3676,12 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
 	t->currentmaterialflags = t->basematerialflags;
 	t->currentalpha = ent->alpha;
 	if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
+	{
 		t->currentalpha *= r_wateralpha.value;
+		// if rendering refraction/reflection, disable transparency
+		if (r_waterstate.enabled && (t->currentalpha < 1 || (t->currentmaterialflags & MATERIALFLAG_ALPHA)))
+			t->currentmaterialflags |= MATERIALFLAG_WATERSHADER;
+	}
 	if (!(ent->flags & RENDER_LIGHT))
 		t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
 	if (ent->effects & EF_ADDITIVE)
@@ -3192,12 +3694,64 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
 		t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
 	if (ent->flags & RENDER_VIEWMODEL)
 		t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
-	if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
-		t->currenttexmatrix = r_waterscrollmatrix;
-	else
-		t->currenttexmatrix = identitymatrix;
 	if (t->backgroundnumskinframes && !(t->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
 		t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
+	if (t->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+		t->currentmaterialflags &= ~(MATERIALFLAG_ADD | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_CUSTOMBLEND);
+
+	for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && (tcmod->tcmod || i < 1);i++, tcmod++)
+	{
+		matrix4x4_t matrix;
+		switch(tcmod->tcmod)
+		{
+		case Q3TCMOD_COUNT:
+		case Q3TCMOD_NONE:
+			if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
+				matrix = r_waterscrollmatrix;
+			else
+				matrix = identitymatrix;
+			break;
+		case Q3TCMOD_ENTITYTRANSLATE:
+			// this is used in Q3 to allow the gamecode to control texcoord
+			// scrolling on the entity, which is not supported in darkplaces yet.
+			Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
+			break;
+		case Q3TCMOD_ROTATE:
+			Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
+			Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.time, 0, 0, 1);
+			Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
+			break;
+		case Q3TCMOD_SCALE:
+			Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
+			break;
+		case Q3TCMOD_SCROLL:
+			Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.time, tcmod->parms[1] * r_refdef.time, 0);
+			break;
+		case Q3TCMOD_STRETCH:
+			f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
+			Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
+			break;
+		case Q3TCMOD_TRANSFORM:
+			VectorSet(tcmat +  0, tcmod->parms[0], tcmod->parms[1], 0);
+			VectorSet(tcmat +  3, tcmod->parms[2], tcmod->parms[3], 0);
+			VectorSet(tcmat +  6, 0                   , 0                , 1);
+			VectorSet(tcmat +  9, tcmod->parms[4], tcmod->parms[5], 0);
+			Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
+			break;
+		case Q3TCMOD_TURBULENT:
+			// this is handled in the RSurf_PrepareVertices function
+			matrix = identitymatrix;
+			break;
+		}
+		// either replace or concatenate the transformation
+		if (i < 1)
+			t->currenttexmatrix = matrix;
+		else
+		{
+			matrix4x4_t temp = t->currenttexmatrix;
+			Matrix4x4_Concat(&t->currenttexmatrix, &matrix, &temp);
+		}
+	}
 
 	t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
 	t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
@@ -3213,8 +3767,8 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
 		{
 			if (r_shadow_glossintensity.value > 0)
 			{
-				t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_black;
-				t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_black;
+				t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
+				t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
 				t->specularscale = r_shadow_glossintensity.value;
 			}
 		}
@@ -3222,6 +3776,27 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
 			t->specularscale = r_shadow_gloss2intensity.value;
 	}
 
+	// lightmaps mode looks bad with dlights using actual texturing, so turn
+	// off the colormap and glossmap, but leave the normalmap on as it still
+	// accurately represents the shading involved
+	if (gl_lightmaps.integer && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
+	{
+		t->basetexture = r_texture_white;
+		t->specularscale = 0;
+	}
+
+	t->currentpolygonfactor = r_refdef.polygonfactor + t->basepolygonfactor;
+	t->currentpolygonoffset = r_refdef.polygonoffset + t->basepolygonoffset;
+	// submodels are biased to avoid z-fighting with world surfaces that they
+	// may be exactly overlapping (avoids z-fighting artifacts on certain
+	// doors and things in Quake maps)
+	if (ent->model->brush.submodel)
+	{
+		t->currentpolygonfactor += r_polygonoffset_submodel_factor.value;
+		t->currentpolygonoffset += r_polygonoffset_submodel_offset.value;
+	}
+
+	VectorClear(t->dlightcolor);
 	t->currentnumlayers = 0;
 	if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
 	{
@@ -3268,10 +3843,13 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
 				else
 				{
 					float colorscale;
+					// set the color tint used for lights affecting this surface
+					VectorSet(t->dlightcolor, ent->colormod[0] * t->currentalpha, ent->colormod[1] * t->currentalpha, ent->colormod[2] * t->currentalpha);
 					colorscale = 2;
 					// q3bsp has no lightmap updates, so the lightstylevalue that
 					// would normally be baked into the lightmap must be
 					// applied to the color
+					// FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
 					if (ent->model->type == mod_brushq3)
 						colorscale *= r_refdef.lightstylevalue[0] * (1.0f / 256.0f);
 					colorscale *= r_refdef.lightmapintensity;
@@ -3321,298 +3899,629 @@ void R_UpdateAllTextureInfo(entity_render_t *ent)
 			R_UpdateTextureInfo(ent, ent->model->data_textures + i);
 }
 
-int rsurface_array_size = 0;
-float *rsurface_array_modelvertex3f = NULL;
-float *rsurface_array_modelsvector3f = NULL;
-float *rsurface_array_modeltvector3f = NULL;
-float *rsurface_array_modelnormal3f = NULL;
-float *rsurface_array_deformedvertex3f = NULL;
-float *rsurface_array_deformedsvector3f = NULL;
-float *rsurface_array_deformedtvector3f = NULL;
-float *rsurface_array_deformednormal3f = NULL;
-float *rsurface_array_color4f = NULL;
-float *rsurface_array_texcoord3f = NULL;
+rsurfacestate_t rsurface;
 
 void R_Mesh_ResizeArrays(int newvertices)
 {
 	float *base;
-	if (rsurface_array_size >= newvertices)
+	if (rsurface.array_size >= newvertices)
 		return;
-	if (rsurface_array_modelvertex3f)
-		Mem_Free(rsurface_array_modelvertex3f);
-	rsurface_array_size = (newvertices + 1023) & ~1023;
-	base = (float *)Mem_Alloc(r_main_mempool, rsurface_array_size * sizeof(float[31]));
-	rsurface_array_modelvertex3f     = base + rsurface_array_size * 0;
-	rsurface_array_modelsvector3f    = base + rsurface_array_size * 3;
-	rsurface_array_modeltvector3f    = base + rsurface_array_size * 6;
-	rsurface_array_modelnormal3f     = base + rsurface_array_size * 9;
-	rsurface_array_deformedvertex3f  = base + rsurface_array_size * 12;
-	rsurface_array_deformedsvector3f = base + rsurface_array_size * 15;
-	rsurface_array_deformedtvector3f = base + rsurface_array_size * 18;
-	rsurface_array_deformednormal3f  = base + rsurface_array_size * 21;
-	rsurface_array_texcoord3f        = base + rsurface_array_size * 24;
-	rsurface_array_color4f           = base + rsurface_array_size * 27;
+	if (rsurface.array_modelvertex3f)
+		Mem_Free(rsurface.array_modelvertex3f);
+	rsurface.array_size = (newvertices + 1023) & ~1023;
+	base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
+	rsurface.array_modelvertex3f     = base + rsurface.array_size * 0;
+	rsurface.array_modelsvector3f    = base + rsurface.array_size * 3;
+	rsurface.array_modeltvector3f    = base + rsurface.array_size * 6;
+	rsurface.array_modelnormal3f     = base + rsurface.array_size * 9;
+	rsurface.array_deformedvertex3f  = base + rsurface.array_size * 12;
+	rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
+	rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
+	rsurface.array_deformednormal3f  = base + rsurface.array_size * 21;
+	rsurface.array_texcoord3f        = base + rsurface.array_size * 24;
+	rsurface.array_color4f           = base + rsurface.array_size * 27;
+	rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
 }
 
-float *rsurface_modelvertex3f;
-int rsurface_modelvertex3f_bufferobject;
-size_t rsurface_modelvertex3f_bufferoffset;
-float *rsurface_modelsvector3f;
-int rsurface_modelsvector3f_bufferobject;
-size_t rsurface_modelsvector3f_bufferoffset;
-float *rsurface_modeltvector3f;
-int rsurface_modeltvector3f_bufferobject;
-size_t rsurface_modeltvector3f_bufferoffset;
-float *rsurface_modelnormal3f;
-int rsurface_modelnormal3f_bufferobject;
-size_t rsurface_modelnormal3f_bufferoffset;
-float *rsurface_vertex3f;
-int rsurface_vertex3f_bufferobject;
-size_t rsurface_vertex3f_bufferoffset;
-float *rsurface_svector3f;
-int rsurface_svector3f_bufferobject;
-size_t rsurface_svector3f_bufferoffset;
-float *rsurface_tvector3f;
-int rsurface_tvector3f_bufferobject;
-size_t rsurface_tvector3f_bufferoffset;
-float *rsurface_normal3f;
-int rsurface_normal3f_bufferobject;
-size_t rsurface_normal3f_bufferoffset;
-float *rsurface_lightmapcolor4f;
-int rsurface_lightmapcolor4f_bufferobject;
-size_t rsurface_lightmapcolor4f_bufferoffset;
-vec3_t rsurface_modelorg;
-qboolean rsurface_generatedvertex;
-const entity_render_t *rsurface_entity;
-const model_t *rsurface_model;
-texture_t *rsurface_texture;
-qboolean rsurface_uselightmaptexture;
-rsurfmode_t rsurface_mode;
-int rsurface_lightmode; // 0 = lightmap or fullbright, 1 = color array from q3bsp, 2 = vertex shaded model
-
 void RSurf_CleanUp(void)
 {
 	CHECKGLERROR
-	if (rsurface_mode == RSURFMODE_GLSL)
+	if (rsurface.mode == RSURFMODE_GLSL)
 	{
 		qglUseProgramObjectARB(0);CHECKGLERROR
 	}
 	GL_AlphaTest(false);
-	rsurface_mode = RSURFMODE_NONE;
-	rsurface_uselightmaptexture = false;
-	rsurface_texture = NULL;
+	rsurface.mode = RSURFMODE_NONE;
+	rsurface.uselightmaptexture = false;
+	rsurface.texture = NULL;
 }
 
 void RSurf_ActiveWorldEntity(void)
 {
+	model_t *model = r_refdef.worldmodel;
 	RSurf_CleanUp();
-	rsurface_entity = r_refdef.worldentity;
-	rsurface_model = r_refdef.worldmodel;
-	if (rsurface_array_size < rsurface_model->surfmesh.num_vertices)
-		R_Mesh_ResizeArrays(rsurface_model->surfmesh.num_vertices);
+	if (rsurface.array_size < model->surfmesh.num_vertices)
+		R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
+	rsurface.matrix = identitymatrix;
+	rsurface.inversematrix = identitymatrix;
 	R_Mesh_Matrix(&identitymatrix);
-	VectorCopy(r_view.origin, rsurface_modelorg);
-	rsurface_modelvertex3f  = rsurface_model->surfmesh.data_vertex3f;
-	rsurface_modelvertex3f_bufferobject = rsurface_model->surfmesh.vbo;
-	rsurface_modelvertex3f_bufferoffset = rsurface_model->surfmesh.vbooffset_vertex3f;
-	rsurface_modelsvector3f = rsurface_model->surfmesh.data_svector3f;
-	rsurface_modelsvector3f_bufferobject = rsurface_model->surfmesh.vbo;
-	rsurface_modelsvector3f_bufferoffset = rsurface_model->surfmesh.vbooffset_svector3f;
-	rsurface_modeltvector3f = rsurface_model->surfmesh.data_tvector3f;
-	rsurface_modeltvector3f_bufferobject = rsurface_model->surfmesh.vbo;
-	rsurface_modeltvector3f_bufferoffset = rsurface_model->surfmesh.vbooffset_tvector3f;
-	rsurface_modelnormal3f  = rsurface_model->surfmesh.data_normal3f;
-	rsurface_modelnormal3f_bufferobject = rsurface_model->surfmesh.vbo;
-	rsurface_modelnormal3f_bufferoffset = rsurface_model->surfmesh.vbooffset_normal3f;
-	rsurface_generatedvertex = false;
-	rsurface_vertex3f  = rsurface_modelvertex3f;
-	rsurface_vertex3f_bufferobject = rsurface_modelvertex3f_bufferobject;
-	rsurface_vertex3f_bufferoffset = rsurface_modelvertex3f_bufferoffset;
-	rsurface_svector3f = rsurface_modelsvector3f;
-	rsurface_svector3f_bufferobject = rsurface_modelsvector3f_bufferobject;
-	rsurface_svector3f_bufferoffset = rsurface_modelsvector3f_bufferoffset;
-	rsurface_tvector3f = rsurface_modeltvector3f;
-	rsurface_tvector3f_bufferobject = rsurface_modeltvector3f_bufferobject;
-	rsurface_tvector3f_bufferoffset = rsurface_modeltvector3f_bufferoffset;
-	rsurface_normal3f  = rsurface_modelnormal3f;
-	rsurface_normal3f_bufferobject = rsurface_modelnormal3f_bufferobject;
-	rsurface_normal3f_bufferoffset = rsurface_modelnormal3f_bufferoffset;
+	VectorCopy(r_view.origin, rsurface.modelorg);
+	VectorSet(rsurface.modellight_ambient, 0, 0, 0);
+	VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
+	VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
+	VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
+	VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
+	rsurface.frameblend[0].frame = 0;
+	rsurface.frameblend[0].lerp = 1;
+	rsurface.frameblend[1].frame = 0;
+	rsurface.frameblend[1].lerp = 0;
+	rsurface.frameblend[2].frame = 0;
+	rsurface.frameblend[2].lerp = 0;
+	rsurface.frameblend[3].frame = 0;
+	rsurface.frameblend[3].lerp = 0;
+	rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
+	rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
+	rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
+	rsurface.modelsvector3f = model->surfmesh.data_svector3f;
+	rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
+	rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
+	rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
+	rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
+	rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
+	rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
+	rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
+	rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
+	rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
+	rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
+	rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
+	rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
+	rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
+	rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
+	rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
+	rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
+	rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
+	rsurface.modelelement3i = model->surfmesh.data_element3i;
+	rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
+	rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
+	rsurface.modelnum_vertices = model->surfmesh.num_vertices;
+	rsurface.modelnum_triangles = model->surfmesh.num_triangles;
+	rsurface.modelsurfaces = model->data_surfaces;
+	rsurface.generatedvertex = false;
+	rsurface.vertex3f  = rsurface.modelvertex3f;
+	rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
+	rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
+	rsurface.svector3f = rsurface.modelsvector3f;
+	rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
+	rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
+	rsurface.tvector3f = rsurface.modeltvector3f;
+	rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
+	rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
+	rsurface.normal3f  = rsurface.modelnormal3f;
+	rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
+	rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
+	rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
 }
 
 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
 {
+	model_t *model = ent->model;
 	RSurf_CleanUp();
-	rsurface_entity = ent;
-	rsurface_model = ent->model;
-	if (rsurface_array_size < rsurface_model->surfmesh.num_vertices)
-		R_Mesh_ResizeArrays(rsurface_model->surfmesh.num_vertices);
-	R_Mesh_Matrix(&ent->matrix);
-	Matrix4x4_Transform(&ent->inversematrix, r_view.origin, rsurface_modelorg);
-	if (rsurface_model->surfmesh.isanimated && (rsurface_entity->frameblend[0].lerp != 1 || rsurface_entity->frameblend[0].frame != 0))
+	if (rsurface.array_size < model->surfmesh.num_vertices)
+		R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
+	rsurface.matrix = ent->matrix;
+	rsurface.inversematrix = ent->inversematrix;
+	R_Mesh_Matrix(&rsurface.matrix);
+	Matrix4x4_Transform(&rsurface.inversematrix, r_view.origin, rsurface.modelorg);
+	VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
+	VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
+	VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
+	VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
+	VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
+	rsurface.frameblend[0] = ent->frameblend[0];
+	rsurface.frameblend[1] = ent->frameblend[1];
+	rsurface.frameblend[2] = ent->frameblend[2];
+	rsurface.frameblend[3] = ent->frameblend[3];
+	if (model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0))
 	{
 		if (wanttangents)
 		{
-			rsurface_modelvertex3f = rsurface_array_modelvertex3f;
-			rsurface_modelsvector3f = rsurface_array_modelsvector3f;
-			rsurface_modeltvector3f = rsurface_array_modeltvector3f;
-			rsurface_modelnormal3f = rsurface_array_modelnormal3f;
-			Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, rsurface_array_modelnormal3f, rsurface_array_modelsvector3f, rsurface_array_modeltvector3f);
+			rsurface.modelvertex3f = rsurface.array_modelvertex3f;
+			rsurface.modelsvector3f = rsurface.array_modelsvector3f;
+			rsurface.modeltvector3f = rsurface.array_modeltvector3f;
+			rsurface.modelnormal3f = rsurface.array_modelnormal3f;
+			Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
 		}
 		else if (wantnormals)
 		{
-			rsurface_modelvertex3f = rsurface_array_modelvertex3f;
-			rsurface_modelsvector3f = NULL;
-			rsurface_modeltvector3f = NULL;
-			rsurface_modelnormal3f = rsurface_array_modelnormal3f;
-			Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, rsurface_array_modelnormal3f, NULL, NULL);
+			rsurface.modelvertex3f = rsurface.array_modelvertex3f;
+			rsurface.modelsvector3f = NULL;
+			rsurface.modeltvector3f = NULL;
+			rsurface.modelnormal3f = rsurface.array_modelnormal3f;
+			Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
 		}
 		else
 		{
-			rsurface_modelvertex3f = rsurface_array_modelvertex3f;
-			rsurface_modelsvector3f = NULL;
-			rsurface_modeltvector3f = NULL;
-			rsurface_modelnormal3f = NULL;
-			Mod_Alias_GetMesh_Vertices(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, NULL, NULL, NULL);
+			rsurface.modelvertex3f = rsurface.array_modelvertex3f;
+			rsurface.modelsvector3f = NULL;
+			rsurface.modeltvector3f = NULL;
+			rsurface.modelnormal3f = NULL;
+			Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL);
 		}
-		rsurface_modelvertex3f_bufferobject = 0;
-		rsurface_modelvertex3f_bufferoffset = 0;
-		rsurface_modelsvector3f_bufferobject = 0;
-		rsurface_modelsvector3f_bufferoffset = 0;
-		rsurface_modeltvector3f_bufferobject = 0;
-		rsurface_modeltvector3f_bufferoffset = 0;
-		rsurface_modelnormal3f_bufferobject = 0;
-		rsurface_modelnormal3f_bufferoffset = 0;
-		rsurface_generatedvertex = true;
+		rsurface.modelvertex3f_bufferobject = 0;
+		rsurface.modelvertex3f_bufferoffset = 0;
+		rsurface.modelsvector3f_bufferobject = 0;
+		rsurface.modelsvector3f_bufferoffset = 0;
+		rsurface.modeltvector3f_bufferobject = 0;
+		rsurface.modeltvector3f_bufferoffset = 0;
+		rsurface.modelnormal3f_bufferobject = 0;
+		rsurface.modelnormal3f_bufferoffset = 0;
+		rsurface.generatedvertex = true;
 	}
 	else
 	{
-		rsurface_modelvertex3f  = rsurface_model->surfmesh.data_vertex3f;
-		rsurface_modelvertex3f_bufferobject = rsurface_model->surfmesh.vbo;
-		rsurface_modelvertex3f_bufferoffset = rsurface_model->surfmesh.vbooffset_vertex3f;
-		rsurface_modelsvector3f = rsurface_model->surfmesh.data_svector3f;
-		rsurface_modelsvector3f_bufferobject = rsurface_model->surfmesh.vbo;
-		rsurface_modelsvector3f_bufferoffset = rsurface_model->surfmesh.vbooffset_svector3f;
-		rsurface_modeltvector3f = rsurface_model->surfmesh.data_tvector3f;
-		rsurface_modeltvector3f_bufferobject = rsurface_model->surfmesh.vbo;
-		rsurface_modeltvector3f_bufferoffset = rsurface_model->surfmesh.vbooffset_tvector3f;
-		rsurface_modelnormal3f  = rsurface_model->surfmesh.data_normal3f;
-		rsurface_modelnormal3f_bufferobject = rsurface_model->surfmesh.vbo;
-		rsurface_modelnormal3f_bufferoffset = rsurface_model->surfmesh.vbooffset_normal3f;
-		rsurface_generatedvertex = false;
-	}
-	rsurface_vertex3f  = rsurface_modelvertex3f;
-	rsurface_vertex3f_bufferobject = rsurface_modelvertex3f_bufferobject;
-	rsurface_vertex3f_bufferoffset = rsurface_modelvertex3f_bufferoffset;
-	rsurface_svector3f = rsurface_modelsvector3f;
-	rsurface_svector3f_bufferobject = rsurface_modelsvector3f_bufferobject;
-	rsurface_svector3f_bufferoffset = rsurface_modelsvector3f_bufferoffset;
-	rsurface_tvector3f = rsurface_modeltvector3f;
-	rsurface_tvector3f_bufferobject = rsurface_modeltvector3f_bufferobject;
-	rsurface_tvector3f_bufferoffset = rsurface_modeltvector3f_bufferoffset;
-	rsurface_normal3f  = rsurface_modelnormal3f;
-	rsurface_normal3f_bufferobject = rsurface_modelnormal3f_bufferobject;
-	rsurface_normal3f_bufferoffset = rsurface_modelnormal3f_bufferoffset;
+		rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
+		rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
+		rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
+		rsurface.modelsvector3f = model->surfmesh.data_svector3f;
+		rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
+		rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
+		rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
+		rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
+		rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
+		rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
+		rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
+		rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
+		rsurface.generatedvertex = false;
+	}
+	rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
+	rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
+	rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
+	rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
+	rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
+	rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
+	rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
+	rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
+	rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
+	rsurface.modelelement3i = model->surfmesh.data_element3i;
+	rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
+	rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
+	rsurface.modelnum_vertices = model->surfmesh.num_vertices;
+	rsurface.modelnum_triangles = model->surfmesh.num_triangles;
+	rsurface.modelsurfaces = model->data_surfaces;
+	rsurface.vertex3f  = rsurface.modelvertex3f;
+	rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
+	rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
+	rsurface.svector3f = rsurface.modelsvector3f;
+	rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
+	rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
+	rsurface.tvector3f = rsurface.modeltvector3f;
+	rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
+	rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
+	rsurface.normal3f  = rsurface.modelnormal3f;
+	rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
+	rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
+	rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
 }
 
+static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
 {
-	// if vertices are dynamic (animated models), generate them into the temporary rsurface_array_model* arrays and point rsurface_model* at them instead of the static data from the model itself
-	if (rsurface_generatedvertex)
-	{
-		if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
-			generatetangents = true;
-		if (generatetangents)
+	int deformindex;
+	int texturesurfaceindex;
+	int i, j;
+	float amplitude;
+	float animpos;
+	float scale;
+	const float *v1, *in_tc;
+	float *out_tc;
+	float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
+	float waveparms[4];
+	q3shaderinfo_deform_t *deform;
+	// if vertices are dynamic (animated models), generate them into the temporary rsurface.array_model* arrays and point rsurface.model* at them instead of the static data from the model itself
+	if (rsurface.generatedvertex)
+	{
+		if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
 			generatenormals = true;
-		if (generatenormals && !rsurface_modelnormal3f)
+		for (i = 0;i < Q3MAXDEFORMS;i++)
+		{
+			if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
+			{
+				generatetangents = true;
+				generatenormals = true;
+			}
+			if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
+				generatenormals = true;
+		}
+		if (generatenormals && !rsurface.modelnormal3f)
 		{
-			rsurface_normal3f = rsurface_modelnormal3f = rsurface_array_modelnormal3f;
-			rsurface_normal3f_bufferobject = rsurface_modelnormal3f_bufferobject = 0;
-			rsurface_normal3f_bufferoffset = rsurface_modelnormal3f_bufferoffset = 0;
-			Mod_BuildNormals(0, rsurface_model->surfmesh.num_vertices, rsurface_model->surfmesh.num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_element3i, rsurface_array_modelnormal3f, r_smoothnormals_areaweighting.integer);
+			rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
+			rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
+			rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
+			Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer);
 		}
-		if (generatetangents && !rsurface_modelsvector3f)
+		if (generatetangents && !rsurface.modelsvector3f)
 		{
-			rsurface_svector3f = rsurface_modelsvector3f = rsurface_array_modelsvector3f;
-			rsurface_svector3f_bufferobject = rsurface_modelsvector3f_bufferobject = 0;
-			rsurface_svector3f_bufferoffset = rsurface_modelsvector3f_bufferoffset = 0;
-			rsurface_tvector3f = rsurface_modeltvector3f = rsurface_array_modeltvector3f;
-			rsurface_tvector3f_bufferobject = rsurface_modeltvector3f_bufferobject = 0;
-			rsurface_tvector3f_bufferoffset = rsurface_modeltvector3f_bufferoffset = 0;
-			Mod_BuildTextureVectorsFromNormals(0, rsurface_model->surfmesh.num_vertices, rsurface_model->surfmesh.num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_modelnormal3f, rsurface_model->surfmesh.data_element3i, rsurface_array_modelsvector3f, rsurface_array_modeltvector3f, r_smoothnormals_areaweighting.integer);
+			rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
+			rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
+			rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
+			rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
+			rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
+			rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
+			Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f, r_smoothnormals_areaweighting.integer);
 		}
 	}
-	// if vertices are deformed (sprite flares and things in maps, possibly water waves, bulges and other deformations), generate them into rsurface_deform* arrays from whatever the rsurface_model* array pointers point to (may be static model data or generated data for an animated model)
-	if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
-	{
-		int texturesurfaceindex;
-		float center[3], forward[3], right[3], up[3], v[4][3];
-		matrix4x4_t matrix1, imatrix1;
-		Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.forward, forward);
-		Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.right, right);
-		Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.up, up);
-		// make deformed versions of only the model vertices used by the specified surfaces
-		for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+	rsurface.vertex3f  = rsurface.modelvertex3f;
+	rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
+	rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
+	rsurface.svector3f = rsurface.modelsvector3f;
+	rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
+	rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
+	rsurface.tvector3f = rsurface.modeltvector3f;
+	rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
+	rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
+	rsurface.normal3f  = rsurface.modelnormal3f;
+	rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
+	rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
+	// if vertices are deformed (sprite flares and things in maps, possibly
+	// water waves, bulges and other deformations), generate them into
+	// rsurface.deform* arrays from whatever the rsurface.* arrays point to
+	// (may be static model data or generated data for an animated model, or
+	//  the previous deform pass)
+	for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
+	{
+		switch (deform->deform)
 		{
-			int i, j;
-			const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
-			// a single autosprite surface can contain multiple sprites...
-			for (j = 0;j < surface->num_vertices - 3;j += 4)
+		default:
+		case Q3DEFORM_PROJECTIONSHADOW:
+		case Q3DEFORM_TEXT0:
+		case Q3DEFORM_TEXT1:
+		case Q3DEFORM_TEXT2:
+		case Q3DEFORM_TEXT3:
+		case Q3DEFORM_TEXT4:
+		case Q3DEFORM_TEXT5:
+		case Q3DEFORM_TEXT6:
+		case Q3DEFORM_TEXT7:
+		case Q3DEFORM_NONE:
+			break;
+		case Q3DEFORM_AUTOSPRITE:
+			Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
+			Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
+			Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
+			VectorNormalize(newforward);
+			VectorNormalize(newright);
+			VectorNormalize(newup);
+			// make deformed versions of only the model vertices used by the specified surfaces
+			for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
 			{
-				VectorClear(center);
-				for (i = 0;i < 4;i++)
-					VectorAdd(center, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
-				VectorScale(center, 0.25f, center);
-				if (rsurface_texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE2)
+				const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+				// a single autosprite surface can contain multiple sprites...
+				for (j = 0;j < surface->num_vertices - 3;j += 4)
 				{
-					forward[0] = rsurface_modelorg[0] - center[0];
-					forward[1] = rsurface_modelorg[1] - center[1];
-					forward[2] = 0;
+					VectorClear(center);
+					for (i = 0;i < 4;i++)
+						VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
+					VectorScale(center, 0.25f, center);
+					VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, forward);
+					VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
+					VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
+					for (i = 0;i < 4;i++)
+					{
+						VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
+						VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
+					}
+				}
+				Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer);
+				Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
+			}
+			rsurface.vertex3f = rsurface.array_deformedvertex3f;
+			rsurface.vertex3f_bufferobject = 0;
+			rsurface.vertex3f_bufferoffset = 0;
+			rsurface.svector3f = rsurface.array_deformedsvector3f;
+			rsurface.svector3f_bufferobject = 0;
+			rsurface.svector3f_bufferoffset = 0;
+			rsurface.tvector3f = rsurface.array_deformedtvector3f;
+			rsurface.tvector3f_bufferobject = 0;
+			rsurface.tvector3f_bufferoffset = 0;
+			rsurface.normal3f = rsurface.array_deformednormal3f;
+			rsurface.normal3f_bufferobject = 0;
+			rsurface.normal3f_bufferoffset = 0;
+			break;
+		case Q3DEFORM_AUTOSPRITE2:
+			Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
+			Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
+			Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
+			VectorNormalize(newforward);
+			VectorNormalize(newright);
+			VectorNormalize(newup);
+			// make deformed versions of only the model vertices used by the specified surfaces
+			for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+			{
+				const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+				const float *v1, *v2;
+				vec3_t start, end;
+				float f, l;
+				struct
+				{
+					float length2;
+					const float *v1;
+					const float *v2;
+				}
+				shortest[2];
+				memset(shortest, 0, sizeof(shortest));
+				// a single autosprite surface can contain multiple sprites...
+				for (j = 0;j < surface->num_vertices - 3;j += 4)
+				{
+					VectorClear(center);
+					for (i = 0;i < 4;i++)
+						VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
+					VectorScale(center, 0.25f, center);
+					// find the two shortest edges, then use them to define the
+					// axis vectors for rotating around the central axis
+					for (i = 0;i < 6;i++)
+					{
+						v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
+						v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
+#if 0
+						Debug_PolygonBegin(NULL, 0, false, 0);
+						Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
+						Debug_PolygonVertex((v1[0] + v2[0]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, (v1[1] + v2[1]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1], (v1[2] + v2[2]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2], 0, 0, 1, 1, 0, 1);
+						Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
+						Debug_PolygonEnd();
+#endif
+						l = VectorDistance2(v1, v2);
+						// this length bias tries to make sense of square polygons, assuming they are meant to be upright
+						if (v1[2] != v2[2])
+							l += (1.0f / 1024.0f);
+						if (shortest[0].length2 > l || i == 0)
+						{
+							shortest[1] = shortest[0];
+							shortest[0].length2 = l;
+							shortest[0].v1 = v1;
+							shortest[0].v2 = v2;
+						}
+						else if (shortest[1].length2 > l || i == 1)
+						{
+							shortest[1].length2 = l;
+							shortest[1].v1 = v1;
+							shortest[1].v2 = v2;
+						}
+					}
+					VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
+					VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
+#if 0
+					Debug_PolygonBegin(NULL, 0, false, 0);
+					Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
+					Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 4, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 4, 0, 0, 0, 1, 0, 1);
+					Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
+					Debug_PolygonEnd();
+#endif
+					// this calculates the right vector from the shortest edge
+					// and the up vector from the edge midpoints
+					VectorSubtract(shortest[0].v1, shortest[0].v2, right);
+					VectorNormalize(right);
+					VectorSubtract(end, start, up);
+					VectorNormalize(up);
+					// calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
+					//VectorSubtract(rsurface.modelorg, center, forward);
+					Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, forward);
+					VectorNegate(forward, forward);
+					VectorReflect(forward, 0, up, forward);
 					VectorNormalize(forward);
-					right[0] = forward[1];
-					right[1] = -forward[0];
-					right[2] = 0;
-					VectorSet(up, 0, 0, 1);
+					CrossProduct(up, forward, newright);
+					VectorNormalize(newright);
+#if 0
+					Debug_PolygonBegin(NULL, 0, false, 0);
+					Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 8, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 8, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 8, 0, 0, 1, 0, 0, 1);
+					Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
+					Debug_PolygonVertex(center[0] + up   [0] * 8, center[1] + up   [1] * 8, center[2] + up   [2] * 8, 0, 0, 0, 0, 1, 1);
+					Debug_PolygonEnd();
+#endif
+#if 0
+					Debug_PolygonBegin(NULL, 0, false, 0);
+					Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
+					Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
+					Debug_PolygonVertex(center[0] + up      [0] * 8, center[1] + up      [1] * 8, center[2] + up      [2] * 8, 0, 0, 0, 0, 1, 1);
+					Debug_PolygonEnd();
+#endif
+					// rotate the quad around the up axis vector, this is made
+					// especially easy by the fact we know the quad is flat,
+					// so we only have to subtract the center position and
+					// measure distance along the right vector, and then
+					// multiply that by the newright vector and add back the
+					// center position
+					// we also need to subtract the old position to undo the
+					// displacement from the center, which we do with a
+					// DotProduct, the subtraction/addition of center is also
+					// optimized into DotProducts here
+					l = DotProduct(right, center);
+					for (i = 0;i < 4;i++)
+					{
+						v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
+						f = DotProduct(right, v1) - l;
+						VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
+					}
 				}
-				// FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
-				Matrix4x4_FromVectors(&matrix1, (rsurface_modelnormal3f + 3 * surface->num_firstvertex) + j*3, (rsurface_modelsvector3f + 3 * surface->num_firstvertex) + j*3, (rsurface_modeltvector3f + 3 * surface->num_firstvertex) + j*3, center);
-				Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
-				for (i = 0;i < 4;i++)
-					Matrix4x4_Transform(&imatrix1, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
-				for (i = 0;i < 4;i++)
-					VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, rsurface_array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
+				Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer);
+				Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
 			}
-			Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_element3i + surface->num_firsttriangle * 3, rsurface_array_deformednormal3f, r_smoothnormals_areaweighting.integer);
-			Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_array_deformednormal3f, rsurface_model->surfmesh.data_element3i + surface->num_firsttriangle * 3, rsurface_array_deformedsvector3f, rsurface_array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
+			rsurface.vertex3f = rsurface.array_deformedvertex3f;
+			rsurface.vertex3f_bufferobject = 0;
+			rsurface.vertex3f_bufferoffset = 0;
+			rsurface.svector3f = rsurface.array_deformedsvector3f;
+			rsurface.svector3f_bufferobject = 0;
+			rsurface.svector3f_bufferoffset = 0;
+			rsurface.tvector3f = rsurface.array_deformedtvector3f;
+			rsurface.tvector3f_bufferobject = 0;
+			rsurface.tvector3f_bufferoffset = 0;
+			rsurface.normal3f = rsurface.array_deformednormal3f;
+			rsurface.normal3f_bufferobject = 0;
+			rsurface.normal3f_bufferoffset = 0;
+			break;
+		case Q3DEFORM_NORMAL:
+			// deform the normals to make reflections wavey
+			for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+			{
+				const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+				for (j = 0;j < surface->num_vertices;j++)
+				{
+					float vertex[3];
+					float *normal = (rsurface.array_deformednormal3f  + 3 * surface->num_firstvertex) + j*3;
+					VectorScale((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
+					VectorCopy((rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, normal);
+					normal[0] += deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
+					normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
+					normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
+					VectorNormalize(normal);
+				}
+				Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
+			}
+			rsurface.svector3f = rsurface.array_deformedsvector3f;
+			rsurface.svector3f_bufferobject = 0;
+			rsurface.svector3f_bufferoffset = 0;
+			rsurface.tvector3f = rsurface.array_deformedtvector3f;
+			rsurface.tvector3f_bufferobject = 0;
+			rsurface.tvector3f_bufferoffset = 0;
+			rsurface.normal3f = rsurface.array_deformednormal3f;
+			rsurface.normal3f_bufferobject = 0;
+			rsurface.normal3f_bufferoffset = 0;
+			break;
+		case Q3DEFORM_WAVE:
+			// deform vertex array to make wavey water and flags and such
+			waveparms[0] = deform->waveparms[0];
+			waveparms[1] = deform->waveparms[1];
+			waveparms[2] = deform->waveparms[2];
+			waveparms[3] = deform->waveparms[3];
+			// this is how a divisor of vertex influence on deformation
+			animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
+			scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
+			for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+			{
+				const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+				for (j = 0;j < surface->num_vertices;j++)
+				{
+					float *vertex = (rsurface.array_deformedvertex3f  + 3 * surface->num_firstvertex) + j*3;
+					VectorCopy((rsurface.vertex3f  + 3 * surface->num_firstvertex) + j*3, vertex);
+					// if the wavefunc depends on time, evaluate it per-vertex
+					if (waveparms[3])
+					{
+						waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
+						scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
+					}
+					VectorMA(vertex, scale, (rsurface.normal3f  + 3 * surface->num_firstvertex) + j*3, vertex);
+				}
+			}
+			rsurface.vertex3f = rsurface.array_deformedvertex3f;
+			rsurface.vertex3f_bufferobject = 0;
+			rsurface.vertex3f_bufferoffset = 0;
+			break;
+		case Q3DEFORM_BULGE:
+			// deform vertex array to make the surface have moving bulges
+			for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+			{
+				const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+				for (j = 0;j < surface->num_vertices;j++)
+				{
+					scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.time * deform->parms[2])) * deform->parms[1];
+					VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
+				}
+			}
+			rsurface.vertex3f = rsurface.array_deformedvertex3f;
+			rsurface.vertex3f_bufferobject = 0;
+			rsurface.vertex3f_bufferoffset = 0;
+			break;
+		case Q3DEFORM_MOVE:
+			// deform vertex array
+			scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
+			VectorScale(deform->parms, scale, waveparms);
+			for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+			{
+				const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+				for (j = 0;j < surface->num_vertices;j++)
+					VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
+			}
+			rsurface.vertex3f = rsurface.array_deformedvertex3f;
+			rsurface.vertex3f_bufferobject = 0;
+			rsurface.vertex3f_bufferoffset = 0;
+			break;
 		}
-		rsurface_vertex3f = rsurface_array_deformedvertex3f;
-		rsurface_vertex3f_bufferobject = 0;
-		rsurface_vertex3f_bufferoffset = 0;
-		rsurface_svector3f = rsurface_array_deformedsvector3f;
-		rsurface_svector3f_bufferobject = 0;
-		rsurface_svector3f_bufferoffset = 0;
-		rsurface_tvector3f = rsurface_array_deformedtvector3f;
-		rsurface_tvector3f_bufferobject = 0;
-		rsurface_tvector3f_bufferoffset = 0;
-		rsurface_normal3f = rsurface_array_deformednormal3f;
-		rsurface_normal3f_bufferobject = 0;
-		rsurface_normal3f_bufferoffset = 0;
 	}
-	else
-	{
-		rsurface_vertex3f  = rsurface_modelvertex3f;
-		rsurface_vertex3f_bufferobject = rsurface_modelvertex3f_bufferobject;
-		rsurface_vertex3f_bufferoffset = rsurface_modelvertex3f_bufferoffset;
-		rsurface_svector3f = rsurface_modelsvector3f;
-		rsurface_svector3f_bufferobject = rsurface_modelsvector3f_bufferobject;
-		rsurface_svector3f_bufferoffset = rsurface_modelsvector3f_bufferoffset;
-		rsurface_tvector3f = rsurface_modeltvector3f;
-		rsurface_tvector3f_bufferobject = rsurface_modeltvector3f_bufferobject;
-		rsurface_tvector3f_bufferoffset = rsurface_modeltvector3f_bufferoffset;
-		rsurface_normal3f  = rsurface_modelnormal3f;
-		rsurface_normal3f_bufferobject = rsurface_modelnormal3f_bufferobject;
-		rsurface_normal3f_bufferoffset = rsurface_modelnormal3f_bufferoffset;
-	}
-	R_Mesh_VertexPointer(rsurface_vertex3f, rsurface_vertex3f_bufferobject, rsurface_vertex3f_bufferoffset);
+	// generate texcoords based on the chosen texcoord source
+	switch(rsurface.texture->tcgen.tcgen)
+	{
+	default:
+	case Q3TCGEN_TEXTURE:
+		rsurface.texcoordtexture2f               = rsurface.modeltexcoordtexture2f;
+		rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordtexture2f_bufferobject;
+		rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
+		break;
+	case Q3TCGEN_LIGHTMAP:
+		rsurface.texcoordtexture2f               = rsurface.modeltexcoordlightmap2f;
+		rsurface.texcoordtexture2f_bufferobject  = rsurface.modeltexcoordlightmap2f_bufferobject;
+		rsurface.texcoordtexture2f_bufferoffset  = rsurface.modeltexcoordlightmap2f_bufferoffset;
+		break;
+	case Q3TCGEN_VECTOR:
+		for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+		{
+			const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+			for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, out_tc += 2)
+			{
+				out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
+				out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
+			}
+		}
+		rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
+		rsurface.texcoordtexture2f_bufferobject  = 0;
+		rsurface.texcoordtexture2f_bufferoffset  = 0;
+		break;
+	case Q3TCGEN_ENVIRONMENT:
+		// make environment reflections using a spheremap
+		for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+		{
+			const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+			const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
+			const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
+			float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
+			for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
+			{
+				float l, d, eyedir[3];
+				VectorSubtract(rsurface.modelorg, vertex, eyedir);
+				l = 0.5f / VectorLength(eyedir);
+				d = DotProduct(normal, eyedir)*2;
+				out_tc[0] = 0.5f + (normal[1]*d - eyedir[1])*l;
+				out_tc[1] = 0.5f - (normal[2]*d - eyedir[2])*l;
+			}
+		}
+		rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
+		rsurface.texcoordtexture2f_bufferobject  = 0;
+		rsurface.texcoordtexture2f_bufferoffset  = 0;
+		break;
+	}
+	// the only tcmod that needs software vertex processing is turbulent, so
+	// check for it here and apply the changes if needed
+	// and we only support that as the first one
+	// (handling a mixture of turbulent and other tcmods would be problematic
+	//  without punting it entirely to a software path)
+	if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
+	{
+		amplitude = rsurface.texture->tcmods[0].parms[1];
+		animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.time * rsurface.texture->tcmods[0].parms[3];
+		for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+		{
+			const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+			for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, in_tc = rsurface.texcoordtexture2f + 2 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, in_tc += 2, out_tc += 2)
+			{
+				out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
+				out_tc[1] = in_tc[1] + amplitude * sin(((v1[1]        ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
+			}
+		}
+		rsurface.texcoordtexture2f               = rsurface.array_generatedtexcoordtexture2f;
+		rsurface.texcoordtexture2f_bufferobject  = 0;
+		rsurface.texcoordtexture2f_bufferoffset  = 0;
+	}
+	rsurface.texcoordlightmap2f              = rsurface.modeltexcoordlightmap2f;
+	rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
+	rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
+	R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
 }
 
 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
@@ -3628,7 +4537,7 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel
 	if (texturenumsurfaces == 1)
 	{
 		GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
-		R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+		R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 	}
 	else if (r_batchmode.integer == 2)
 	{
@@ -3641,10 +4550,10 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel
 			j = i + 1;
 			if (surface->num_triangles > MAXBATCHTRIANGLES)
 			{
-				R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+				R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 				continue;
 			}
-			memcpy(batchelements, rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
+			memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
 			batchtriangles = surface->num_triangles;
 			firstvertex = surface->num_firstvertex;
 			endvertex = surface->num_firstvertex + surface->num_vertices;
@@ -3653,7 +4562,7 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel
 				surface2 = texturesurfacelist[j];
 				if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
 					break;
-				memcpy(batchelements + batchtriangles * 3, rsurface_model->surfmesh.data_element3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
+				memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
 				batchtriangles += surface2->num_triangles;
 				firstvertex = min(firstvertex, surface2->num_firstvertex);
 				endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
@@ -3675,7 +4584,7 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel
 			numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
 			numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
 			GL_LockArrays(surface->num_firstvertex, numvertices);
-			R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+			R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 		}
 	}
 	else
@@ -3684,8 +4593,61 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel
 		{
 			surface = texturesurfacelist[i];
 			GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
-			R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+			R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
+		}
+	}
+}
+
+static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit, int refractiontexunit, int reflectiontexunit)
+{
+	int i, planeindex, vertexindex;
+	float d, bestd;
+	vec3_t vert;
+	const float *v;
+	r_waterstate_waterplane_t *p, *bestp;
+	msurface_t *surface;
+	if (r_waterstate.renderingscene)
+		return;
+	for (i = 0;i < texturenumsurfaces;i++)
+	{
+		surface = texturesurfacelist[i];
+		if (lightmaptexunit >= 0)
+			R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
+		if (deluxemaptexunit >= 0)
+			R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
+		// pick the closest matching water plane
+		bestd = 0;
+		bestp = NULL;
+		for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
+		{
+			d = 0;
+			for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
+			{
+				Matrix4x4_Transform(&rsurface.matrix, v, vert);
+				d += fabs(PlaneDiff(vert, &p->plane));
+			}
+			if (bestd > d || !bestp)
+			{
+				bestd = d;
+				bestp = p;
+			}
+		}
+		if (bestp)
+		{
+			if (refractiontexunit >= 0)
+				R_Mesh_TexBind(refractiontexunit, R_GetTexture(bestp->texture_refraction));
+			if (reflectiontexunit >= 0)
+				R_Mesh_TexBind(reflectiontexunit, R_GetTexture(bestp->texture_reflection));
+		}
+		else
+		{
+			if (refractiontexunit >= 0)
+				R_Mesh_TexBind(refractiontexunit, R_GetTexture(r_texture_black));
+			if (reflectiontexunit >= 0)
+				R_Mesh_TexBind(reflectiontexunit, R_GetTexture(r_texture_black));
 		}
+		GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
+		R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 	}
 }
 
@@ -3706,7 +4668,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa
 		if (deluxemaptexunit >= 0)
 			R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
 		GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
-		R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+		R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 	}
 	else if (r_batchmode.integer == 2)
 	{
@@ -3722,10 +4684,10 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa
 			j = i + 1;
 			if (surface->num_triangles > MAXBATCHTRIANGLES)
 			{
-				R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+				R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 				continue;
 			}
-			memcpy(batchelements, rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
+			memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
 			batchtriangles = surface->num_triangles;
 			firstvertex = surface->num_firstvertex;
 			endvertex = surface->num_firstvertex + surface->num_vertices;
@@ -3734,7 +4696,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa
 				surface2 = texturesurfacelist[j];
 				if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
 					break;
-				memcpy(batchelements + batchtriangles * 3, rsurface_model->surfmesh.data_element3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
+				memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
 				batchtriangles += surface2->num_triangles;
 				firstvertex = min(firstvertex, surface2->num_firstvertex);
 				endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
@@ -3747,7 +4709,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa
 	else if (r_batchmode.integer == 1)
 	{
 #if 0
-		Con_Printf("%s batch sizes ignoring lightmap:", rsurface_texture->name);
+		Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
 		for (i = 0;i < texturenumsurfaces;i = j)
 		{
 			surface = texturesurfacelist[i];
@@ -3757,7 +4719,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa
 			Con_Printf(" %i", j - i);
 		}
 		Con_Printf("\n");
-		Con_Printf("%s batch sizes honoring lightmap:", rsurface_texture->name);
+		Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
 #endif
 		for (i = 0;i < texturenumsurfaces;i = j)
 		{
@@ -3775,7 +4737,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa
 			numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
 			numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
 			GL_LockArrays(surface->num_firstvertex, numvertices);
-			R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+			R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 		}
 #if 0
 		Con_Printf("\n");
@@ -3790,7 +4752,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa
 			if (deluxemaptexunit >= 0)
 				R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
 			GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
-			R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+			R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 		}
 	}
 }
@@ -3808,7 +4770,7 @@ static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **te
 			{
 				float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_view.colorscale;
 				GL_Color(f, f, f, 1);
-				R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, 1, (rsurface_model->surfmesh.data_element3i + 3 * (j + surface->num_firsttriangle)), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * (j + surface->num_firsttriangle)));
+				R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, 1, (rsurface.modelelement3i + 3 * (j + surface->num_firsttriangle)), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * (j + surface->num_firsttriangle)));
 			}
 		}
 	}
@@ -3820,7 +4782,7 @@ static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **te
 			int k = (int)(((size_t)surface) / sizeof(msurface_t));
 			GL_Color((k & 15) * (1.0f / 16.0f) * r_view.colorscale, ((k >> 4) & 15) * (1.0f / 16.0f) * r_view.colorscale, ((k >> 8) & 15) * (1.0f / 16.0f) * r_view.colorscale, 1);
 			GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
-			R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+			R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
 		}
 	}
 }
@@ -3831,13 +4793,13 @@ static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **t
 	int i;
 	float f;
 	float *v, *c, *c2;
-	if (rsurface_lightmapcolor4f)
+	if (rsurface.lightmapcolor4f)
 	{
 		// generate color arrays for the surfaces in this list
 		for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
 		{
 			const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
-			for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
+			for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
 			{
 				f = FogPoint_Model(v);
 				c2[0] = c[0] * f;
@@ -3852,7 +4814,7 @@ static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **t
 		for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
 		{
 			const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
-			for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
+			for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
 			{
 				f = FogPoint_Model(v);
 				c2[0] = f;
@@ -3862,9 +4824,9 @@ static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **t
 			}
 		}
 	}
-	rsurface_lightmapcolor4f = rsurface_array_color4f;
-	rsurface_lightmapcolor4f_bufferobject = 0;
-	rsurface_lightmapcolor4f_bufferoffset = 0;
+	rsurface.lightmapcolor4f = rsurface.array_color4f;
+	rsurface.lightmapcolor4f_bufferobject = 0;
+	rsurface.lightmapcolor4f_bufferoffset = 0;
 }
 
 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a)
@@ -3872,12 +4834,12 @@ static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t *
 	int texturesurfaceindex;
 	int i;
 	float *c, *c2;
-	if (!rsurface_lightmapcolor4f)
+	if (!rsurface.lightmapcolor4f)
 		return;
 	for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
 	{
 		const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
-		for (i = 0, c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
+		for (i = 0, c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
 		{
 			c2[0] = c[0] * r;
 			c2[1] = c[1] * g;
@@ -3885,20 +4847,20 @@ static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t *
 			c2[3] = c[3] * a;
 		}
 	}
-	rsurface_lightmapcolor4f = rsurface_array_color4f;
-	rsurface_lightmapcolor4f_bufferobject = 0;
-	rsurface_lightmapcolor4f_bufferoffset = 0;
+	rsurface.lightmapcolor4f = rsurface.array_color4f;
+	rsurface.lightmapcolor4f_bufferobject = 0;
+	rsurface.lightmapcolor4f_bufferoffset = 0;
 }
 
 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
 {
 	// TODO: optimize
-	rsurface_lightmapcolor4f = NULL;
-	rsurface_lightmapcolor4f_bufferobject = 0;
-	rsurface_lightmapcolor4f_bufferoffset = 0;
+	rsurface.lightmapcolor4f = NULL;
+	rsurface.lightmapcolor4f_bufferobject = 0;
+	rsurface.lightmapcolor4f_bufferoffset = 0;
 	if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
 	if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
-	R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset);
+	R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
 	GL_Color(r, g, b, a);
 	RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 0, -1);
 }
@@ -3907,12 +4869,12 @@ static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, msurface_t **text
 {
 	// TODO: optimize applyfog && applycolor case
 	// just apply fog if necessary, and tint the fog color array if necessary
-	rsurface_lightmapcolor4f = NULL;
-	rsurface_lightmapcolor4f_bufferobject = 0;
-	rsurface_lightmapcolor4f_bufferoffset = 0;
+	rsurface.lightmapcolor4f = NULL;
+	rsurface.lightmapcolor4f_bufferobject = 0;
+	rsurface.lightmapcolor4f_bufferoffset = 0;
 	if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
 	if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
-	R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset);
+	R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
 	GL_Color(r, g, b, a);
 	RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
 }
@@ -3929,11 +4891,11 @@ static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t
 		for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
 		{
 			const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
-			for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
+			for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
 			{
 				if (surface->lightmapinfo->samples)
 				{
-					const unsigned char *lm = surface->lightmapinfo->samples + (rsurface_model->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i];
+					const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
 					float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
 					VectorScale(lm, scale, c);
 					if (surface->lightmapinfo->styles[1] != 255)
@@ -3961,19 +4923,19 @@ static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t
 				c[3] = 1;
 			}
 		}
-		rsurface_lightmapcolor4f = rsurface_array_color4f;
-		rsurface_lightmapcolor4f_bufferobject = 0;
-		rsurface_lightmapcolor4f_bufferoffset = 0;
+		rsurface.lightmapcolor4f = rsurface.array_color4f;
+		rsurface.lightmapcolor4f_bufferobject = 0;
+		rsurface.lightmapcolor4f_bufferoffset = 0;
 	}
 	else
 	{
-		rsurface_lightmapcolor4f = rsurface_model->surfmesh.data_lightmapcolor4f;
-		rsurface_lightmapcolor4f_bufferobject = rsurface_model->surfmesh.vbo;
-		rsurface_lightmapcolor4f_bufferoffset = rsurface_model->surfmesh.vbooffset_lightmapcolor4f;
+		rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
+		rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
+		rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
 	}
 	if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
 	if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
-	R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset);
+	R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
 	GL_Color(r, g, b, a);
 	RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
 }
@@ -3989,13 +4951,13 @@ static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t
 	vec3_t lightdir;
 	// TODO: optimize
 	// model lighting
-	VectorCopy(rsurface_entity->modellight_lightdir, lightdir);
-	ambientcolor[0] = rsurface_entity->modellight_ambient[0] * r * 0.5f;
-	ambientcolor[1] = rsurface_entity->modellight_ambient[1] * g * 0.5f;
-	ambientcolor[2] = rsurface_entity->modellight_ambient[2] * b * 0.5f;
-	diffusecolor[0] = rsurface_entity->modellight_diffuse[0] * r * 0.5f;
-	diffusecolor[1] = rsurface_entity->modellight_diffuse[1] * g * 0.5f;
-	diffusecolor[2] = rsurface_entity->modellight_diffuse[2] * b * 0.5f;
+	VectorCopy(rsurface.modellight_lightdir, lightdir);
+	ambientcolor[0] = rsurface.modellight_ambient[0] * r * 0.5f;
+	ambientcolor[1] = rsurface.modellight_ambient[1] * g * 0.5f;
+	ambientcolor[2] = rsurface.modellight_ambient[2] * b * 0.5f;
+	diffusecolor[0] = rsurface.modellight_diffuse[0] * r * 0.5f;
+	diffusecolor[1] = rsurface.modellight_diffuse[1] * g * 0.5f;
+	diffusecolor[2] = rsurface.modellight_diffuse[2] * b * 0.5f;
 	if (VectorLength2(diffusecolor) > 0)
 	{
 		// generate color arrays for the surfaces in this list
@@ -4003,9 +4965,9 @@ static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t
 		{
 			const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
 			int numverts = surface->num_vertices;
-			v = rsurface_vertex3f + 3 * surface->num_firstvertex;
-			c2 = rsurface_normal3f + 3 * surface->num_firstvertex;
-			c = rsurface_array_color4f + 4 * surface->num_firstvertex;
+			v = rsurface.vertex3f + 3 * surface->num_firstvertex;
+			c2 = rsurface.normal3f + 3 * surface->num_firstvertex;
+			c = rsurface.array_color4f + 4 * surface->num_firstvertex;
 			// q3-style directional shading
 			for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
 			{
@@ -4021,34 +4983,35 @@ static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t
 		b = 1;
 		a = 1;
 		applycolor = false;
-		rsurface_lightmapcolor4f = rsurface_array_color4f;
-		rsurface_lightmapcolor4f_bufferobject = 0;
-		rsurface_lightmapcolor4f_bufferoffset = 0;
+		rsurface.lightmapcolor4f = rsurface.array_color4f;
+		rsurface.lightmapcolor4f_bufferobject = 0;
+		rsurface.lightmapcolor4f_bufferoffset = 0;
 	}
 	else
 	{
 		r = ambientcolor[0];
 		g = ambientcolor[1];
 		b = ambientcolor[2];
-		rsurface_lightmapcolor4f = NULL;
-		rsurface_lightmapcolor4f_bufferobject = 0;
-		rsurface_lightmapcolor4f_bufferoffset = 0;
+		rsurface.lightmapcolor4f = NULL;
+		rsurface.lightmapcolor4f_bufferobject = 0;
+		rsurface.lightmapcolor4f_bufferoffset = 0;
 	}
 	if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
 	if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
-	R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset);
+	R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
 	GL_Color(r, g, b, a);
 	RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
 }
 
 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
 {
-	GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
-	GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
-	GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
-	if (rsurface_mode != RSURFMODE_SHOWSURFACES)
+	GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+	GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
+	GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
+	GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
+	if (rsurface.mode != RSURFMODE_SHOWSURFACES)
 	{
-		rsurface_mode = RSURFMODE_SHOWSURFACES;
+		rsurface.mode = RSURFMODE_SHOWSURFACES;
 		GL_DepthMask(true);
 		GL_BlendFunc(GL_ONE, GL_ZERO);
 		R_Mesh_ColorPointer(NULL, 0, 0);
@@ -4061,26 +5024,27 @@ static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurfa
 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
 {
 	// transparent sky would be ridiculous
-	if ((rsurface_texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
+	if ((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
 		return;
-	if (rsurface_mode != RSURFMODE_SKY)
+	if (rsurface.mode != RSURFMODE_SKY)
 	{
-		if (rsurface_mode == RSURFMODE_GLSL)
+		if (rsurface.mode == RSURFMODE_GLSL)
 		{
 			qglUseProgramObjectARB(0);CHECKGLERROR
 		}
-		rsurface_mode = RSURFMODE_SKY;
+		rsurface.mode = RSURFMODE_SKY;
 	}
 	if (skyrendernow)
 	{
 		skyrendernow = false;
 		R_Sky();
 		// restore entity matrix
-		R_Mesh_Matrix(&rsurface_entity->matrix);
+		R_Mesh_Matrix(&rsurface.matrix);
 	}
-	GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
-	GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
-	GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+	GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+	GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
+	GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
+	GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
 	GL_DepthMask(true);
 	// LordHavoc: HalfLife maps have freaky skypolys so don't use
 	// skymasking on them, and Quake3 never did sky masking (unlike
@@ -4088,7 +5052,7 @@ static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **te
 	// in Quake3 maps as it causes problems with q3map2 sky tricks,
 	// and skymasking also looks very bad when noclipping outside the
 	// level, so don't use it then either.
-	if (rsurface_model->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
+	if (r_refdef.worldmodel && r_refdef.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
 	{
 		GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1);
 		R_Mesh_ColorPointer(NULL, 0, 0);
@@ -4115,34 +5079,35 @@ static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **te
 
 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
 {
-	if (rsurface_mode != RSURFMODE_GLSL)
+	if (rsurface.mode != RSURFMODE_GLSL)
 	{
-		rsurface_mode = RSURFMODE_GLSL;
+		rsurface.mode = RSURFMODE_GLSL;
 		R_Mesh_ResetTextureState();
 	}
 
-	R_SetupSurfaceShader(vec3_origin, rsurface_lightmode == 2, 1, 1, rsurface_texture->specularscale);
+	R_SetupSurfaceShader(vec3_origin, rsurface.lightmode == 2, 1, 1, rsurface.texture->specularscale);
 	if (!r_glsl_permutation)
 		return;
 
-	if (rsurface_lightmode == 2)
+	if (rsurface.lightmode == 2)
 		RSurf_PrepareVerticesForBatch(true, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
 	else
 		RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
-	R_Mesh_TexCoordPointer(0, 2, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_model->surfmesh.vbo, rsurface_model->surfmesh.vbooffset_texcoordtexture2f);
-	R_Mesh_TexCoordPointer(1, 3, rsurface_svector3f, rsurface_svector3f_bufferobject, rsurface_svector3f_bufferoffset);
-	R_Mesh_TexCoordPointer(2, 3, rsurface_tvector3f, rsurface_tvector3f_bufferobject, rsurface_tvector3f_bufferoffset);
-	R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f, rsurface_normal3f_bufferobject, rsurface_normal3f_bufferoffset);
-	R_Mesh_TexCoordPointer(4, 2, rsurface_model->surfmesh.data_texcoordlightmap2f, rsurface_model->surfmesh.vbo, rsurface_model->surfmesh.vbooffset_texcoordlightmap2f);
+	R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
+	R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
+	R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
+	R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
+	R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
 
-	if (rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
+	GL_Color(rsurface.texture->currentlayers[0].color[0], rsurface.texture->currentlayers[0].color[1], rsurface.texture->currentlayers[0].color[2], rsurface.texture->currentlayers[0].color[3]);
+	if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
 	{
-		R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
+		R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
 		if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
 			R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
 		R_Mesh_ColorPointer(NULL, 0, 0);
 	}
-	else if (rsurface_uselightmaptexture)
+	else if (rsurface.uselightmaptexture)
 	{
 		R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
 		if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
@@ -4154,14 +5119,24 @@ static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **t
 		R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
 		if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
 			R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
-		R_Mesh_ColorPointer(rsurface_model->surfmesh.data_lightmapcolor4f, rsurface_model->surfmesh.vbo, rsurface_model->surfmesh.vbooffset_lightmapcolor4f);
+		R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
 	}
 
-	if (rsurface_uselightmaptexture && !(rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
-		RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1);
+	if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
+	{
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+			RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? 12 : -1);
+		else
+			RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1);
+	}
 	else
-		RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
-	if (rsurface_texture->backgroundnumskinframes && !(rsurface_texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
+	{
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+			RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? 12 : -1);
+		else
+			RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+	}
+	if (rsurface.texture->backgroundnumskinframes && !(rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
 	{
 	}
 }
@@ -4175,14 +5150,14 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t
 	rmeshstate_t m;
 	int layerindex;
 	const texturelayer_t *layer;
-	if (rsurface_mode != RSURFMODE_MULTIPASS)
-		rsurface_mode = RSURFMODE_MULTIPASS;
+	if (rsurface.mode != RSURFMODE_MULTIPASS)
+		rsurface.mode = RSURFMODE_MULTIPASS;
 	RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
-	for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
+	for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
 	{
 		vec4_t layercolor;
 		int layertexrgbscale;
-		if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
 		{
 			if (layerindex == 0)
 				GL_AlphaTest(true);
@@ -4218,19 +5193,19 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t
 		case TEXTURELAYERTYPE_LITTEXTURE:
 			memset(&m, 0, sizeof(m));
 			m.tex[0] = R_GetTexture(r_texture_white);
-			m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f;
-			m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-			m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordlightmap2f;
+			m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
+			m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
+			m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
 			m.tex[1] = R_GetTexture(layer->texture);
 			m.texmatrix[1] = layer->texmatrix;
 			m.texrgbscale[1] = layertexrgbscale;
-			m.pointer_texcoord[1] = rsurface_model->surfmesh.data_texcoordtexture2f;
-			m.pointer_texcoord_bufferobject[1] = rsurface_model->surfmesh.vbo;
-			m.pointer_texcoord_bufferoffset[1] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f;
+			m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
+			m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
+			m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
 			R_Mesh_TextureState(&m);
-			if (rsurface_lightmode == 2)
+			if (rsurface.lightmode == 2)
 				RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
-			else if (rsurface_uselightmaptexture)
+			else if (rsurface.uselightmaptexture)
 				RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
 			else
 				RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
@@ -4240,9 +5215,9 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t
 			m.tex[0] = R_GetTexture(layer->texture);
 			m.texmatrix[0] = layer->texmatrix;
 			m.texrgbscale[0] = layertexrgbscale;
-			m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
-			m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-			m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f;
+			m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
+			m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
+			m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
 			R_Mesh_TextureState(&m);
 			RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
 			break;
@@ -4253,19 +5228,19 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t
 			{
 				m.tex[0] = R_GetTexture(layer->texture);
 				m.texmatrix[0] = layer->texmatrix;
-				m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
-				m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-				m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f;
+				m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
+				m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
+				m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
 			}
 			R_Mesh_TextureState(&m);
 			// generate a color array for the fog pass
-			R_Mesh_ColorPointer(rsurface_array_color4f, 0, 0);
+			R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
 			for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
 			{
 				int i;
 				float f, *v, *c;
 				const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
-				for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
+				for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
 				{
 					f = 1 - FogPoint_Model(v);
 					c[0] = layercolor[0];
@@ -4282,7 +5257,7 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t
 		GL_LockArrays(0, 0);
 	}
 	CHECKGLERROR
-	if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+	if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
 	{
 		qglDepthFunc(GL_LEQUAL);CHECKGLERROR
 		GL_AlphaTest(false);
@@ -4297,12 +5272,12 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t
 	rmeshstate_t m;
 	int layerindex;
 	const texturelayer_t *layer;
-	if (rsurface_mode != RSURFMODE_MULTIPASS)
-		rsurface_mode = RSURFMODE_MULTIPASS;
+	if (rsurface.mode != RSURFMODE_MULTIPASS)
+		rsurface.mode = RSURFMODE_MULTIPASS;
 	RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
-	for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
+	for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
 	{
-		if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
 		{
 			if (layerindex == 0)
 				GL_AlphaTest(true);
@@ -4325,13 +5300,13 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t
 				// first the lightmap pass
 				memset(&m, 0, sizeof(m));
 				m.tex[0] = R_GetTexture(r_texture_white);
-				m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f;
-				m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-				m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordlightmap2f;
+				m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
+				m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
+				m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
 				R_Mesh_TextureState(&m);
-				if (rsurface_lightmode == 2)
+				if (rsurface.lightmode == 2)
 					RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
-				else if (rsurface_uselightmaptexture)
+				else if (rsurface.uselightmaptexture)
 					RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
 				else
 					RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
@@ -4341,9 +5316,9 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t
 				memset(&m, 0, sizeof(m));
 				m.tex[0] = R_GetTexture(layer->texture);
 				m.texmatrix[0] = layer->texmatrix;
-				m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
-				m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-				m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f;
+				m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
+				m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
+				m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
 				R_Mesh_TextureState(&m);
 				RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0] * 0.5f, layer->color[1] * 0.5f, layer->color[2] * 0.5f, layer->color[3], layer->color[0] != 2 || layer->color[1] != 2 || layer->color[2] != 2 || layer->color[3] != 1, false);
 			}
@@ -4353,11 +5328,11 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t
 				memset(&m, 0, sizeof(m));
 				m.tex[0] = R_GetTexture(layer->texture);
 				m.texmatrix[0] = layer->texmatrix;
-				m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
-				m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-				m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f;
+				m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
+				m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
+				m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
 				R_Mesh_TextureState(&m);
-				if (rsurface_lightmode == 2)
+				if (rsurface.lightmode == 2)
 					RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
 				else
 					RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
@@ -4368,23 +5343,23 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t
 			memset(&m, 0, sizeof(m));
 			m.tex[0] = R_GetTexture(layer->texture);
 			m.texmatrix[0] = layer->texmatrix;
-			m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
-			m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-			m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f;
+			m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
+			m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
+			m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
 			R_Mesh_TextureState(&m);
 			RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
 			break;
 		case TEXTURELAYERTYPE_FOG:
 			// singletexture fogging
-			R_Mesh_ColorPointer(rsurface_array_color4f, 0, 0);
+			R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
 			if (layer->texture)
 			{
 				memset(&m, 0, sizeof(m));
 				m.tex[0] = R_GetTexture(layer->texture);
 				m.texmatrix[0] = layer->texmatrix;
-				m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
-				m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-				m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f;
+				m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
+				m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
+				m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
 				R_Mesh_TextureState(&m);
 			}
 			else
@@ -4395,7 +5370,7 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t
 				int i;
 				float f, *v, *c;
 				const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
-				for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
+				for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
 				{
 					f = 1 - FogPoint_Model(v);
 					c[0] = layer->color[0];
@@ -4412,7 +5387,7 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t
 		GL_LockArrays(0, 0);
 	}
 	CHECKGLERROR
-	if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+	if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
 	{
 		qglDepthFunc(GL_LEQUAL);CHECKGLERROR
 		GL_AlphaTest(false);
@@ -4421,28 +5396,34 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t
 
 static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly)
 {
-	if (rsurface_texture->currentmaterialflags & MATERIALFLAG_NODRAW)
+	if (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW)
 		return;
-	r_shadow_rtlight = NULL;
+	rsurface.rtlight = NULL;
 	CHECKGLERROR
 	if (depthonly)
 	{
-		if ((rsurface_texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
+		if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
+			return;
+		if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER))
 			return;
-		if (rsurface_mode != RSURFMODE_MULTIPASS)
-			rsurface_mode = RSURFMODE_MULTIPASS;
+		if (rsurface.mode != RSURFMODE_MULTIPASS)
+			rsurface.mode = RSURFMODE_MULTIPASS;
 		if (r_depthfirst.integer == 3)
 		{
-			int i = (int)(texturesurfacelist[0] - rsurface_model->data_surfaces);
-			GL_Color(((i >> 6) & 7) / 7.0f, ((i >> 3) & 7) / 7.0f, (i & 7) / 7.0f,1);
+			int i = (int)(texturesurfacelist[0] - rsurface.modelsurfaces);
+			if (!r_view.showdebug)
+				GL_Color(0, 0, 0, 1);
+			else
+				GL_Color(((i >> 6) & 7) / 7.0f, ((i >> 3) & 7) / 7.0f, (i & 7) / 7.0f,1);
 		}
 		else
 		{
 			GL_ColorMask(0,0,0,0);
 			GL_Color(1,1,1,1);
 		}
-		GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
-		GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+		GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+		GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
+		GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
 		GL_DepthTest(true);
 		GL_BlendFunc(GL_ONE, GL_ZERO);
 		GL_DepthMask(true);
@@ -4456,13 +5437,19 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur
 	}
 	else if (r_depthfirst.integer == 3)
 		return;
+	else if (!r_view.showdebug && (r_showsurfaces.integer || gl_lightmaps.integer))
+	{
+		GL_Color(0, 0, 0, 1);
+		RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+	}
 	else if (r_showsurfaces.integer)
 	{
-		if (rsurface_mode != RSURFMODE_MULTIPASS)
-			rsurface_mode = RSURFMODE_MULTIPASS;
-		GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+		if (rsurface.mode != RSURFMODE_MULTIPASS)
+			rsurface.mode = RSURFMODE_MULTIPASS;
+		GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+		GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
 		GL_DepthTest(true);
-		GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+		GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
 		GL_BlendFunc(GL_ONE, GL_ZERO);
 		GL_DepthMask(writedepth);
 		GL_Color(1,1,1,1);
@@ -4476,50 +5463,52 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur
 	else if (gl_lightmaps.integer)
 	{
 		rmeshstate_t m;
-		if (rsurface_mode != RSURFMODE_MULTIPASS)
-			rsurface_mode = RSURFMODE_MULTIPASS;
-		GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+		if (rsurface.mode != RSURFMODE_MULTIPASS)
+			rsurface.mode = RSURFMODE_MULTIPASS;
+		GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
 		GL_DepthTest(true);
-		GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+		GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
 		GL_BlendFunc(GL_ONE, GL_ZERO);
 		GL_DepthMask(writedepth);
 		GL_Color(1,1,1,1);
 		GL_AlphaTest(false);
+		// use lightmode 0 (fullbright or lightmap) or 2 (model lighting)
+		rsurface.lightmode = ((rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || rsurface.modeltexcoordlightmap2f != NULL) ? 0 : 2;
 		R_Mesh_ColorPointer(NULL, 0, 0);
 		memset(&m, 0, sizeof(m));
 		m.tex[0] = R_GetTexture(r_texture_white);
-		m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f;
-		m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
-		m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordlightmap2f;
+		m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
+		m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
+		m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
 		R_Mesh_TextureState(&m);
-		RSurf_PrepareVerticesForBatch(rsurface_lightmode == 2, false, texturenumsurfaces, texturesurfacelist);
-		if (rsurface_lightmode == 2)
+		RSurf_PrepareVerticesForBatch(rsurface.lightmode == 2, false, texturenumsurfaces, texturesurfacelist);
+		if (rsurface.lightmode == 2)
 			RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
-		else if (rsurface_uselightmaptexture)
+		else if (rsurface.uselightmaptexture)
 			RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
 		else
 			RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
 		r_refdef.stats.entities_surfaces += texturenumsurfaces;
 	}
-	else if (rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY)
+	else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
 	{
 		R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
 		r_refdef.stats.entities_surfaces += texturenumsurfaces;
 	}
-	else if (rsurface_texture->currentnumlayers)
+	else if (rsurface.texture->currentnumlayers)
 	{
 		// write depth for anything we skipped on the depth-only pass earlier
-		if (!writedepth && (rsurface_texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
 			writedepth = true;
-		GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
-		GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
-		GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
-		GL_BlendFunc(rsurface_texture->currentlayers[0].blendfunc1, rsurface_texture->currentlayers[0].blendfunc2);
-		GL_DepthMask(writedepth && !(rsurface_texture->currentmaterialflags & MATERIALFLAG_BLENDED));
-		GL_Color(rsurface_entity->colormod[0], rsurface_entity->colormod[1], rsurface_entity->colormod[2], rsurface_texture->currentalpha);
-		GL_AlphaTest((rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
-		// FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
-		rsurface_lightmode = ((rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
+		GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+		GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
+		GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
+		GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
+		GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
+		GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
+		GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
+		// use lightmode 0 (fullbright or lightmap) or 2 (model lighting)
+		rsurface.lightmode = ((rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || rsurface.modeltexcoordlightmap2f != NULL) ? 0 : 2;
 		if (r_glsl.integer && gl_support_fragment_shader)
 			R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
 		else if (gl_combine.integer && r_textureunits.integer >= 2)
@@ -4553,19 +5542,19 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const
 	for (i = 0;i < numsurfaces;i = j)
 	{
 		j = i + 1;
-		surface = rsurface_model->data_surfaces + surfacelist[i];
+		surface = rsurface.modelsurfaces + surfacelist[i];
 		texture = surface->texture;
 		R_UpdateTextureInfo(ent, texture);
-		rsurface_texture = texture->currentframe;
-		rsurface_uselightmaptexture = surface->lightmaptexture != NULL;
+		rsurface.texture = texture->currentframe;
+		rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
 		// scan ahead until we find a different texture
 		endsurface = min(i + 1024, numsurfaces);
 		texturenumsurfaces = 0;
 		texturesurfacelist[texturenumsurfaces++] = surface;
 		for (;j < endsurface;j++)
 		{
-			surface = rsurface_model->data_surfaces + surfacelist[j];
-			if (texture != surface->texture || rsurface_uselightmaptexture != (surface->lightmaptexture != NULL))
+			surface = rsurface.modelsurfaces + surfacelist[j];
+			if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
 				break;
 			texturesurfacelist[texturenumsurfaces++] = surface;
 		}
@@ -4576,30 +5565,38 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const
 	RSurf_CleanUp();
 }
 
-void R_QueueSurfaceList(int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly)
+void R_QueueSurfaceList(entity_render_t *ent, int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
 {
 	int i, j;
 	vec3_t tempcenter, center;
 	texture_t *texture;
+	// if we're rendering water textures (extra scene renders), use a separate loop to avoid burdening the main one
+	if (addwaterplanes)
+	{
+		for (i = 0;i < numsurfaces;i++)
+			if (surfacelist[i]->texture->currentframe->currentmaterialflags & MATERIALFLAG_WATERSHADER)
+				R_Water_AddWaterPlane(surfacelist[i]);
+		return;
+	}
 	// break the surface list down into batches by texture and use of lightmapping
 	for (i = 0;i < numsurfaces;i = j)
 	{
 		j = i + 1;
-		// texture is the base texture pointer, rsurface_texture is the
+		// texture is the base texture pointer, rsurface.texture is the
 		// current frame/skin the texture is directing us to use (for example
 		// if a model has 2 skins and it is on skin 1, then skin 0 tells us to
 		// use skin 1 instead)
 		texture = surfacelist[i]->texture;
-		rsurface_texture = texture->currentframe;
-		rsurface_uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
-		if (!(rsurface_texture->currentmaterialflags & flagsmask))
+		rsurface.texture = texture->currentframe;
+		rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
+		if (!(rsurface.texture->currentmaterialflags & flagsmask))
 		{
 			// if this texture is not the kind we want, skip ahead to the next one
 			for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
 				;
 			continue;
 		}
-		if (rsurface_texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
+		if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
 		{
 			// transparent surfaces get pushed off into the transparent queue
 			const msurface_t *surface = surfacelist[i];
@@ -4608,13 +5605,13 @@ void R_QueueSurfaceList(int numsurfaces, msurface_t **surfacelist, int flagsmask
 			tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
 			tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
 			tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
-			Matrix4x4_Transform(&rsurface_entity->matrix, tempcenter, center);
-			R_MeshQueue_AddTransparent(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, rsurface_entity, surface - rsurface_model->data_surfaces, r_shadow_rtlight);
+			Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
+			R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, ent, surface - rsurface.modelsurfaces, rsurface.rtlight);
 		}
 		else
 		{
 			// simply scan ahead until we find a different texture or lightmap state
-			for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface_uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
+			for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
 				;
 			// render the range of surfaces
 			R_DrawTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly);
@@ -4652,6 +5649,7 @@ void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, in
 	GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	GL_DepthMask(false);
 	GL_DepthRange(0, 1);
+	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 	GL_DepthTest(true);
 	GL_CullFace(GL_NONE);
 	R_Mesh_Matrix(&identitymatrix);
@@ -4712,14 +5710,14 @@ void R_DrawCollisionBrushes(entity_render_t *ent)
 	GL_DepthMask(false);
 	GL_DepthRange(0, 1);
 	GL_DepthTest(!r_showdisabledepthtest.integer);
-	qglPolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);CHECKGLERROR
+	GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
 	for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
 		if (brush->colbrushf && brush->colbrushf->numtriangles)
 			R_DrawCollisionBrush(brush->colbrushf);
 	for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
 		if (surface->num_collisiontriangles)
 			R_DrawCollisionSurface(ent, surface);
-	qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
+	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 }
 
 void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean drawnormals, int flagsmask)
@@ -4732,6 +5730,7 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean
 	CHECKGLERROR
 	GL_DepthRange(0, 1);
 	GL_DepthTest(!r_showdisabledepthtest.integer);
+	GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 	GL_DepthMask(true);
 	GL_BlendFunc(GL_ONE, GL_ZERO);
 	R_Mesh_ColorPointer(NULL, 0, 0);
@@ -4740,13 +5739,13 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean
 	{
 		if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
 			continue;
-		rsurface_texture = surface->texture->currentframe;
-		if ((rsurface_texture->currentmaterialflags & flagsmask) && surface->num_triangles)
+		rsurface.texture = surface->texture->currentframe;
+		if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
 		{
 			RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
 			if (drawtris)
 			{
-				if (!rsurface_texture->currentlayers->depthmask)
+				if (!rsurface.texture->currentlayers->depthmask)
 					GL_Color(r_showtris.value * r_view.colorscale, 0, 0, 1);
 				else if (ent == r_refdef.worldentity)
 					GL_Color(r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, 1);
@@ -4757,7 +5756,7 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean
 				qglBegin(GL_LINES);
 				for (k = 0;k < surface->num_triangles;k++, elements += 3)
 				{
-#define GLVERTEXELEMENT(n) qglVertex3f(rsurface_vertex3f[elements[n]*3+0], rsurface_vertex3f[elements[n]*3+1], rsurface_vertex3f[elements[n]*3+2])
+#define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2])
 					GLVERTEXELEMENT(0);GLVERTEXELEMENT(1);
 					GLVERTEXELEMENT(1);GLVERTEXELEMENT(2);
 					GLVERTEXELEMENT(2);GLVERTEXELEMENT(0);
@@ -4771,9 +5770,9 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean
 				qglBegin(GL_LINES);
 				for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
 				{
-					VectorCopy(rsurface_vertex3f + l * 3, v);
+					VectorCopy(rsurface.vertex3f + l * 3, v);
 					qglVertex3f(v[0], v[1], v[2]);
-					VectorMA(v, 8, rsurface_svector3f + l * 3, v);
+					VectorMA(v, 8, rsurface.svector3f + l * 3, v);
 					qglVertex3f(v[0], v[1], v[2]);
 				}
 				qglEnd();
@@ -4782,9 +5781,9 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean
 				qglBegin(GL_LINES);
 				for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
 				{
-					VectorCopy(rsurface_vertex3f + l * 3, v);
+					VectorCopy(rsurface.vertex3f + l * 3, v);
 					qglVertex3f(v[0], v[1], v[2]);
-					VectorMA(v, 8, rsurface_tvector3f + l * 3, v);
+					VectorMA(v, 8, rsurface.tvector3f + l * 3, v);
 					qglVertex3f(v[0], v[1], v[2]);
 				}
 				qglEnd();
@@ -4793,9 +5792,9 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean
 				qglBegin(GL_LINES);
 				for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
 				{
-					VectorCopy(rsurface_vertex3f + l * 3, v);
+					VectorCopy(rsurface.vertex3f + l * 3, v);
 					qglVertex3f(v[0], v[1], v[2]);
-					VectorMA(v, 8, rsurface_normal3f + l * 3, v);
+					VectorMA(v, 8, rsurface.normal3f + l * 3, v);
 					qglVertex3f(v[0], v[1], v[2]);
 				}
 				qglEnd();
@@ -4803,11 +5802,11 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean
 			}
 		}
 	}
-	rsurface_texture = NULL;
+	rsurface.texture = NULL;
 }
 
 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
-void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly)
+void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
 {
 	int i, j, endj, f, flagsmask;
 	int counttriangles = 0;
@@ -4823,7 +5822,7 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep
 	RSurf_ActiveWorldEntity();
 
 	// update light styles
-	if (!skysurfaces && !depthonly && model->brushq1.light_styleupdatechains)
+	if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.light_styleupdatechains)
 	{
 		for (i = 0;i < model->brushq1.light_styles;i++)
 		{
@@ -4838,11 +5837,11 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep
 	}
 
 	R_UpdateAllTextureInfo(r_refdef.worldentity);
-	flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL);
+	flagsmask = addwaterplanes ? MATERIALFLAG_WATERSHADER : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
 	f = 0;
 	t = NULL;
-	rsurface_uselightmaptexture = false;
-	rsurface_texture = NULL;
+	rsurface.uselightmaptexture = false;
+	rsurface.texture = NULL;
 	numsurfacelist = 0;
 	j = model->firstmodelsurface;
 	endj = j + model->nummodelsurfaces;
@@ -4867,25 +5866,28 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep
 				counttriangles += surface->num_triangles;
 				if (numsurfacelist >= maxsurfacelist)
 				{
-					R_QueueSurfaceList(numsurfacelist, surfacelist, flagsmask, writedepth, depthonly);
+					R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
 					numsurfacelist = 0;
 				}
 			}
 		}
 	}
 	if (numsurfacelist)
-		R_QueueSurfaceList(numsurfacelist, surfacelist, flagsmask, writedepth, depthonly);
+		R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
 	r_refdef.stats.entities_triangles += counttriangles;
 	RSurf_CleanUp();
 
-	if (r_showcollisionbrushes.integer && !skysurfaces && !depthonly)
-		R_DrawCollisionBrushes(r_refdef.worldentity);
+	if (r_view.showdebug)
+	{
+		if (r_showcollisionbrushes.integer && !skysurfaces && !addwaterplanes && !depthonly)
+			R_DrawCollisionBrushes(r_refdef.worldentity);
 
-	if ((r_showtris.integer || r_shownormals.integer) && !depthonly)
-		R_DrawTrianglesAndNormals(r_refdef.worldentity, r_showtris.integer, r_shownormals.integer, flagsmask);
+		if ((r_showtris.integer || r_shownormals.integer) && !addwaterplanes && !depthonly)
+			R_DrawTrianglesAndNormals(r_refdef.worldentity, r_showtris.integer, r_shownormals.integer, flagsmask);
+	}
 }
 
-void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly)
+void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
 {
 	int i, f, flagsmask;
 	int counttriangles = 0;
@@ -4909,7 +5911,7 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr
 		RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader && !depthonly);
 
 	// update light styles
-	if (!skysurfaces && !depthonly && model->brushq1.light_styleupdatechains)
+	if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.light_styleupdatechains)
 	{
 		for (i = 0;i < model->brushq1.light_styles;i++)
 		{
@@ -4924,11 +5926,11 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr
 	}
 
 	R_UpdateAllTextureInfo(ent);
-	flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL);
+	flagsmask = addwaterplanes ? MATERIALFLAG_WATERSHADER : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
 	f = 0;
 	t = NULL;
-	rsurface_uselightmaptexture = false;
-	rsurface_texture = NULL;
+	rsurface.uselightmaptexture = false;
+	rsurface.texture = NULL;
 	numsurfacelist = 0;
 	surface = model->data_surfaces + model->firstmodelsurface;
 	endsurface = surface + model->nummodelsurfaces;
@@ -4945,19 +5947,22 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr
 			counttriangles += surface->num_triangles;
 			if (numsurfacelist >= maxsurfacelist)
 			{
-				R_QueueSurfaceList(numsurfacelist, surfacelist, flagsmask, writedepth, depthonly);
+				R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
 				numsurfacelist = 0;
 			}
 		}
 	}
 	if (numsurfacelist)
-		R_QueueSurfaceList(numsurfacelist, surfacelist, flagsmask, writedepth, depthonly);
+		R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
 	r_refdef.stats.entities_triangles += counttriangles;
 	RSurf_CleanUp();
 
-	if (r_showcollisionbrushes.integer && !skysurfaces && !depthonly)
-		R_DrawCollisionBrushes(ent);
+	if (r_view.showdebug)
+	{
+		if (r_showcollisionbrushes.integer && !skysurfaces && !addwaterplanes && !depthonly)
+			R_DrawCollisionBrushes(ent);
 
-	if ((r_showtris.integer || r_shownormals.integer) && !depthonly)
-		R_DrawTrianglesAndNormals(ent, r_showtris.integer, r_shownormals.integer, flagsmask);
+		if ((r_showtris.integer || r_shownormals.integer) && !addwaterplanes && !depthonly)
+			R_DrawTrianglesAndNormals(ent, r_showtris.integer, r_shownormals.integer, flagsmask);
+	}
 }