Fix setinfo.
[xonotic/darkplaces.git] / gl_rmain.c
index fbe5758..e96bbba 100644 (file)
@@ -26,14 +26,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "ft2.h"
 #include "csprogs.h"
 #include "cl_video.h"
-#include "dpsoftrast.h"
 #include "cl_collision.h"
 
-#ifdef SUPPORTD3D
-#include <d3d9.h>
-extern LPDIRECT3DDEVICE9 vid_d3d9dev;
-#endif
-
 #ifdef WIN32
 // Enable NVIDIA High Performance Graphics while using Integrated Graphics.
 #ifdef __cplusplus
@@ -48,7 +42,7 @@ __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
 mempool_t *r_main_mempool;
 rtexturepool_t *r_main_texturepool;
 
-static int r_textureframe = 0; ///< used only by R_GetCurrentTexture
+int r_textureframe = 0; ///< used only by R_GetCurrentTexture, incremented per view and per UI render
 
 static qboolean r_loadnormalmap;
 static qboolean r_loadgloss;
@@ -98,11 +92,12 @@ cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "1 shows surfaces as differen
 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
 cvar_t r_showlighting = {0, "r_showlighting", "0", "shows areas lit by lights, useful for finding out why some areas of a map render slowly (bright orange = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
-cvar_t r_showshadowvolumes = {0, "r_showshadowvolumes", "0", "shows areas shadowed by lights, useful for finding out why some areas of a map render slowly (bright blue = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
 cvar_t r_showcollisionbrushes_polygonfactor = {0, "r_showcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};
 cvar_t r_showcollisionbrushes_polygonoffset = {0, "r_showcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};
 cvar_t r_showdisabledepthtest = {0, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"};
+cvar_t r_showspriteedges = {0, "r_showspriteedges", "0", "renders a debug outline to show the polygon shape of each sprite frame rendered (may be 2 or more in case of interpolated animations), for debugging rendering bugs with specific view types"};
+cvar_t r_showparticleedges = {0, "r_showparticleedges", "0", "renders a debug outline to show the polygon shape of each particle, for debugging rendering bugs with specific view types"};
 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
 cvar_t r_draw2d = {0, "r_draw2d","1", "draw 2D stuff (dangerous to turn off)"};
@@ -114,6 +109,8 @@ cvar_t r_cullentities_trace_entityocclusion = { 0, "r_cullentities_trace_entityo
 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling (in addition to center sample)"};
 cvar_t r_cullentities_trace_tempentitysamples = {0, "r_cullentities_trace_tempentitysamples", "-1", "number of samples to test for entity culling of temp entities (including all CSQC entities), -1 disables trace culling on these entities to prevent flicker (pvs still applies)"};
 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
+cvar_t r_cullentities_trace_expand = {0, "r_cullentities_trace_expand", "0", "box expanded by this many units for entity culling"};
+cvar_t r_cullentities_trace_pad = {0, "r_cullentities_trace_pad", "8", "accept traces that hit within this many units of the box"};
 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
 cvar_t r_cullentities_trace_eyejitter = {0, "r_cullentities_trace_eyejitter", "16", "randomly offset rays from the eye by this much to reduce the odds of flickering"};
 cvar_t r_sortentities = {0, "r_sortentities", "0", "sort entities before drawing (might be faster)"};
@@ -175,6 +172,7 @@ static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the Ope
 
 cvar_t r_usedepthtextures = {CVAR_SAVE, "r_usedepthtextures", "1", "use depth texture instead of depth renderbuffer where possible, uses less video memory but may render slower (or faster) depending on hardware"};
 cvar_t r_viewfbo = {CVAR_SAVE, "r_viewfbo", "0", "enables use of an 8bit (1) or 16bit (2) or 32bit (3) per component float framebuffer render, which may be at a different resolution than the video mode"};
+cvar_t r_rendertarget_debug = {0, "r_rendertarget_debug", "-1", "replaces the view with the contents of the specified render target (by number - note that these can fluctuate depending on scene)"};
 cvar_t r_viewscale = {CVAR_SAVE, "r_viewscale", "1", "scaling factor for resolution of the fbo rendering method, must be > 0, can be above 1 for a costly antialiasing behavior, typical values are 0.5 for 1/4th as many pixels rendered, or 1 for normal rendering"};
 cvar_t r_viewscale_fpsscaling = {CVAR_SAVE, "r_viewscale_fpsscaling", "0", "change resolution based on framerate"};
 cvar_t r_viewscale_fpsscaling_min = {CVAR_SAVE, "r_viewscale_fpsscaling_min", "0.0625", "worst acceptable quality"};
@@ -212,7 +210,6 @@ cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "h
 cvar_t r_water_scissormode = {0, "r_water_scissormode", "3", "scissor (1) or cull (2) or both (3) water renders"};
 cvar_t r_water_lowquality = {0, "r_water_lowquality", "0", "special option to accelerate water rendering, 1 disables shadows and particles, 2 disables all dynamic lights"};
 cvar_t r_water_hideplayer = {CVAR_SAVE, "r_water_hideplayer", "0", "if set to 1 then player will be hidden in refraction views, if set to 2 then player will also be hidden in reflection views, player is always visible in camera views"};
-cvar_t r_water_fbo = {CVAR_SAVE, "r_water_fbo", "1", "enables use of render to texture for water effects, otherwise copy to texture is used (slower)"};
 
 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "0", "enables animation smoothing on sprites"};
 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
@@ -319,7 +316,6 @@ static int r_qwskincache_size;
 
 /// vertex coordinates for a quad that covers the screen exactly
 extern const float r_screenvertex3f[12];
-extern const float r_d3dscreenvertex3f[12];
 const float r_screenvertex3f[12] =
 {
        0, 0, 0,
@@ -327,13 +323,6 @@ const float r_screenvertex3f[12] =
        1, 1, 0,
        0, 1, 0
 };
-const float r_d3dscreenvertex3f[12] =
-{
-       0, 1, 0,
-       1, 1, 0,
-       1, 0, 0,
-       0, 0, 0
-};
 
 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
 {
@@ -639,12 +628,6 @@ static const char *builtinshaderstrings[] =
 0
 };
 
-const char *builtinhlslshaderstrings[] =
-{
-#include "shader_hlsl.h"
-0
-};
-
 //=======================================================================================================================================================
 
 typedef struct shaderpermutationinfo_s
@@ -727,26 +710,6 @@ shadermodeinfo_t shadermodeinfo[SHADERLANGUAGE_COUNT][SHADERMODE_COUNT] =
                {"combined", "glsl", builtinshaderstrings, "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
                {"combined", "glsl", builtinshaderstrings, "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
        },
-       // SHADERLANGUAGE_HLSL
-       {
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_GENERIC\n", " generic"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_POSTPROCESS\n", " postprocess"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_FLATCOLOR\n", " flatcolor"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_LIGHTMAP\n", " lightmap"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_FAKELIGHT\n", " fakelight"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP\n", " lightdirectionmap_forced_lightmap"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_LIGHTDIRECTIONMAP_FORCED_VERTEXCOLOR\n", " lightdirectionmap_forced_vertexcolor"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_LIGHTSOURCE\n", " lightsource"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_REFRACTION\n", " refraction"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_WATER\n", " water"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
-               {"combined", "hlsl", builtinhlslshaderstrings, "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
-       },
 };
 
 struct r_glsl_permutation_s;
@@ -1190,6 +1153,9 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode
        geomstrings_list[geomstrings_count++] = sourcestring;
        fragstrings_list[fragstrings_count++] = sourcestring;
 
+       // we don't currently use geometry shaders for anything, so just empty the list
+       geomstrings_count = 0;
+
        // compile the shader program
        if (vertstrings_count + geomstrings_count + fragstrings_count)
                p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
@@ -1368,12 +1334,10 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode
                if (p->loc_Texture_ReflectCube     >= 0) {p->tex_Texture_ReflectCube      = sampler;qglUniform1i(p->loc_Texture_ReflectCube     , sampler);sampler++;}
                if (p->loc_Texture_BounceGrid      >= 0) {p->tex_Texture_BounceGrid       = sampler;qglUniform1i(p->loc_Texture_BounceGrid      , sampler);sampler++;}
                // get the uniform block indices so we can bind them
+               p->ubiloc_Skeletal_Transform12_UniformBlock = -1;
 #ifndef USE_GLES2 /* FIXME: GLES3 only */
-               if (vid.support.arb_uniform_buffer_object)
-                       p->ubiloc_Skeletal_Transform12_UniformBlock = qglGetUniformBlockIndex(p->program, "Skeletal_Transform12_UniformBlock");
-               else
+               p->ubiloc_Skeletal_Transform12_UniformBlock = qglGetUniformBlockIndex(p->program, "Skeletal_Transform12_UniformBlock");
 #endif
-                       p->ubiloc_Skeletal_Transform12_UniformBlock = -1;
                // clear the uniform block bindings
                p->ubibind_Skeletal_Transform12_UniformBlock = -1;
                // bind the uniform blocks in use
@@ -1403,7 +1367,7 @@ static void R_SetupShader_SetPermutationGLSL(unsigned int mode, dpuint64 permuta
                {
                        if (!r_glsl_permutation->compiled)
                        {
-                               Con_DPrintf("Compiling shader mode %u permutation %u\n", mode, permutation);
+                               Con_DPrintf("Compiling shader mode %u permutation %llx\n", mode, permutation);
                                R_GLSL_CompilePermutation(perm, mode, permutation);
                        }
                        if (!r_glsl_permutation->program)
@@ -1441,515 +1405,12 @@ static void R_SetupShader_SetPermutationGLSL(unsigned int mode, dpuint64 permuta
        CHECKGLERROR
 }
 
-#ifdef SUPPORTD3D
-
-#ifdef SUPPORTD3D
-#include <d3d9.h>
-extern LPDIRECT3DDEVICE9 vid_d3d9dev;
-extern D3DCAPS9 vid_d3d9caps;
-#endif
-
-struct r_hlsl_permutation_s;
-typedef struct r_hlsl_permutation_s
-{
-       /// hash lookup data
-       struct r_hlsl_permutation_s *hashnext;
-       unsigned int mode;
-       dpuint64 permutation;
-
-       /// indicates if we have tried compiling this permutation already
-       qboolean compiled;
-       /// NULL if compilation failed
-       IDirect3DVertexShader9 *vertexshader;
-       IDirect3DPixelShader9 *pixelshader;
-}
-r_hlsl_permutation_t;
-
-typedef enum D3DVSREGISTER_e
-{
-       D3DVSREGISTER_TexMatrix = 0, // float4x4
-       D3DVSREGISTER_BackgroundTexMatrix = 4, // float4x4
-       D3DVSREGISTER_ModelViewProjectionMatrix = 8, // float4x4
-       D3DVSREGISTER_ModelViewMatrix = 12, // float4x4
-       D3DVSREGISTER_ShadowMapMatrix = 16, // float4x4
-       D3DVSREGISTER_ModelToLight = 20, // float4x4
-       D3DVSREGISTER_EyePosition = 24,
-       D3DVSREGISTER_FogPlane = 25,
-       D3DVSREGISTER_LightDir = 26,
-       D3DVSREGISTER_LightPosition = 27,
-}
-D3DVSREGISTER_t;
-
-typedef enum D3DPSREGISTER_e
-{
-       D3DPSREGISTER_Alpha = 0,
-       D3DPSREGISTER_BloomBlur_Parameters = 1,
-       D3DPSREGISTER_ClientTime = 2,
-       D3DPSREGISTER_Color_Ambient = 3,
-       D3DPSREGISTER_Color_Diffuse = 4,
-       D3DPSREGISTER_Color_Specular = 5,
-       D3DPSREGISTER_Color_Glow = 6,
-       D3DPSREGISTER_Color_Pants = 7,
-       D3DPSREGISTER_Color_Shirt = 8,
-       D3DPSREGISTER_DeferredColor_Ambient = 9,
-       D3DPSREGISTER_DeferredColor_Diffuse = 10,
-       D3DPSREGISTER_DeferredColor_Specular = 11,
-       D3DPSREGISTER_DeferredMod_Diffuse = 12,
-       D3DPSREGISTER_DeferredMod_Specular = 13,
-       D3DPSREGISTER_DistortScaleRefractReflect = 14,
-       D3DPSREGISTER_EyePosition = 15, // unused
-       D3DPSREGISTER_FogColor = 16,
-       D3DPSREGISTER_FogHeightFade = 17,
-       D3DPSREGISTER_FogPlane = 18,
-       D3DPSREGISTER_FogPlaneViewDist = 19,
-       D3DPSREGISTER_FogRangeRecip = 20,
-       D3DPSREGISTER_LightColor = 21,
-       D3DPSREGISTER_LightDir = 22, // unused
-       D3DPSREGISTER_LightPosition = 23,
-       D3DPSREGISTER_OffsetMapping_ScaleSteps = 24,
-       D3DPSREGISTER_PixelSize = 25,
-       D3DPSREGISTER_ReflectColor = 26,
-       D3DPSREGISTER_ReflectFactor = 27,
-       D3DPSREGISTER_ReflectOffset = 28,
-       D3DPSREGISTER_RefractColor = 29,
-       D3DPSREGISTER_Saturation = 30,
-       D3DPSREGISTER_ScreenCenterRefractReflect = 31,
-       D3DPSREGISTER_ScreenScaleRefractReflect = 32,
-       D3DPSREGISTER_ScreenToDepth = 33,
-       D3DPSREGISTER_ShadowMap_Parameters = 34,
-       D3DPSREGISTER_ShadowMap_TextureScale = 35,
-       D3DPSREGISTER_SpecularPower = 36,
-       D3DPSREGISTER_UserVec1 = 37,
-       D3DPSREGISTER_UserVec2 = 38,
-       D3DPSREGISTER_UserVec3 = 39,
-       D3DPSREGISTER_UserVec4 = 40,
-       D3DPSREGISTER_ViewTintColor = 41,
-       D3DPSREGISTER_PixelToScreenTexCoord = 42,
-       D3DPSREGISTER_BloomColorSubtract = 43,
-       D3DPSREGISTER_ViewToLight = 44, // float4x4
-       D3DPSREGISTER_ModelToReflectCube = 48, // float4x4
-       D3DPSREGISTER_NormalmapScrollBlend = 52,
-       D3DPSREGISTER_OffsetMapping_LodDistance = 53,
-       D3DPSREGISTER_OffsetMapping_Bias = 54,
-       // next at 54
-}
-D3DPSREGISTER_t;
-
-/// information about each possible shader permutation
-r_hlsl_permutation_t *r_hlsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
-/// currently selected permutation
-r_hlsl_permutation_t *r_hlsl_permutation;
-/// storage for permutations linked in the hash table
-memexpandablearray_t r_hlsl_permutationarray;
-
-static r_hlsl_permutation_t *R_HLSL_FindPermutation(unsigned int mode, dpuint64 permutation)
-{
-       //unsigned int hashdepth = 0;
-       unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
-       r_hlsl_permutation_t *p;
-       for (p = r_hlsl_permutationhash[mode][hashindex];p;p = p->hashnext)
-       {
-               if (p->mode == mode && p->permutation == permutation)
-               {
-                       //if (hashdepth > 10)
-                       //      Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
-                       return p;
-               }
-               //hashdepth++;
-       }
-       p = (r_hlsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_hlsl_permutationarray);
-       p->mode = mode;
-       p->permutation = permutation;
-       p->hashnext = r_hlsl_permutationhash[mode][hashindex];
-       r_hlsl_permutationhash[mode][hashindex] = p;
-       //if (hashdepth > 10)
-       //      Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
-       return p;
-}
-
-#include <d3dx9.h>
-//#include <d3dx9shader.h>
-//#include <d3dx9mesh.h>
-
-static void R_HLSL_CacheShader(r_hlsl_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring)
-{
-       DWORD *vsbin = NULL;
-       DWORD *psbin = NULL;
-       fs_offset_t vsbinsize;
-       fs_offset_t psbinsize;
-//     IDirect3DVertexShader9 *vs = NULL;
-//     IDirect3DPixelShader9 *ps = NULL;
-       ID3DXBuffer *vslog = NULL;
-       ID3DXBuffer *vsbuffer = NULL;
-       ID3DXConstantTable *vsconstanttable = NULL;
-       ID3DXBuffer *pslog = NULL;
-       ID3DXBuffer *psbuffer = NULL;
-       ID3DXConstantTable *psconstanttable = NULL;
-       int vsresult = 0;
-       int psresult = 0;
-       char temp[MAX_INPUTLINE];
-       const char *vsversion = "vs_3_0", *psversion = "ps_3_0";
-       char vabuf[1024];
-       qboolean debugshader = gl_paranoid.integer != 0;
-       if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";}
-       if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";}
-       if (!debugshader)
-       {
-               vsbin = (DWORD *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.vsbin", cachename), r_main_mempool, true, &vsbinsize);
-               psbin = (DWORD *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.psbin", cachename), r_main_mempool, true, &psbinsize);
-       }
-       if ((!vsbin && vertstring) || (!psbin && fragstring))
-       {
-               const char* dllnames_d3dx9 [] =
-               {
-                       "d3dx9_43.dll",
-                       "d3dx9_42.dll",
-                       "d3dx9_41.dll",
-                       "d3dx9_40.dll",
-                       "d3dx9_39.dll",
-                       "d3dx9_38.dll",
-                       "d3dx9_37.dll",
-                       "d3dx9_36.dll",
-                       "d3dx9_35.dll",
-                       "d3dx9_34.dll",
-                       "d3dx9_33.dll",
-                       "d3dx9_32.dll",
-                       "d3dx9_31.dll",
-                       "d3dx9_30.dll",
-                       "d3dx9_29.dll",
-                       "d3dx9_28.dll",
-                       "d3dx9_27.dll",
-                       "d3dx9_26.dll",
-                       "d3dx9_25.dll",
-                       "d3dx9_24.dll",
-                       NULL
-               };
-               dllhandle_t d3dx9_dll = NULL;
-               HRESULT (WINAPI *qD3DXCompileShaderFromFileA)(LPCSTR pSrcFile, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
-               HRESULT (WINAPI *qD3DXPreprocessShader)(LPCSTR pSrcData, UINT SrcDataSize, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPD3DXBUFFER* ppShaderText, LPD3DXBUFFER* ppErrorMsgs);
-               HRESULT (WINAPI *qD3DXCompileShader)(LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
-               dllfunction_t d3dx9_dllfuncs[] =
-               {
-                       {"D3DXCompileShaderFromFileA",  (void **) &qD3DXCompileShaderFromFileA},
-                       {"D3DXPreprocessShader",                (void **) &qD3DXPreprocessShader},
-                       {"D3DXCompileShader",                   (void **) &qD3DXCompileShader},
-                       {NULL, NULL}
-               };
-               // LordHavoc: the June 2010 SDK lacks these macros to make ID3DXBuffer usable in C, and to make it work in both C and C++ the macros are needed...
-#ifndef ID3DXBuffer_GetBufferPointer
-#if !defined(__cplusplus) || defined(CINTERFACE)
-#define ID3DXBuffer_GetBufferPointer(p)   (p)->lpVtbl->GetBufferPointer(p)
-#define ID3DXBuffer_GetBufferSize(p)      (p)->lpVtbl->GetBufferSize(p)
-#define ID3DXBuffer_Release(p)            (p)->lpVtbl->Release(p)
-#else
-#define ID3DXBuffer_GetBufferPointer(p)   (p)->GetBufferPointer()
-#define ID3DXBuffer_GetBufferSize(p)      (p)->GetBufferSize()
-#define ID3DXBuffer_Release(p)            (p)->Release()
-#endif
-#endif
-               if (Sys_LoadLibrary(dllnames_d3dx9, &d3dx9_dll, d3dx9_dllfuncs))
-               {
-                       DWORD shaderflags = 0;
-                       if (debugshader)
-                               shaderflags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION;
-                       vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0);
-                       psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0);
-                       if (vertstring && vertstring[0])
-                       {
-                               if (debugshader)
-                               {
-                                       FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_vs.fx", cachename), vertstring, strlen(vertstring));
-                                       vsresult = qD3DXCompileShaderFromFileA(va(vabuf, sizeof(vabuf), "%s/%s_vs.fx", fs_gamedir, cachename), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable);
-                               }
-                               else
-                                       vsresult = qD3DXCompileShader(vertstring, (unsigned int)strlen(vertstring), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable);
-                               if (vsbuffer)
-                               {
-                                       vsbinsize = ID3DXBuffer_GetBufferSize(vsbuffer);
-                                       vsbin = (DWORD *)Mem_Alloc(tempmempool, vsbinsize);
-                                       memcpy(vsbin, ID3DXBuffer_GetBufferPointer(vsbuffer), vsbinsize);
-                                       ID3DXBuffer_Release(vsbuffer);
-                               }
-                               if (vslog)
-                               {
-                                       strlcpy(temp, (const char *)ID3DXBuffer_GetBufferPointer(vslog), min(sizeof(temp), ID3DXBuffer_GetBufferSize(vslog)));
-                                       Con_DPrintf("HLSL vertex shader compile output for %s follows:\n%s\n", cachename, temp);
-                                       ID3DXBuffer_Release(vslog);
-                               }
-                       }
-                       if (fragstring && fragstring[0])
-                       {
-                               if (debugshader)
-                               {
-                                       FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_ps.fx", cachename), fragstring, strlen(fragstring));
-                                       psresult = qD3DXCompileShaderFromFileA(va(vabuf, sizeof(vabuf), "%s/%s_ps.fx", fs_gamedir, cachename), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable);
-                               }
-                               else
-                                       psresult = qD3DXCompileShader(fragstring, (unsigned int)strlen(fragstring), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable);
-                               if (psbuffer)
-                               {
-                                       psbinsize = ID3DXBuffer_GetBufferSize(psbuffer);
-                                       psbin = (DWORD *)Mem_Alloc(tempmempool, psbinsize);
-                                       memcpy(psbin, ID3DXBuffer_GetBufferPointer(psbuffer), psbinsize);
-                                       ID3DXBuffer_Release(psbuffer);
-                               }
-                               if (pslog)
-                               {
-                                       strlcpy(temp, (const char *)ID3DXBuffer_GetBufferPointer(pslog), min(sizeof(temp), ID3DXBuffer_GetBufferSize(pslog)));
-                                       Con_DPrintf("HLSL pixel shader compile output for %s follows:\n%s\n", cachename, temp);
-                                       ID3DXBuffer_Release(pslog);
-                               }
-                       }
-                       Sys_UnloadLibrary(&d3dx9_dll);
-               }
-               else
-                       Con_DPrintf("Unable to compile shader - D3DXCompileShader function not found\n");
-       }
-       if (vsbin && psbin)
-       {
-               vsresult = IDirect3DDevice9_CreateVertexShader(vid_d3d9dev, vsbin, &p->vertexshader);
-               if (FAILED(vsresult))
-                       Con_DPrintf("HLSL CreateVertexShader failed for %s (hresult = %8x)\n", cachename, vsresult);
-               psresult = IDirect3DDevice9_CreatePixelShader(vid_d3d9dev, psbin, &p->pixelshader);
-               if (FAILED(psresult))
-                       Con_DPrintf("HLSL CreatePixelShader failed for %s (hresult = %8x)\n", cachename, psresult);
-       }
-       // free the shader data
-       vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0);
-       psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0);
-}
-
-static void R_HLSL_CompilePermutation(r_hlsl_permutation_t *p, unsigned int mode, dpuint64 permutation)
-{
-       int i;
-       shadermodeinfo_t *modeinfo = &shadermodeinfo[SHADERLANGUAGE_HLSL][mode];
-       int vertstring_length = 0;
-       int geomstring_length = 0;
-       int fragstring_length = 0;
-       char *t;
-       char *sourcestring;
-       char *vertstring, *geomstring, *fragstring;
-       char permutationname[256];
-       char cachename[256];
-       int vertstrings_count = 0;
-       int geomstrings_count = 0;
-       int fragstrings_count = 0;
-       const char *vertstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
-       const char *geomstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
-       const char *fragstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
-
-       if (p->compiled)
-               return;
-       p->compiled = true;
-       p->vertexshader = NULL;
-       p->pixelshader = NULL;
-
-       permutationname[0] = 0;
-       cachename[0] = 0;
-       sourcestring = ShaderModeInfo_GetShaderText(modeinfo, true, false);
-
-       strlcat(permutationname, modeinfo->filename, sizeof(permutationname));
-       strlcat(cachename, "hlsl/", sizeof(cachename));
-
-       // define HLSL so that the shader can tell apart the HLSL compiler and the Cg compiler
-       vertstrings_count = 0;
-       geomstrings_count = 0;
-       fragstrings_count = 0;
-       vertstrings_list[vertstrings_count++] = "#define HLSL\n";
-       geomstrings_list[geomstrings_count++] = "#define HLSL\n";
-       fragstrings_list[fragstrings_count++] = "#define HLSL\n";
-
-       // the first pretext is which type of shader to compile as
-       // (later these will all be bound together as a program object)
-       vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
-       geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
-       fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
-
-       // the second pretext is the mode (for example a light source)
-       vertstrings_list[vertstrings_count++] = modeinfo->pretext;
-       geomstrings_list[geomstrings_count++] = modeinfo->pretext;
-       fragstrings_list[fragstrings_count++] = modeinfo->pretext;
-       strlcat(permutationname, modeinfo->name, sizeof(permutationname));
-       strlcat(cachename, modeinfo->name, sizeof(cachename));
-
-       // now add all the permutation pretexts
-       for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
-       {
-               if (permutation & (1ll<<i))
-               {
-                       vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
-                       geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
-                       fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
-                       strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
-                       strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename));
-               }
-               else
-               {
-                       // keep line numbers correct
-                       vertstrings_list[vertstrings_count++] = "\n";
-                       geomstrings_list[geomstrings_count++] = "\n";
-                       fragstrings_list[fragstrings_count++] = "\n";
-               }
-       }
-
-       // add static parms
-       R_CompileShader_AddStaticParms(mode, permutation);
-       memcpy(vertstrings_list + vertstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
-       vertstrings_count += shaderstaticparms_count;
-       memcpy(geomstrings_list + geomstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
-       geomstrings_count += shaderstaticparms_count;
-       memcpy(fragstrings_list + fragstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
-       fragstrings_count += shaderstaticparms_count;
-
-       // replace spaces in the cachename with _ characters
-       for (i = 0;cachename[i];i++)
-               if (cachename[i] == ' ')
-                       cachename[i] = '_';
-
-       // now append the shader text itself
-       vertstrings_list[vertstrings_count++] = sourcestring;
-       geomstrings_list[geomstrings_count++] = sourcestring;
-       fragstrings_list[fragstrings_count++] = sourcestring;
-
-       vertstring_length = 0;
-       for (i = 0;i < vertstrings_count;i++)
-               vertstring_length += (int)strlen(vertstrings_list[i]);
-       vertstring = t = (char *)Mem_Alloc(tempmempool, vertstring_length + 1);
-       for (i = 0;i < vertstrings_count;t += (int)strlen(vertstrings_list[i]), i++)
-               memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
-
-       geomstring_length = 0;
-       for (i = 0;i < geomstrings_count;i++)
-               geomstring_length += (int)strlen(geomstrings_list[i]);
-       geomstring = t = (char *)Mem_Alloc(tempmempool, geomstring_length + 1);
-       for (i = 0;i < geomstrings_count;t += (int)strlen(geomstrings_list[i]), i++)
-               memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
-
-       fragstring_length = 0;
-       for (i = 0;i < fragstrings_count;i++)
-               fragstring_length += (int)strlen(fragstrings_list[i]);
-       fragstring = t = (char *)Mem_Alloc(tempmempool, fragstring_length + 1);
-       for (i = 0;i < fragstrings_count;t += (int)strlen(fragstrings_list[i]), i++)
-               memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
-
-       // try to load the cached shader, or generate one
-       R_HLSL_CacheShader(p, cachename, vertstring, fragstring);
-
-       if ((p->vertexshader || !vertstring[0]) && (p->pixelshader || !fragstring[0]))
-               Con_DPrintf("^5HLSL shader %s compiled.\n", permutationname);
-       else
-               Con_Printf("^1HLSL shader %s failed!  some features may not work properly.\n", permutationname);
-
-       // free the strings
-       if (vertstring)
-               Mem_Free(vertstring);
-       if (geomstring)
-               Mem_Free(geomstring);
-       if (fragstring)
-               Mem_Free(fragstring);
-       if (sourcestring)
-               Mem_Free(sourcestring);
-}
-
-static inline void hlslVSSetParameter16f(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 4);}
-static inline void hlslVSSetParameter4fv(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 1);}
-static inline void hlslVSSetParameter4f(D3DVSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
-static inline void hlslVSSetParameter3f(D3DVSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
-static inline void hlslVSSetParameter2f(D3DVSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
-static inline void hlslVSSetParameter1f(D3DVSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
-
-static inline void hlslPSSetParameter16f(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 4);}
-static inline void hlslPSSetParameter4fv(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 1);}
-static inline void hlslPSSetParameter4f(D3DPSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
-static inline void hlslPSSetParameter3f(D3DPSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
-static inline void hlslPSSetParameter2f(D3DPSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
-static inline void hlslPSSetParameter1f(D3DPSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
-
-void R_SetupShader_SetPermutationHLSL(unsigned int mode, dpuint64 permutation)
-{
-       r_hlsl_permutation_t *perm = R_HLSL_FindPermutation(mode, permutation);
-       if (r_hlsl_permutation != perm)
-       {
-               r_hlsl_permutation = perm;
-               if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader)
-               {
-                       if (!r_hlsl_permutation->compiled)
-                               R_HLSL_CompilePermutation(perm, mode, permutation);
-                       if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader)
-                       {
-                               // remove features until we find a valid permutation
-                               int i;
-                               for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
-                               {
-                                       // reduce i more quickly whenever it would not remove any bits
-                                       dpuint64 j = 1ll<<(SHADERPERMUTATION_COUNT-1-i);
-                                       if (!(permutation & j))
-                                               continue;
-                                       permutation -= j;
-                                       r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation);
-                                       if (!r_hlsl_permutation->compiled)
-                                               R_HLSL_CompilePermutation(perm, mode, permutation);
-                                       if (r_hlsl_permutation->vertexshader || r_hlsl_permutation->pixelshader)
-                                               break;
-                               }
-                               if (i >= SHADERPERMUTATION_COUNT)
-                               {
-                                       //Con_Printf("Could not find a working HLSL shader for permutation %s %s\n", shadermodeinfo[mode].filename, shadermodeinfo[mode].pretext);
-                                       r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation);
-                                       return; // no bit left to clear, entire mode is broken
-                               }
-                       }
-               }
-               IDirect3DDevice9_SetVertexShader(vid_d3d9dev, r_hlsl_permutation->vertexshader);
-               IDirect3DDevice9_SetPixelShader(vid_d3d9dev, r_hlsl_permutation->pixelshader);
-       }
-       hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
-       hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
-       hlslPSSetParameter1f(D3DPSREGISTER_ClientTime, cl.time);
-}
-#endif
-
-static void R_SetupShader_SetPermutationSoft(unsigned int mode, dpuint64 permutation)
-{
-       DPSOFTRAST_SetShader(mode, permutation, r_shadow_glossexact.integer);
-       DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewProjectionMatrixM1, 1, false, gl_modelviewprojection16f);
-       DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewMatrixM1, 1, false, gl_modelview16f);
-       DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_ClientTime, cl.time);
-}
-
 void R_GLSL_Restart_f(void)
 {
        unsigned int i, limit;
        switch(vid.renderpath)
        {
-       case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-               {
-                       r_hlsl_permutation_t *p;
-                       r_hlsl_permutation = NULL;
-                       limit = (unsigned int)Mem_ExpandableArray_IndexRange(&r_hlsl_permutationarray);
-                       for (i = 0;i < limit;i++)
-                       {
-                               if ((p = (r_hlsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_hlsl_permutationarray, i)))
-                               {
-                                       if (p->vertexshader)
-                                               IDirect3DVertexShader9_Release(p->vertexshader);
-                                       if (p->pixelshader)
-                                               IDirect3DPixelShader9_Release(p->pixelshader);
-                                       Mem_ExpandableArray_FreeRecord(&r_hlsl_permutationarray, (void*)p);
-                               }
-                       }
-                       memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
-               }
-#endif
-               break;
-       case RENDERPATH_D3D10:
-               Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_D3D11:
-               Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_GL20:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
                {
                        r_glsl_permutation_t *p;
@@ -1966,12 +1427,6 @@ void R_GLSL_Restart_f(void)
                        memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
                }
                break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               break;
-       case RENDERPATH_SOFT:
-               break;
        }
 }
 
@@ -2016,85 +1471,36 @@ static void R_GLSL_DumpShader_f(void)
        }
 }
 
-void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale, qboolean usegamma, qboolean notrippy, qboolean suppresstexalpha)
+void R_SetupShader_Generic(rtexture_t *t, qboolean usegamma, qboolean notrippy, qboolean suppresstexalpha)
 {
        dpuint64 permutation = 0;
        if (r_trippy.integer && !notrippy)
                permutation |= SHADERPERMUTATION_TRIPPY;
        permutation |= SHADERPERMUTATION_VIEWTINT;
-       if (first)
+       if (t)
                permutation |= SHADERPERMUTATION_DIFFUSE;
-       if (second)
-               permutation |= SHADERPERMUTATION_SPECULAR;
-       if (texturemode == GL_MODULATE)
-               permutation |= SHADERPERMUTATION_COLORMAPPING;
-       else if (texturemode == GL_ADD)
-               permutation |= SHADERPERMUTATION_GLOW;
-       else if (texturemode == GL_DECAL)
-               permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
        if (usegamma && v_glslgamma_2d.integer && !vid.sRGB2D && r_texture_gammaramps && !vid_gammatables_trivial)
                permutation |= SHADERPERMUTATION_GAMMARAMPS;
        if (suppresstexalpha)
                permutation |= SHADERPERMUTATION_REFLECTCUBE;
-       if (!second)
-               texturemode = GL_MODULATE;
        if (vid.allowalphatocoverage)
                GL_AlphaToCoverage(false);
        switch (vid.renderpath)
        {
-       case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-               R_SetupShader_SetPermutationHLSL(SHADERMODE_GENERIC, permutation);
-               R_Mesh_TexBind(GL20TU_FIRST , first );
-               R_Mesh_TexBind(GL20TU_SECOND, second);
-               if (permutation & SHADERPERMUTATION_GAMMARAMPS)
-                       R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps);
-#endif
-               break;
-       case RENDERPATH_D3D10:
-               Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_D3D11:
-               Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_GL20:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
                R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, permutation);
                if (r_glsl_permutation->tex_Texture_First >= 0)
-                       R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First , first );
-               if (r_glsl_permutation->tex_Texture_Second >= 0)
-                       R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Second, second);
+                       R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First, t);
                if (r_glsl_permutation->tex_Texture_GammaRamps >= 0)
                        R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps, r_texture_gammaramps);
                break;
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               R_Mesh_TexBind(0, first );
-               R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-               R_Mesh_TexMatrix(0, NULL);
-               R_Mesh_TexBind(1, second);
-               if (second)
-               {
-                       R_Mesh_TexCombine(1, texturemode, texturemode, rgbscale, 1);
-                       R_Mesh_TexMatrix(1, NULL);
-               }
-               break;
-       case RENDERPATH_GL11:
-               R_Mesh_TexBind(0, first );
-               R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-               R_Mesh_TexMatrix(0, NULL);
-               break;
-       case RENDERPATH_SOFT:
-               R_SetupShader_SetPermutationSoft(SHADERMODE_GENERIC, permutation);
-               R_Mesh_TexBind(GL20TU_FIRST , first );
-               R_Mesh_TexBind(GL20TU_SECOND, second);
-               break;
        }
 }
 
 void R_SetupShader_Generic_NoTexture(qboolean usegamma, qboolean notrippy)
 {
-       R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1, usegamma, notrippy, false);
+       R_SetupShader_Generic(NULL, usegamma, notrippy, false);
 }
 
 void R_SetupShader_DepthOrShadow(qboolean notrippy, qboolean depthrgb, qboolean skeletal)
@@ -2111,35 +1517,13 @@ void R_SetupShader_DepthOrShadow(qboolean notrippy, qboolean depthrgb, qboolean
                GL_AlphaToCoverage(false);
        switch (vid.renderpath)
        {
-       case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-               R_SetupShader_SetPermutationHLSL(SHADERMODE_DEPTH_OR_SHADOW, permutation);
-#endif
-               break;
-       case RENDERPATH_D3D10:
-               Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_D3D11:
-               Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_GL20:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
                R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, permutation);
 #ifndef USE_GLES2 /* FIXME: GLES3 only */
                if (r_glsl_permutation->ubiloc_Skeletal_Transform12_UniformBlock >= 0 && rsurface.batchskeletaltransform3x4buffer) qglBindBufferRange(GL_UNIFORM_BUFFER, r_glsl_permutation->ubibind_Skeletal_Transform12_UniformBlock, rsurface.batchskeletaltransform3x4buffer->bufferobject, rsurface.batchskeletaltransform3x4offset, rsurface.batchskeletaltransform3x4size);
 #endif
                break;
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               R_Mesh_TexBind(0, 0);
-               R_Mesh_TexBind(1, 0);
-               break;
-       case RENDERPATH_GL11:
-               R_Mesh_TexBind(0, 0);
-               break;
-       case RENDERPATH_SOFT:
-               R_SetupShader_SetPermutationSoft(SHADERMODE_DEPTH_OR_SHADOW, permutation);
-               break;
        }
 }
 
@@ -2479,229 +1863,55 @@ void R_SetupShader_Surface(const float rtlightambient[3], const float rtlightdif
                permutation |= SHADERPERMUTATION_FOGALPHAHACK;
        switch(vid.renderpath)
        {
-       case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-               RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0) | BATCHNEED_ALLOWMULTIDRAW, texturenumsurfaces, texturesurfacelist);
-               R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmesh_vertexbuffer, rsurface.batchvertexmesh_bufferoffset);
-               R_SetupShader_SetPermutationHLSL(mode, permutation);
-               Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);hlslPSSetParameter16f(D3DPSREGISTER_ModelToReflectCube, m16f);
-               if (mode == SHADERMODE_LIGHTSOURCE)
-               {
-                       Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ModelToLight, m16f);
-                       hlslVSSetParameter3f(D3DVSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
-               }
-               else
-               {
-                       if (mode == SHADERMODE_LIGHTDIRECTION)
-                       {
-                               hlslVSSetParameter3f(D3DVSREGISTER_LightDir, t->render_modellight_lightdir[0], t->render_modellight_lightdir[1], t->render_modellight_lightdir[2]);
-                       }
-               }
-               Matrix4x4_ToArrayFloatGL(&t->currenttexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_TexMatrix, m16f);
-               Matrix4x4_ToArrayFloatGL(&t->currentbackgroundtexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_BackgroundTexMatrix, m16f);
-               Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ShadowMapMatrix, m16f);
-               hlslVSSetParameter3f(D3DVSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
-               hlslVSSetParameter4f(D3DVSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
-
+       case RENDERPATH_GL32:
+       case RENDERPATH_GLES2:
+               RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_ALLOWMULTIDRAW, texturenumsurfaces, texturesurfacelist);
+               RSurf_UploadBuffersForBatch();
+               // this has to be after RSurf_PrepareVerticesForBatch
+               if (rsurface.batchskeletaltransform3x4buffer)
+                       permutation |= SHADERPERMUTATION_SKELETAL;
+               R_SetupShader_SetPermutationGLSL(mode, permutation);
+#ifndef USE_GLES2 /* FIXME: GLES3 only */
+               if (r_glsl_permutation->ubiloc_Skeletal_Transform12_UniformBlock >= 0 && rsurface.batchskeletaltransform3x4buffer) qglBindBufferRange(GL_UNIFORM_BUFFER, r_glsl_permutation->ubibind_Skeletal_Transform12_UniformBlock, rsurface.batchskeletaltransform3x4buffer->bufferobject, rsurface.batchskeletaltransform3x4offset, rsurface.batchskeletaltransform3x4size);
+#endif
+               if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);}
                if (mode == SHADERMODE_LIGHTSOURCE)
                {
-                       hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
-                       hlslPSSetParameter3f(D3DPSREGISTER_LightColor, 1, 1, 1); // DEPRECATED
-                       hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, rtlightambient[0], rtlightambient[1], rtlightambient[2]);
-                       hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, rtlightdiffuse[0], rtlightdiffuse[1], rtlightdiffuse[2]);
-                       hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, rtlightspecular[0], rtlightspecular[1], rtlightspecular[2]);
-
+                       if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
+                       if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3f(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
+                       if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3f(r_glsl_permutation->loc_LightColor, 1, 1, 1); // DEPRECATED
+                       if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, rtlightambient[0], rtlightambient[1], rtlightambient[2]);
+                       if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, rtlightdiffuse[0], rtlightdiffuse[1], rtlightdiffuse[2]);
+                       if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, rtlightspecular[0], rtlightspecular[1], rtlightspecular[2]);
+       
                        // additive passes are only darkened by fog, not tinted
-                       hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0);
-                       hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, t->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
+                       if (r_glsl_permutation->loc_FogColor >= 0)
+                               qglUniform3f(r_glsl_permutation->loc_FogColor, 0, 0, 0);
+                       if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1f(r_glsl_permutation->loc_SpecularPower, t->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
                }
                else
                {
-                       hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Diffuse, t->render_rtlight_diffuse[0], t->render_rtlight_diffuse[1], t->render_rtlight_diffuse[2]);
-                       hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, t->render_rtlight_specular[0], t->render_rtlight_specular[1], t->render_rtlight_specular[2]);
                        if (mode == SHADERMODE_FLATCOLOR)
                        {
-                               hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
+                               if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
                        }
                        else if (mode == SHADERMODE_LIGHTDIRECTION)
                        {
-                               hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
-                               hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, t->render_modellight_diffuse[0], t->render_modellight_diffuse[1], t->render_modellight_diffuse[2]);
-                               hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, t->render_modellight_specular[0], t->render_modellight_specular[1], t->render_modellight_specular[2]);
-                               hlslPSSetParameter3f(D3DPSREGISTER_LightColor, 1, 1, 1); // DEPRECATED
-                               hlslPSSetParameter3f(D3DPSREGISTER_LightDir, t->render_modellight_lightdir[0], t->render_modellight_lightdir[1], t->render_modellight_lightdir[2]);
+                               if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
+                               if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, t->render_modellight_diffuse[0], t->render_modellight_diffuse[1], t->render_modellight_diffuse[2]);
+                               if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, t->render_modellight_specular[0], t->render_modellight_specular[1], t->render_modellight_specular[2]);
+                               if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Diffuse, t->render_rtlight_diffuse[0], t->render_rtlight_diffuse[1], t->render_rtlight_diffuse[2]);
+                               if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Specular, t->render_rtlight_specular[0], t->render_rtlight_specular[1], t->render_rtlight_specular[2]);
+                               if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3f(r_glsl_permutation->loc_LightColor, 1, 1, 1); // DEPRECATED
+                               if (r_glsl_permutation->loc_LightDir >= 0) qglUniform3f(r_glsl_permutation->loc_LightDir, t->render_modellight_lightdir[0], t->render_modellight_lightdir[1], t->render_modellight_lightdir[2]);
                        }
                        else
                        {
-                               hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, t->render_lightmap_ambient[0], t->render_lightmap_ambient[1], t->render_lightmap_ambient[2]);
-                               hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, t->render_lightmap_diffuse[0], t->render_lightmap_diffuse[1], t->render_lightmap_diffuse[2]);
-                               hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, t->render_lightmap_specular[0], t->render_lightmap_specular[1], t->render_lightmap_specular[2]);
-                       }
-                       // additive passes are only darkened by fog, not tinted
-                       if(blendfuncflags & BLENDFUNC_ALLOWS_FOG_HACK0)
-                               hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0);
-                       else
-                               hlslPSSetParameter3f(D3DPSREGISTER_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
-                       hlslPSSetParameter4f(D3DPSREGISTER_DistortScaleRefractReflect, r_water_refractdistort.value * t->refractfactor, r_water_refractdistort.value * t->refractfactor, r_water_reflectdistort.value * t->reflectfactor, r_water_reflectdistort.value * t->reflectfactor);
-                       hlslPSSetParameter4f(D3DPSREGISTER_ScreenScaleRefractReflect, r_fb.water.screenscale[0], r_fb.water.screenscale[1], r_fb.water.screenscale[0], r_fb.water.screenscale[1]);
-                       hlslPSSetParameter4f(D3DPSREGISTER_ScreenCenterRefractReflect, r_fb.water.screencenter[0], r_fb.water.screencenter[1], r_fb.water.screencenter[0], r_fb.water.screencenter[1]);
-                       hlslPSSetParameter4f(D3DPSREGISTER_RefractColor, t->refractcolor4f[0], t->refractcolor4f[1], t->refractcolor4f[2], t->refractcolor4f[3] * t->currentalpha);
-                       hlslPSSetParameter4f(D3DPSREGISTER_ReflectColor, t->reflectcolor4f[0], t->reflectcolor4f[1], t->reflectcolor4f[2], t->reflectcolor4f[3] * t->currentalpha);
-                       hlslPSSetParameter1f(D3DPSREGISTER_ReflectFactor, t->reflectmax - t->reflectmin);
-                       hlslPSSetParameter1f(D3DPSREGISTER_ReflectOffset, t->reflectmin);
-                       hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, (t->specularpower - 1.0f) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
-                       if (mode == SHADERMODE_WATER)
-                               hlslPSSetParameter2f(D3DPSREGISTER_NormalmapScrollBlend, t->r_water_waterscroll[0], t->r_water_waterscroll[1]);
-               }
-               if (permutation & SHADERPERMUTATION_SHADOWMAPORTHO)
-               {
-                       hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_modelshadowmap_texturescale[0], r_shadow_modelshadowmap_texturescale[1], r_shadow_modelshadowmap_texturescale[2], r_shadow_modelshadowmap_texturescale[3]);
-                       hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_modelshadowmap_parameters[0], r_shadow_modelshadowmap_parameters[1], r_shadow_modelshadowmap_parameters[2], r_shadow_modelshadowmap_parameters[3]);
-               }
-               else
-               {
-                       hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_lightshadowmap_texturescale[0], r_shadow_lightshadowmap_texturescale[1], r_shadow_lightshadowmap_texturescale[2], r_shadow_lightshadowmap_texturescale[3]);
-                       hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_lightshadowmap_parameters[0], r_shadow_lightshadowmap_parameters[1], r_shadow_lightshadowmap_parameters[2], r_shadow_lightshadowmap_parameters[3]);
-               }
-               hlslPSSetParameter3f(D3DPSREGISTER_Color_Glow, t->render_glowmod[0], t->render_glowmod[1], t->render_glowmod[2]);
-               hlslPSSetParameter1f(D3DPSREGISTER_Alpha, t->currentalpha * ((t->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay) ? t->r_water_wateralpha : 1));
-               hlslPSSetParameter3f(D3DPSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
-               if (t->pantstexture)
-                       hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, t->render_colormap_pants[0], t->render_colormap_pants[1], t->render_colormap_pants[2]);
-               else
-                       hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, 0, 0, 0);
-               if (t->shirttexture)
-                       hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, t->render_colormap_shirt[0], t->render_colormap_shirt[1], t->render_colormap_shirt[2]);
-               else
-                       hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, 0, 0, 0);
-               hlslPSSetParameter4f(D3DPSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
-               hlslPSSetParameter1f(D3DPSREGISTER_FogPlaneViewDist, rsurface.fogplaneviewdist);
-               hlslPSSetParameter1f(D3DPSREGISTER_FogRangeRecip, rsurface.fograngerecip);
-               hlslPSSetParameter1f(D3DPSREGISTER_FogHeightFade, rsurface.fogheightfade);
-               hlslPSSetParameter4f(D3DPSREGISTER_OffsetMapping_ScaleSteps,
-                               r_glsl_offsetmapping_scale.value*t->offsetscale,
-                               max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
-                               1.0 / max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
-                               max(1, r_glsl_offsetmapping_reliefmapping_refinesteps.integer)
-                       );
-               hlslPSSetParameter1f(D3DPSREGISTER_OffsetMapping_LodDistance, r_glsl_offsetmapping_lod_distance.integer * r_refdef.view.quality);
-               hlslPSSetParameter1f(D3DPSREGISTER_OffsetMapping_Bias, t->offsetbias);
-               hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
-               hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
-
-               R_Mesh_TexBind(GL20TU_NORMAL            , t->nmaptexture                       );
-               R_Mesh_TexBind(GL20TU_COLOR             , t->basetexture                       );
-               R_Mesh_TexBind(GL20TU_GLOSS             , t->glosstexture                      );
-               R_Mesh_TexBind(GL20TU_GLOW              , t->glowtexture                       );
-               if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  , t->backgroundnmaptexture             );
-               if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   , t->backgroundbasetexture             );
-               if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   , t->backgroundglosstexture            );
-               if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    , t->backgroundglowtexture             );
-               if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_PANTS             , t->pantstexture                      );
-               if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_SHIRT             , t->shirttexture                      );
-               if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTMASK       , t->reflectmasktexture                );
-               if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTCUBE       , t->reflectcubetexture ? t->reflectcubetexture : r_texture_whitecube);
-               if (permutation & SHADERPERMUTATION_FOGHEIGHTTEXTURE) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE  , r_texture_fogheighttexture                          );
-               if (permutation & (SHADERPERMUTATION_FOGINSIDE | SHADERPERMUTATION_FOGOUTSIDE)) R_Mesh_TexBind(GL20TU_FOGMASK           , r_texture_fogattenuation                            );
-               R_Mesh_TexBind(GL20TU_LIGHTMAP          , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
-               R_Mesh_TexBind(GL20TU_DELUXEMAP         , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
-               if (rsurface.rtlight                                  ) R_Mesh_TexBind(GL20TU_ATTENUATION       , r_shadow_attenuationgradienttexture                 );
-               if (rsurfacepass == RSURFPASS_BACKGROUND)
-               {
-                       R_Mesh_TexBind(GL20TU_REFRACTION        , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
-                       if(mode == SHADERMODE_GENERIC) R_Mesh_TexBind(GL20TU_FIRST             , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
-                       R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
-               }
-               else
-               {
-                       if (permutation & SHADERPERMUTATION_REFLECTION        ) R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
-               }
-//             if (rsurfacepass == RSURFPASS_DEFERREDLIGHT           ) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP   , r_shadow_prepassgeometrynormalmaptexture            );
-               if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP  ) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE     , r_shadow_prepasslightingdiffusetexture              );
-               if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP  ) R_Mesh_TexBind(GL20TU_SCREENSPECULAR    , r_shadow_prepasslightingspeculartexture             );
-               if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
-               {
-                       R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2ddepthtexture);
-                       if (rsurface.rtlight)
-                       {
-                               if (permutation & SHADERPERMUTATION_CUBEFILTER        ) R_Mesh_TexBind(GL20TU_CUBE              , rsurface.rtlight->currentcubemap                    );
-                               if (permutation & SHADERPERMUTATION_SHADOWMAPVSDCT    ) R_Mesh_TexBind(GL20TU_CUBEPROJECTION    , r_shadow_shadowmapvsdcttexture                      );
-                       }
-               }
-#endif
-               break;
-       case RENDERPATH_D3D10:
-               Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_D3D11:
-               Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_GL20:
-       case RENDERPATH_GLES2:
-               if (!vid.useinterleavedarrays)
-               {
-                       RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_ALLOWMULTIDRAW, texturenumsurfaces, texturesurfacelist);
-                       R_Mesh_VertexPointer(     3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
-                       R_Mesh_ColorPointer(      4, GL_FLOAT, sizeof(float[4]), rsurface.batchlightmapcolor4f, rsurface.batchlightmapcolor4f_vertexbuffer, rsurface.batchlightmapcolor4f_bufferoffset);
-                       R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
-                       R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset);
-                       R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset);
-                       R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset);
-                       R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
-                       R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
-                       R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE | 0x80000000, sizeof(unsigned char[4]), rsurface.batchskeletalindex4ub, rsurface.batchskeletalindex4ub_vertexbuffer, rsurface.batchskeletalindex4ub_bufferoffset);
-                       R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), rsurface.batchskeletalweight4ub, rsurface.batchskeletalweight4ub_vertexbuffer, rsurface.batchskeletalweight4ub_bufferoffset);
-               }
-               else
-               {
-                       RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0) | (rsurface.entityskeletaltransform3x4 ? BATCHNEED_VERTEXMESH_SKELETAL : 0) | BATCHNEED_ALLOWMULTIDRAW, texturenumsurfaces, texturesurfacelist);
-                       R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmesh_vertexbuffer, rsurface.batchvertexmesh_bufferoffset);
-               }
-               // this has to be after RSurf_PrepareVerticesForBatch
-               if (rsurface.batchskeletaltransform3x4buffer)
-                       permutation |= SHADERPERMUTATION_SKELETAL;
-               R_SetupShader_SetPermutationGLSL(mode, permutation);
-#ifndef USE_GLES2 /* FIXME: GLES3 only */
-               if (r_glsl_permutation->ubiloc_Skeletal_Transform12_UniformBlock >= 0 && rsurface.batchskeletaltransform3x4buffer) qglBindBufferRange(GL_UNIFORM_BUFFER, r_glsl_permutation->ubibind_Skeletal_Transform12_UniformBlock, rsurface.batchskeletaltransform3x4buffer->bufferobject, rsurface.batchskeletaltransform3x4offset, rsurface.batchskeletaltransform3x4size);
-#endif
-               if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);}
-               if (mode == SHADERMODE_LIGHTSOURCE)
-               {
-                       if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
-                       if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3f(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
-                       if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3f(r_glsl_permutation->loc_LightColor, 1, 1, 1); // DEPRECATED
-                       if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, rtlightambient[0], rtlightambient[1], rtlightambient[2]);
-                       if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, rtlightdiffuse[0], rtlightdiffuse[1], rtlightdiffuse[2]);
-                       if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, rtlightspecular[0], rtlightspecular[1], rtlightspecular[2]);
-       
-                       // additive passes are only darkened by fog, not tinted
-                       if (r_glsl_permutation->loc_FogColor >= 0)
-                               qglUniform3f(r_glsl_permutation->loc_FogColor, 0, 0, 0);
-                       if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1f(r_glsl_permutation->loc_SpecularPower, t->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
-               }
-               else
-               {
-                       if (mode == SHADERMODE_FLATCOLOR)
-                       {
-                               if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
-                       }
-                       else if (mode == SHADERMODE_LIGHTDIRECTION)
-                       {
-                               if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
-                               if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, t->render_modellight_diffuse[0], t->render_modellight_diffuse[1], t->render_modellight_diffuse[2]);
-                               if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, t->render_modellight_specular[0], t->render_modellight_specular[1], t->render_modellight_specular[2]);
-                               if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Diffuse, t->render_rtlight_diffuse[0], t->render_rtlight_diffuse[1], t->render_rtlight_diffuse[2]);
-                               if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Specular, t->render_rtlight_specular[0], t->render_rtlight_specular[1], t->render_rtlight_specular[2]);
-                               if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3f(r_glsl_permutation->loc_LightColor, 1, 1, 1); // DEPRECATED
-                               if (r_glsl_permutation->loc_LightDir >= 0) qglUniform3f(r_glsl_permutation->loc_LightDir, t->render_modellight_lightdir[0], t->render_modellight_lightdir[1], t->render_modellight_lightdir[2]);
-                       }
-                       else
-                       {
-                               if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_lightmap_ambient[0], t->render_lightmap_ambient[1], t->render_lightmap_ambient[2]);
-                               if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, t->render_lightmap_diffuse[0], t->render_lightmap_diffuse[1], t->render_lightmap_diffuse[2]);
-                               if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, t->render_lightmap_specular[0], t->render_lightmap_specular[1], t->render_lightmap_specular[2]);
-                               if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Diffuse, t->render_rtlight_diffuse[0], t->render_rtlight_diffuse[1], t->render_rtlight_diffuse[2]);
-                               if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Specular, t->render_rtlight_specular[0], t->render_rtlight_specular[1], t->render_rtlight_specular[2]);
+                               if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_lightmap_ambient[0], t->render_lightmap_ambient[1], t->render_lightmap_ambient[2]);
+                               if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, t->render_lightmap_diffuse[0], t->render_lightmap_diffuse[1], t->render_lightmap_diffuse[2]);
+                               if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, t->render_lightmap_specular[0], t->render_lightmap_specular[1], t->render_lightmap_specular[2]);
+                               if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Diffuse, t->render_rtlight_diffuse[0], t->render_rtlight_diffuse[1], t->render_rtlight_diffuse[2]);
+                               if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Specular, t->render_rtlight_specular[0], t->render_rtlight_specular[1], t->render_rtlight_specular[2]);
                        }
                        // additive passes are only darkened by fog, not tinted
                        if (r_glsl_permutation->loc_FogColor >= 0)
@@ -2791,13 +2001,13 @@ void R_SetupShader_Surface(const float rtlightambient[3], const float rtlightdif
                if (r_glsl_permutation->tex_Texture_Attenuation     >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Attenuation      , r_shadow_attenuationgradienttexture                 );
                if (rsurfacepass == RSURFPASS_BACKGROUND)
                {
-                       if (r_glsl_permutation->tex_Texture_Refraction  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Refraction        , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
-                       if (r_glsl_permutation->tex_Texture_First       >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First             , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
-                       if (r_glsl_permutation->tex_Texture_Reflection  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Reflection        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
+                       if (r_glsl_permutation->tex_Texture_Refraction  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Refraction        , waterplane->rt_refraction ? waterplane->rt_refraction->colortexture[0] : r_texture_black);
+                       if (r_glsl_permutation->tex_Texture_First       >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First             , waterplane->rt_camera ? waterplane->rt_camera->colortexture[0] : r_texture_black);
+                       if (r_glsl_permutation->tex_Texture_Reflection  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Reflection        , waterplane->rt_reflection ? waterplane->rt_reflection->colortexture[0] : r_texture_black);
                }
                else
                {
-                       if (r_glsl_permutation->tex_Texture_Reflection >= 0 && waterplane) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Reflection        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
+                       if (r_glsl_permutation->tex_Texture_Reflection >= 0 && waterplane) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Reflection        , waterplane->rt_reflection ? waterplane->rt_reflection->colortexture[0] : r_texture_black);
                }
                if (r_glsl_permutation->tex_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenNormalMap   , r_shadow_prepassgeometrynormalmaptexture            );
                if (r_glsl_permutation->tex_Texture_ScreenDiffuse   >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenDiffuse     , r_shadow_prepasslightingdiffusetexture              );
@@ -2814,151 +2024,6 @@ void R_SetupShader_Surface(const float rtlightambient[3], const float rtlightdif
                if (r_glsl_permutation->tex_Texture_BounceGrid  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_BounceGrid, r_shadow_bouncegrid_state.texture);
                CHECKGLERROR
                break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               break;
-       case RENDERPATH_SOFT:
-               RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_ALLOWMULTIDRAW, texturenumsurfaces, texturesurfacelist);
-               R_Mesh_PrepareVertices_Mesh_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchsvector3f, rsurface.batchtvector3f, rsurface.batchnormal3f, rsurface.batchlightmapcolor4f, rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordlightmap2f);
-               R_SetupShader_SetPermutationSoft(mode, permutation);
-               {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelToReflectCubeM1, 1, false, m16f);}
-               if (mode == SHADERMODE_LIGHTSOURCE)
-               {
-                       {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelToLightM1, 1, false, m16f);}
-                       DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
-                       DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_LightColor, 1, 1, 1); // DEPRECATED
-                       DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Ambient, rtlightambient[0], rtlightambient[1], rtlightambient[2]);
-                       DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Diffuse, rtlightdiffuse[0], rtlightdiffuse[1], rtlightdiffuse[2]);
-                       DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Specular, rtlightspecular[0], rtlightspecular[1], rtlightspecular[2]);
-       
-                       // additive passes are only darkened by fog, not tinted
-                       DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_FogColor, 0, 0, 0);
-                       DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_SpecularPower, t->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
-               }
-               else
-               {
-                       if (mode == SHADERMODE_FLATCOLOR)
-                       {
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
-                       }
-                       else if (mode == SHADERMODE_LIGHTDIRECTION)
-                       {
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Diffuse, t->render_modellight_diffuse[0], t->render_modellight_diffuse[1], t->render_modellight_diffuse[2]);
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Specular, t->render_modellight_specular[0], t->render_modellight_specular[1], t->render_modellight_specular[2]);
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_LightColor, 1, 1, 1); // DEPRECATED
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_LightDir, t->render_modellight_lightdir[0], t->render_modellight_lightdir[1], t->render_modellight_lightdir[2]);
-                       }
-                       else
-                       {
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Ambient, t->render_lightmap_ambient[0], t->render_lightmap_ambient[1], t->render_lightmap_ambient[2]);
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Diffuse, t->render_lightmap_diffuse[0], t->render_lightmap_diffuse[1], t->render_lightmap_diffuse[2]);
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Specular, t->render_lightmap_specular[0], t->render_lightmap_specular[1], t->render_lightmap_specular[2]);
-                       }
-                       DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_DeferredMod_Diffuse, t->render_rtlight_diffuse[0], t->render_rtlight_diffuse[1], t->render_rtlight_diffuse[2]);
-                       DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_DeferredMod_Specular, t->render_rtlight_specular[0], t->render_rtlight_specular[1], t->render_rtlight_specular[2]);
-                       // additive passes are only darkened by fog, not tinted
-                       if(blendfuncflags & BLENDFUNC_ALLOWS_FOG_HACK0)
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_FogColor, 0, 0, 0);
-                       else
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_DistortScaleRefractReflect, r_water_refractdistort.value * t->refractfactor, r_water_refractdistort.value * t->refractfactor, r_water_reflectdistort.value * t->reflectfactor, r_water_reflectdistort.value * t->reflectfactor);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ScreenScaleRefractReflect, r_fb.water.screenscale[0], r_fb.water.screenscale[1], r_fb.water.screenscale[0], r_fb.water.screenscale[1]);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ScreenCenterRefractReflect, r_fb.water.screencenter[0], r_fb.water.screencenter[1], r_fb.water.screencenter[0], r_fb.water.screencenter[1]);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_RefractColor, t->refractcolor4f[0], t->refractcolor4f[1], t->refractcolor4f[2], t->refractcolor4f[3] * t->currentalpha);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ReflectColor, t->reflectcolor4f[0], t->reflectcolor4f[1], t->reflectcolor4f[2], t->reflectcolor4f[3] * t->currentalpha);
-                       DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_ReflectFactor, t->reflectmax - t->reflectmin);
-                       DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_ReflectOffset, t->reflectmin);
-                       DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_SpecularPower, t->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
-                       DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_NormalmapScrollBlend, t->r_water_waterscroll[0], t->r_water_waterscroll[1]);
-               }
-               {Matrix4x4_ToArrayFloatGL(&t->currenttexmatrix, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_TexMatrixM1, 1, false, m16f);}
-               {Matrix4x4_ToArrayFloatGL(&t->currentbackgroundtexmatrix, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_BackgroundTexMatrixM1, 1, false, m16f);}
-               {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ShadowMapMatrixM1, 1, false, m16f);}
-               if (permutation & SHADERPERMUTATION_SHADOWMAPORTHO)
-               {
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ShadowMap_TextureScale, r_shadow_modelshadowmap_texturescale[0], r_shadow_modelshadowmap_texturescale[1], r_shadow_modelshadowmap_texturescale[2], r_shadow_modelshadowmap_texturescale[3]);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ShadowMap_Parameters, r_shadow_modelshadowmap_parameters[0], r_shadow_modelshadowmap_parameters[1], r_shadow_modelshadowmap_parameters[2], r_shadow_modelshadowmap_parameters[3]);
-               }
-               else
-               {
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ShadowMap_TextureScale, r_shadow_lightshadowmap_texturescale[0], r_shadow_lightshadowmap_texturescale[1], r_shadow_lightshadowmap_texturescale[2], r_shadow_lightshadowmap_texturescale[3]);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ShadowMap_Parameters, r_shadow_lightshadowmap_parameters[0], r_shadow_lightshadowmap_parameters[1], r_shadow_lightshadowmap_parameters[2], r_shadow_lightshadowmap_parameters[3]);
-               }
-
-               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Glow, t->render_glowmod[0], t->render_glowmod[1], t->render_glowmod[2]);
-               DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_Alpha, t->currentalpha * ((t->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay) ? t->r_water_wateralpha : 1));
-               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
-               if (DPSOFTRAST_UNIFORM_Color_Pants >= 0)
-               {
-                       if (t->pantstexture)
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Pants, t->render_colormap_pants[0], t->render_colormap_pants[1], t->render_colormap_pants[2]);
-                       else
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Pants, 0, 0, 0);
-               }
-               if (DPSOFTRAST_UNIFORM_Color_Shirt >= 0)
-               {
-                       if (t->shirttexture)
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Shirt, t->render_colormap_shirt[0], t->render_colormap_shirt[1], t->render_colormap_shirt[2]);
-                       else
-                               DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Shirt, 0, 0, 0);
-               }
-               DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
-               DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_FogPlaneViewDist, rsurface.fogplaneviewdist);
-               DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_FogRangeRecip, rsurface.fograngerecip);
-               DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_FogHeightFade, rsurface.fogheightfade);
-               DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_OffsetMapping_ScaleSteps,
-                               r_glsl_offsetmapping_scale.value*t->offsetscale,
-                               max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
-                               1.0 / max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
-                               max(1, r_glsl_offsetmapping_reliefmapping_refinesteps.integer)
-                       );
-               DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_OffsetMapping_LodDistance, r_glsl_offsetmapping_lod_distance.integer * r_refdef.view.quality);
-               DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_OffsetMapping_Bias, t->offsetbias);
-               DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
-               DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
-
-               R_Mesh_TexBind(GL20TU_NORMAL            , t->nmaptexture                       );
-               R_Mesh_TexBind(GL20TU_COLOR             , t->basetexture                       );
-               R_Mesh_TexBind(GL20TU_GLOSS             , t->glosstexture                      );
-               R_Mesh_TexBind(GL20TU_GLOW              , t->glowtexture                       );
-               if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL  , t->backgroundnmaptexture             );
-               if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR   , t->backgroundbasetexture             );
-               if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS   , t->backgroundglosstexture            );
-               if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW    , t->backgroundglowtexture             );
-               if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_PANTS             , t->pantstexture                      );
-               if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_SHIRT             , t->shirttexture                      );
-               if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTMASK       , t->reflectmasktexture                );
-               if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTCUBE       , t->reflectcubetexture ? t->reflectcubetexture : r_texture_whitecube);
-               if (permutation & SHADERPERMUTATION_FOGHEIGHTTEXTURE) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE  , r_texture_fogheighttexture                          );
-               if (permutation & (SHADERPERMUTATION_FOGINSIDE | SHADERPERMUTATION_FOGOUTSIDE)) R_Mesh_TexBind(GL20TU_FOGMASK           , r_texture_fogattenuation                            );
-               R_Mesh_TexBind(GL20TU_LIGHTMAP          , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
-               R_Mesh_TexBind(GL20TU_DELUXEMAP         , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
-               if (rsurface.rtlight                                  ) R_Mesh_TexBind(GL20TU_ATTENUATION       , r_shadow_attenuationgradienttexture                 );
-               if (rsurfacepass == RSURFPASS_BACKGROUND)
-               {
-                       R_Mesh_TexBind(GL20TU_REFRACTION        , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
-                       if(mode == SHADERMODE_GENERIC) R_Mesh_TexBind(GL20TU_FIRST             , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
-                       R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
-               }
-               else
-               {
-                       if (permutation & SHADERPERMUTATION_REFLECTION        ) R_Mesh_TexBind(GL20TU_REFLECTION        , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
-               }
-//             if (rsurfacepass == RSURFPASS_DEFERREDLIGHT           ) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP   , r_shadow_prepassgeometrynormalmaptexture            );
-               if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP  ) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE     , r_shadow_prepasslightingdiffusetexture              );
-               if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP  ) R_Mesh_TexBind(GL20TU_SCREENSPECULAR    , r_shadow_prepasslightingspeculartexture             );
-               if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
-               {
-                       R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2ddepthtexture);
-                       if (rsurface.rtlight)
-                       {
-                               if (permutation & SHADERPERMUTATION_CUBEFILTER        ) R_Mesh_TexBind(GL20TU_CUBE              , rsurface.rtlight->currentcubemap                    );
-                               if (permutation & SHADERPERMUTATION_SHADOWMAPVSDCT    ) R_Mesh_TexBind(GL20TU_CUBEPROJECTION    , r_shadow_shadowmapvsdcttexture                      );
-                       }
-               }
-               break;
        }
 }
 
@@ -3005,34 +2070,7 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
        Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
        switch(vid.renderpath)
        {
-       case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-               R_SetupShader_SetPermutationHLSL(mode, permutation);
-               hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
-               hlslPSSetParameter16f(D3DPSREGISTER_ViewToLight, viewtolight16f);
-               hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Ambient , lightcolorbase[0] * ambientscale , lightcolorbase[1] * ambientscale , lightcolorbase[2] * ambientscale );
-               hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale , lightcolorbase[1] * diffusescale , lightcolorbase[2] * diffusescale );
-               hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Specular, lightcolorbase[0] * specularscale, lightcolorbase[1] * specularscale, lightcolorbase[2] * specularscale);
-               hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_lightshadowmap_texturescale[0], r_shadow_lightshadowmap_texturescale[1], r_shadow_lightshadowmap_texturescale[2], r_shadow_lightshadowmap_texturescale[3]);
-               hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_lightshadowmap_parameters[0], r_shadow_lightshadowmap_parameters[1], r_shadow_lightshadowmap_parameters[2], r_shadow_lightshadowmap_parameters[3]);
-               hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
-               hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
-               hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
-
-               R_Mesh_TexBind(GL20TU_ATTENUATION        , r_shadow_attenuationgradienttexture                 );
-               R_Mesh_TexBind(GL20TU_SCREENNORMALMAP    , r_shadow_prepassgeometrynormalmaptexture            );
-               R_Mesh_TexBind(GL20TU_CUBE               , rsurface.rtlight->currentcubemap                    );
-               R_Mesh_TexBind(GL20TU_SHADOWMAP2D        , r_shadow_shadowmap2ddepthtexture                    );
-               R_Mesh_TexBind(GL20TU_CUBEPROJECTION     , r_shadow_shadowmapvsdcttexture                      );
-#endif
-               break;
-       case RENDERPATH_D3D10:
-               Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_D3D11:
-               Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_GL20:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
                R_SetupShader_SetPermutationGLSL(mode, permutation);
                if (r_glsl_permutation->loc_LightPosition             >= 0) qglUniform3f(       r_glsl_permutation->loc_LightPosition            , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
@@ -3052,29 +2090,6 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
                if (r_glsl_permutation->tex_Texture_ShadowMap2D       >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ShadowMap2D        , r_shadow_shadowmap2ddepthtexture                    );
                if (r_glsl_permutation->tex_Texture_CubeProjection    >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_CubeProjection     , r_shadow_shadowmapvsdcttexture                      );
                break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               break;
-       case RENDERPATH_SOFT:
-               R_SetupShader_SetPermutationGLSL(mode, permutation);
-               DPSOFTRAST_Uniform3f(       DPSOFTRAST_UNIFORM_LightPosition            , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
-               DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ViewToLightM1            , 1, false, viewtolight16f);
-               DPSOFTRAST_Uniform3f(       DPSOFTRAST_UNIFORM_DeferredColor_Ambient    , lightcolorbase[0] * ambientscale , lightcolorbase[1] * ambientscale , lightcolorbase[2] * ambientscale );
-               DPSOFTRAST_Uniform3f(       DPSOFTRAST_UNIFORM_DeferredColor_Diffuse    , lightcolorbase[0] * diffusescale , lightcolorbase[1] * diffusescale , lightcolorbase[2] * diffusescale );
-               DPSOFTRAST_Uniform3f(       DPSOFTRAST_UNIFORM_DeferredColor_Specular   , lightcolorbase[0] * specularscale, lightcolorbase[1] * specularscale, lightcolorbase[2] * specularscale);
-               DPSOFTRAST_Uniform4f(       DPSOFTRAST_UNIFORM_ShadowMap_TextureScale   , r_shadow_lightshadowmap_texturescale[0], r_shadow_lightshadowmap_texturescale[1], r_shadow_lightshadowmap_texturescale[2], r_shadow_lightshadowmap_texturescale[3]);
-               DPSOFTRAST_Uniform4f(       DPSOFTRAST_UNIFORM_ShadowMap_Parameters     , r_shadow_lightshadowmap_parameters[0], r_shadow_lightshadowmap_parameters[1], r_shadow_lightshadowmap_parameters[2], r_shadow_lightshadowmap_parameters[3]);
-               DPSOFTRAST_Uniform1f(       DPSOFTRAST_UNIFORM_SpecularPower            , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
-               DPSOFTRAST_Uniform2f(       DPSOFTRAST_UNIFORM_ScreenToDepth            , r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
-               DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
-
-               R_Mesh_TexBind(GL20TU_ATTENUATION        , r_shadow_attenuationgradienttexture                 );
-               R_Mesh_TexBind(GL20TU_SCREENNORMALMAP    , r_shadow_prepassgeometrynormalmaptexture            );
-               R_Mesh_TexBind(GL20TU_CUBE               , rsurface.rtlight->currentcubemap                    );
-               R_Mesh_TexBind(GL20TU_SHADOWMAP2D        , r_shadow_shadowmap2ddepthtexture                    );
-               R_Mesh_TexBind(GL20TU_CUBEPROJECTION     , r_shadow_shadowmapvsdcttexture                      );
-               break;
        }
 }
 
@@ -3107,6 +2122,8 @@ void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
 
 void R_SkinFrame_PurgeSkinFrame(skinframe_t *s)
 {
+       if (s == NULL)
+               return;
        if (s->merged == s->base)
                s->merged = NULL;
        R_PurgeTexture(s->stain); s->stain = NULL;
@@ -3162,6 +2179,7 @@ skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
 {
        skinframe_t *item;
+       int compareflags = textureflags & TEXF_IMPORTANTBITS;
        int hashindex;
        char basename[MAX_QPATH];
 
@@ -3169,7 +2187,11 @@ skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewid
 
        hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
        for (item = r_skinframe.hash[hashindex];item;item = item->next)
-               if (!strcmp(item->basename, basename) && (comparecrc < 0 || (item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)))
+               if (!strcmp(item->basename, basename) &&
+                       item->textureflags == compareflags &&
+                       item->comparewidth == comparewidth &&
+                       item->compareheight == compareheight &&
+                       item->comparecrc == comparecrc)
                        break;
 
        if (!item)
@@ -3179,7 +2201,7 @@ skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewid
                item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
                memset(item, 0, sizeof(*item));
                strlcpy(item->basename, basename, sizeof(item->basename));
-               item->textureflags = textureflags & ~TEXF_FORCE_RELOAD;
+               item->textureflags = compareflags;
                item->comparewidth = comparewidth;
                item->compareheight = compareheight;
                item->comparecrc = comparecrc;
@@ -3187,11 +2209,7 @@ skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewid
                r_skinframe.hash[hashindex] = item;
        }
        else if (textureflags & TEXF_FORCE_RELOAD)
-       {
-               if (!add)
-                       return NULL;
                R_SkinFrame_PurgeSkinFrame(item);
-       }
 
        R_SkinFrame_MarkUsed(item);
        return item;
@@ -3232,16 +2250,31 @@ skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewid
                skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \
        }
 
-extern cvar_t gl_picmip;
 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain, qboolean fallbacknotexture)
 {
+       skinframe_t *skinframe;
+
+       if (cls.state == ca_dedicated)
+               return NULL;
+
+       // return an existing skinframe if already loaded
+       skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
+       if (skinframe && skinframe->base)
+               return skinframe;
+
+       // if the skinframe doesn't exist this will create it
+       return R_SkinFrame_LoadExternal_SkinFrame(skinframe, name, textureflags, complain, fallbacknotexture);
+}
+
+extern cvar_t gl_picmip;
+skinframe_t *R_SkinFrame_LoadExternal_SkinFrame(skinframe_t *skinframe, const char *name, int textureflags, qboolean complain, qboolean fallbacknotexture)
+{
        int j;
        unsigned char *pixels;
        unsigned char *bumppixels;
        unsigned char *basepixels = NULL;
        int basepixels_width = 0;
        int basepixels_height = 0;
-       skinframe_t *skinframe;
        rtexture_t *ddsbase = NULL;
        qboolean ddshasalpha = false;
        float ddsavgcolor[4];
@@ -3254,13 +2287,6 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
        if (cls.state == ca_dedicated)
                return NULL;
 
-       // return an existing skinframe if already loaded
-       // if loading of the first image fails, don't make a new skinframe as it
-       // would cause all future lookups of this to be missing
-       skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
-       if (skinframe && skinframe->base)
-               return skinframe;
-
        Image_StripImageExtension(name, basename, sizeof(basename));
 
        // check for DDS texture file first
@@ -3337,9 +2363,9 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
                R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
 #ifndef USE_GLES2
                //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
-               if (r_savedds && qglGetCompressedTexImageARB && skinframe->base)
+               if (r_savedds && skinframe->base)
                        R_SaveTextureDDSFile(skinframe->base, va(vabuf, sizeof(vabuf), "dds/%s.dds", skinframe->basename), r_texture_dds_save.integer < 2, skinframe->hasalpha);
-               if (r_savedds && qglGetCompressedTexImageARB && skinframe->fog)
+               if (r_savedds && skinframe->fog)
                        R_SaveTextureDDSFile(skinframe->fog, va(vabuf, sizeof(vabuf), "dds/%s_mask.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
 #endif
        }
@@ -3383,7 +2409,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
                        Mem_Free(pixels);
                }
 #ifndef USE_GLES2
-               if (r_savedds && qglGetCompressedTexImageARB && skinframe->nmap)
+               if (r_savedds && skinframe->nmap)
                        R_SaveTextureDDSFile(skinframe->nmap, va(vabuf, sizeof(vabuf), "dds/%s_norm.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
 #endif
        }
@@ -3395,7 +2421,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
        {
                skinframe->glow = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_glow", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_glow.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
 #ifndef USE_GLES2
-               if (r_savedds && qglGetCompressedTexImageARB && skinframe->glow)
+               if (r_savedds && skinframe->glow)
                        R_SaveTextureDDSFile(skinframe->glow, va(vabuf, sizeof(vabuf), "dds/%s_glow.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
 #endif
                Mem_Free(pixels);pixels = NULL;
@@ -3406,7 +2432,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
        {
                skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_gloss", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (gl_texturecompression_gloss.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
 #ifndef USE_GLES2
-               if (r_savedds && qglGetCompressedTexImageARB && skinframe->gloss)
+               if (r_savedds && skinframe->gloss)
                        R_SaveTextureDDSFile(skinframe->gloss, va(vabuf, sizeof(vabuf), "dds/%s_gloss.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
 #endif
                Mem_Free(pixels);
@@ -3418,7 +2444,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
        {
                skinframe->pants = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_pants", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
 #ifndef USE_GLES2
-               if (r_savedds && qglGetCompressedTexImageARB && skinframe->pants)
+               if (r_savedds && skinframe->pants)
                        R_SaveTextureDDSFile(skinframe->pants, va(vabuf, sizeof(vabuf), "dds/%s_pants.dds", skinframe->basename), r_texture_dds_save.integer < 2, false);
 #endif
                Mem_Free(pixels);
@@ -3430,7 +2456,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
        {
                skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_shirt", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
 #ifndef USE_GLES2
-               if (r_savedds && qglGetCompressedTexImageARB && skinframe->shirt)
+               if (r_savedds && skinframe->shirt)
                        R_SaveTextureDDSFile(skinframe->shirt, va(vabuf, sizeof(vabuf), "dds/%s_shirt.dds", skinframe->basename), r_texture_dds_save.integer < 2, false);
 #endif
                Mem_Free(pixels);
@@ -3442,7 +2468,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
        {
                skinframe->reflect = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_reflect", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_reflectmask.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
 #ifndef USE_GLES2
-               if (r_savedds && qglGetCompressedTexImageARB && skinframe->reflect)
+               if (r_savedds && skinframe->reflect)
                        R_SaveTextureDDSFile(skinframe->reflect, va(vabuf, sizeof(vabuf), "dds/%s_reflect.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
 #endif
                Mem_Free(pixels);
@@ -3455,8 +2481,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole
        return skinframe;
 }
 
-// this is only used by .spr32 sprites, HL .spr files, HL .bsp files
-skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height, qboolean sRGB)
+skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height, int comparewidth, int compareheight, int comparecrc, qboolean sRGB)
 {
        int i;
        skinframe_t *skinframe;
@@ -3466,7 +2491,7 @@ skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, co
                return NULL;
 
        // if already loaded just return it, otherwise make a new skinframe
-       skinframe = R_SkinFrame_Find(name, textureflags, width, height, (textureflags & TEXF_FORCE_RELOAD) ? -1 : skindata ? CRC_Block(skindata, width*height*4) : 0, true);
+       skinframe = R_SkinFrame_Find(name, textureflags, comparewidth, compareheight, comparecrc, true);
        if (skinframe->base)
                return skinframe;
        textureflags &= ~TEXF_FORCE_RELOAD;
@@ -3775,7 +2800,7 @@ skinframe_t *R_SkinFrame_LoadNoTexture(void)
                }
        }
 
-       return R_SkinFrame_LoadInternalBGRA("notexture", TEXF_FORCENEAREST, pix[0][0], 16, 16, false);
+       return R_SkinFrame_LoadInternalBGRA("notexture", TEXF_FORCENEAREST, pix[0][0], 16, 16, 0, 0, 0, false);
 }
 
 skinframe_t *R_SkinFrame_LoadInternalUsingTexture(const char *name, int textureflags, rtexture_t *tex, int width, int height, qboolean sRGB)
@@ -3784,7 +2809,7 @@ skinframe_t *R_SkinFrame_LoadInternalUsingTexture(const char *name, int texturef
        if (cls.state == ca_dedicated)
                return NULL;
        // if already loaded just return it, otherwise make a new skinframe
-       skinframe = R_SkinFrame_Find(name, textureflags, width, height, (textureflags & TEXF_FORCE_RELOAD) ? -1 : 0, true);
+       skinframe = R_SkinFrame_Find(name, textureflags, width, height, 0, true);
        if (skinframe->base)
                return skinframe;
        textureflags &= ~TEXF_FORCE_RELOAD;
@@ -3996,43 +3021,21 @@ static void gl_main_start(void)
        r_uniformbufferalignment = 32;
 
        r_loaddds = r_texture_dds_load.integer != 0;
-       r_savedds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_save.integer;
+       r_savedds = vid.support.ext_texture_compression_s3tc && r_texture_dds_save.integer;
 
        switch(vid.renderpath)
        {
-       case RENDERPATH_GL20:
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_SOFT:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
-               Cvar_SetValueQuick(&r_textureunits, vid.texunits);
+               Cvar_SetValueQuick(&r_textureunits, MAX_TEXTUREUNITS);
                Cvar_SetValueQuick(&gl_combine, 1);
                Cvar_SetValueQuick(&r_glsl, 1);
                r_loadnormalmap = true;
                r_loadgloss = true;
                r_loadfog = false;
 #ifdef GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT
-               if (vid.support.arb_uniform_buffer_object)
-                       qglGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &r_uniformbufferalignment);
+               qglGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &r_uniformbufferalignment);
 #endif
-                       break;
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               Cvar_SetValueQuick(&r_textureunits, vid.texunits);
-               Cvar_SetValueQuick(&gl_combine, 1);
-               Cvar_SetValueQuick(&r_glsl, 0);
-               r_loadnormalmap = false;
-               r_loadgloss = false;
-               r_loadfog = true;
-               break;
-       case RENDERPATH_GL11:
-               Cvar_SetValueQuick(&r_textureunits, vid.texunits);
-               Cvar_SetValueQuick(&gl_combine, 0);
-               Cvar_SetValueQuick(&r_glsl, 0);
-               r_loadnormalmap = false;
-               r_loadgloss = false;
-               r_loadfog = true;
                break;
        }
 
@@ -4058,24 +3061,17 @@ static void gl_main_start(void)
        r_main_texturepool = R_AllocTexturePool();
        R_BuildBlankTextures();
        R_BuildNoTexture();
-       if (vid.support.arb_texture_cube_map)
-       {
-               R_BuildWhiteCube();
-               R_BuildNormalizationCube();
-       }
+       R_BuildWhiteCube();
+       R_BuildNormalizationCube();
        r_texture_fogattenuation = NULL;
        r_texture_fogheighttexture = NULL;
        r_texture_gammaramps = NULL;
        //r_texture_fogintensity = NULL;
        memset(&r_fb, 0, sizeof(r_fb));
+       Mem_ExpandableArray_NewArray(&r_fb.rendertargets, r_main_mempool, sizeof(r_rendertarget_t), 128);
        r_glsl_permutation = NULL;
        memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
        Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256);
-#ifdef SUPPORTD3D
-       r_hlsl_permutation = NULL;
-       memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
-       Mem_ExpandableArray_NewArray(&r_hlsl_permutationarray, r_main_mempool, sizeof(r_hlsl_permutation_t), 256);
-#endif
        memset(&r_svbsp, 0, sizeof (r_svbsp));
 
        memset(r_texture_cubemaps, 0, sizeof(r_texture_cubemaps));
@@ -4107,6 +3103,8 @@ static void gl_main_start(void)
 
 static void gl_main_shutdown(void)
 {
+       R_RenderTarget_FreeUnused(true);
+       Mem_ExpandableArray_FreeArray(&r_fb.rendertargets);
        R_AnimCache_Free();
        R_FrameData_Reset();
        R_BufferData_Reset();
@@ -4115,27 +3113,13 @@ static void gl_main_shutdown(void)
 
        switch(vid.renderpath)
        {
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GL20:
-       case RENDERPATH_GLES1:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
-#if defined(GL_SAMPLES_PASSED_ARB) && !defined(USE_GLES2)
+#if defined(GL_SAMPLES_PASSED) && !defined(USE_GLES2)
                if (r_maxqueries)
-                       qglDeleteQueriesARB(r_maxqueries, r_queries);
+                       qglDeleteQueries(r_maxqueries, r_queries);
 #endif
                break;
-       case RENDERPATH_D3D9:
-               //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_D3D10:
-               Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_D3D11:
-               Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
-       case RENDERPATH_SOFT:
-               break;
        }
 
        r_numqueries = 0;
@@ -4171,11 +3155,6 @@ static void gl_main_shutdown(void)
        r_glsl_permutation = NULL;
        memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
        Mem_ExpandableArray_FreeArray(&r_glsl_permutationarray);
-#ifdef SUPPORTD3D
-       r_hlsl_permutation = NULL;
-       memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
-       Mem_ExpandableArray_FreeArray(&r_hlsl_permutationarray);
-#endif
 }
 
 static void gl_main_newmap(void)
@@ -4257,11 +3236,12 @@ void GL_Main_Init(void)
        Cvar_RegisterVariable(&r_showtris);
        Cvar_RegisterVariable(&r_shownormals);
        Cvar_RegisterVariable(&r_showlighting);
-       Cvar_RegisterVariable(&r_showshadowvolumes);
        Cvar_RegisterVariable(&r_showcollisionbrushes);
        Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
        Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
        Cvar_RegisterVariable(&r_showdisabledepthtest);
+       Cvar_RegisterVariable(&r_showspriteedges);
+       Cvar_RegisterVariable(&r_showparticleedges);
        Cvar_RegisterVariable(&r_drawportals);
        Cvar_RegisterVariable(&r_drawentities);
        Cvar_RegisterVariable(&r_draw2d);
@@ -4271,6 +3251,8 @@ void GL_Main_Init(void)
        Cvar_RegisterVariable(&r_cullentities_trace_samples);
        Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
        Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
+       Cvar_RegisterVariable(&r_cullentities_trace_expand);
+       Cvar_RegisterVariable(&r_cullentities_trace_pad);
        Cvar_RegisterVariable(&r_cullentities_trace_delay);
        Cvar_RegisterVariable(&r_cullentities_trace_eyejitter);
        Cvar_RegisterVariable(&r_sortentities);
@@ -4315,6 +3297,7 @@ void GL_Main_Init(void)
        Cvar_RegisterVariable(&gl_combine);
        Cvar_RegisterVariable(&r_usedepthtextures);
        Cvar_RegisterVariable(&r_viewfbo);
+       Cvar_RegisterVariable(&r_rendertarget_debug);
        Cvar_RegisterVariable(&r_viewscale);
        Cvar_RegisterVariable(&r_viewscale_fpsscaling);
        Cvar_RegisterVariable(&r_viewscale_fpsscaling_min);
@@ -4353,7 +3336,6 @@ void GL_Main_Init(void)
        Cvar_RegisterVariable(&r_water_scissormode);
        Cvar_RegisterVariable(&r_water_lowquality);
        Cvar_RegisterVariable(&r_water_hideplayer);
-       Cvar_RegisterVariable(&r_water_fbo);
 
        Cvar_RegisterVariable(&r_lerpsprites);
        Cvar_RegisterVariable(&r_lerpmodels);
@@ -4421,45 +3403,6 @@ void Render_Init(void)
        Mod_RenderInit();
 }
 
-/*
-===============
-GL_Init
-===============
-*/
-#ifndef USE_GLES2
-extern char *ENGINE_EXTENSIONS;
-void GL_Init (void)
-{
-       gl_renderer = (const char *)qglGetString(GL_RENDERER);
-       gl_vendor = (const char *)qglGetString(GL_VENDOR);
-       gl_version = (const char *)qglGetString(GL_VERSION);
-       gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
-
-       if (!gl_extensions)
-               gl_extensions = "";
-       if (!gl_platformextensions)
-               gl_platformextensions = "";
-
-       Con_Printf("GL_VENDOR: %s\n", gl_vendor);
-       Con_Printf("GL_RENDERER: %s\n", gl_renderer);
-       Con_Printf("GL_VERSION: %s\n", gl_version);
-       Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
-       Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
-
-       VID_CheckExtensions();
-
-       // LordHavoc: report supported extensions
-#ifdef CONFIG_MENU
-       Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
-#else
-       Con_DPrintf("\nQuakeC extensions for server and client: %s\n", vm_sv_extensions );
-#endif
-
-       // clear to black (loading plaque will be seen over this)
-       GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
-}
-#endif
-
 int R_CullBox(const vec3_t mins, const vec3_t maxs)
 {
        int i;
@@ -4864,9 +3807,6 @@ void R_AnimCache_ClearCache(void)
                ent->animcache_tvector3f = NULL;
                ent->animcache_tvector3f_vertexbuffer = NULL;
                ent->animcache_tvector3f_bufferoffset = 0;
-               ent->animcache_vertexmesh = NULL;
-               ent->animcache_vertexmesh_vertexbuffer = NULL;
-               ent->animcache_vertexmesh_bufferoffset = 0;
                ent->animcache_skeletaltransform3x4 = NULL;
                ent->animcache_skeletaltransform3x4buffer = NULL;
                ent->animcache_skeletaltransform3x4offset = 0;
@@ -4874,37 +3814,6 @@ void R_AnimCache_ClearCache(void)
        }
 }
 
-static void R_AnimCache_UpdateEntityMeshBuffers(entity_render_t *ent, int numvertices)
-{
-       int i;
-
-       // check if we need the meshbuffers
-       if (!vid.useinterleavedarrays)
-               return;
-
-       if (!ent->animcache_vertexmesh && ent->animcache_normal3f)
-               ent->animcache_vertexmesh = (r_vertexmesh_t *)R_FrameData_Alloc(sizeof(r_vertexmesh_t)*numvertices);
-       // TODO: upload vertexbuffer?
-       if (ent->animcache_vertexmesh)
-       {
-               r_refdef.stats[r_stat_animcache_vertexmesh_count] += 1;
-               r_refdef.stats[r_stat_animcache_vertexmesh_vertices] += numvertices;
-               r_refdef.stats[r_stat_animcache_vertexmesh_maxvertices] = max(r_refdef.stats[r_stat_animcache_vertexmesh_maxvertices], numvertices);
-               memcpy(ent->animcache_vertexmesh, ent->model->surfmesh.data_vertexmesh, sizeof(r_vertexmesh_t)*numvertices);
-               for (i = 0;i < numvertices;i++)
-                       memcpy(ent->animcache_vertexmesh[i].vertex3f, ent->animcache_vertex3f + 3*i, sizeof(float[3]));
-               if (ent->animcache_svector3f)
-                       for (i = 0;i < numvertices;i++)
-                               memcpy(ent->animcache_vertexmesh[i].svector3f, ent->animcache_svector3f + 3*i, sizeof(float[3]));
-               if (ent->animcache_tvector3f)
-                       for (i = 0;i < numvertices;i++)
-                               memcpy(ent->animcache_vertexmesh[i].tvector3f, ent->animcache_tvector3f + 3*i, sizeof(float[3]));
-               if (ent->animcache_normal3f)
-                       for (i = 0;i < numvertices;i++)
-                               memcpy(ent->animcache_vertexmesh[i].normal3f, ent->animcache_normal3f + 3*i, sizeof(float[3]));
-       }
-}
-
 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
 {
        dp_model_t *model = ent->model;
@@ -4959,7 +3868,6 @@ qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qbool
                                ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
                        }
                        model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
-                       R_AnimCache_UpdateEntityMeshBuffers(ent, model->surfmesh.num_vertices);
                        r_refdef.stats[r_stat_animcache_shade_count] += 1;
                        r_refdef.stats[r_stat_animcache_shade_vertices] += numvertices;
                        r_refdef.stats[r_stat_animcache_shade_maxvertices] = max(r_refdef.stats[r_stat_animcache_shade_maxvertices], numvertices);
@@ -4978,7 +3886,6 @@ qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qbool
                        ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
                }
                model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
-               R_AnimCache_UpdateEntityMeshBuffers(ent, model->surfmesh.num_vertices);
                if (wantnormals || wanttangents)
                {
                        r_refdef.stats[r_stat_animcache_shade_count] += 1;
@@ -4995,44 +3902,23 @@ qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qbool
 void R_AnimCache_CacheVisibleEntities(void)
 {
        int i;
-       qboolean wantnormals = true;
-       qboolean wanttangents = !r_showsurfaces.integer;
-
-       switch(vid.renderpath)
-       {
-       case RENDERPATH_GL20:
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_GLES2:
-               break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               wanttangents = false;
-               break;
-       case RENDERPATH_SOFT:
-               break;
-       }
-
-       if (r_shownormals.integer)
-               wanttangents = wantnormals = true;
 
        // TODO: thread this
        // NOTE: R_PrepareRTLights() also caches entities
 
        for (i = 0;i < r_refdef.scene.numentities;i++)
                if (r_refdef.viewcache.entityvisible[i])
-                       R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents);
+                       R_AnimCache_GetEntity(r_refdef.scene.entities[i], true, true);
 }
 
 //==================================================================================
 
-qboolean R_CanSeeBox(int numsamples, vec_t eyejitter, vec_t entboxenlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
+qboolean R_CanSeeBox(int numsamples, vec_t eyejitter, vec_t entboxenlarge, vec_t entboxexpand, vec_t pad, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
 {
        int i;
        vec3_t eyemins, eyemaxs;
        vec3_t boxmins, boxmaxs;
+       vec3_t padmins, padmaxs;
        vec3_t start;
        vec3_t end;
        dp_model_t *model = r_refdef.scene.worldmodel;
@@ -5053,7 +3939,7 @@ qboolean R_CanSeeBox(int numsamples, vec_t eyejitter, vec_t entboxenlarge, vec3_
                return true;
 
        // view origin is not used for culling in portal/reflection/refraction renders or isometric views
-       if (r_refdef.view.useclipplane || !r_refdef.view.useperspective || r_trippy.integer)
+       if (!r_refdef.view.usevieworiginculling)
                return true;
 
        if (!r_cullentities_trace_entityocclusion.integer && (!model || !model->brush.TraceLineOfSight))
@@ -5067,12 +3953,19 @@ qboolean R_CanSeeBox(int numsamples, vec_t eyejitter, vec_t entboxenlarge, vec3_
        eyemins[2] = eye[2] - eyejitter;
        eyemaxs[2] = eye[2] + eyejitter;
        // expand the box a little
-       boxmins[0] = (entboxenlarge + 1) * entboxmins[0] - entboxenlarge * entboxmaxs[0];
-       boxmaxs[0] = (entboxenlarge + 1) * entboxmaxs[0] - entboxenlarge * entboxmins[0];
-       boxmins[1] = (entboxenlarge + 1) * entboxmins[1] - entboxenlarge * entboxmaxs[1];
-       boxmaxs[1] = (entboxenlarge + 1) * entboxmaxs[1] - entboxenlarge * entboxmins[1];
-       boxmins[2] = (entboxenlarge + 1) * entboxmins[2] - entboxenlarge * entboxmaxs[2];
-       boxmaxs[2] = (entboxenlarge + 1) * entboxmaxs[2] - entboxenlarge * entboxmins[2];
+       boxmins[0] = (entboxenlarge + 1) * entboxmins[0] - entboxenlarge * entboxmaxs[0] - entboxexpand;
+       boxmaxs[0] = (entboxenlarge + 1) * entboxmaxs[0] - entboxenlarge * entboxmins[0] + entboxexpand;
+       boxmins[1] = (entboxenlarge + 1) * entboxmins[1] - entboxenlarge * entboxmaxs[1] - entboxexpand;
+       boxmaxs[1] = (entboxenlarge + 1) * entboxmaxs[1] - entboxenlarge * entboxmins[1] + entboxexpand;
+       boxmins[2] = (entboxenlarge + 1) * entboxmins[2] - entboxenlarge * entboxmaxs[2] - entboxexpand;
+       boxmaxs[2] = (entboxenlarge + 1) * entboxmaxs[2] - entboxenlarge * entboxmins[2] + entboxexpand;
+       // make an even larger box for the acceptable area
+       padmins[0] = boxmins[0] - pad;
+       padmaxs[0] = boxmaxs[0] + pad;
+       padmins[1] = boxmins[1] - pad;
+       padmaxs[1] = boxmaxs[1] + pad;
+       padmins[2] = boxmins[2] - pad;
+       padmaxs[2] = boxmaxs[2] + pad;
 
        // return true if eye overlaps enlarged box
        if (BoxesOverlap(boxmins, boxmaxs, eyemins, eyemaxs))
@@ -5090,11 +3983,11 @@ qboolean R_CanSeeBox(int numsamples, vec_t eyejitter, vec_t entboxenlarge, vec3_
                        //trace_t trace = CL_TraceLine(start, end, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, 0.0f, true, false, NULL, true, true);
                        trace_t trace = CL_Cache_TraceLineSurfaces(start, end, MOVE_NORMAL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT);
                        // not picky - if the trace ended anywhere in the box we're good
-                       if (BoxesOverlap(trace.endpos, trace.endpos, boxmins, boxmaxs))
+                       if (BoxesOverlap(trace.endpos, trace.endpos, padmins, padmaxs))
                                return true;
                }
        }
-       else if (model->brush.TraceLineOfSight(model, start, end, boxmins, boxmaxs))
+       else if (model->brush.TraceLineOfSight(model, start, end, padmins, padmaxs))
                return true;
 
        // try various random positions
@@ -5106,10 +3999,10 @@ qboolean R_CanSeeBox(int numsamples, vec_t eyejitter, vec_t entboxenlarge, vec3_
                {
                        trace_t trace = CL_Cache_TraceLineSurfaces(start, end, MOVE_NORMAL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT);
                        // not picky - if the trace ended anywhere in the box we're good
-                       if (BoxesOverlap(trace.endpos, trace.endpos, boxmins, boxmaxs))
+                       if (BoxesOverlap(trace.endpos, trace.endpos, padmins, padmaxs))
                                return true;
                }
-               else if (model->brush.TraceLineOfSight(model, start, end, boxmins, boxmaxs))
+               else if (model->brush.TraceLineOfSight(model, start, end, padmins, padmaxs))
                        return true;
        }
 
@@ -5168,7 +4061,7 @@ static void R_View_UpdateEntityVisible (void)
                        if (!(ent->flags & (RENDER_VIEWMODEL | RENDER_WORLDOBJECT | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
                        {
                                samples = ent->last_trace_visibility == 0 ? r_cullentities_trace_tempentitysamples.integer : r_cullentities_trace_samples.integer;
-                               if (R_CanSeeBox(samples, r_cullentities_trace_eyejitter.value, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
+                               if (R_CanSeeBox(samples, r_cullentities_trace_eyejitter.value, r_cullentities_trace_enlarge.value, r_cullentities_trace_expand.value, r_cullentities_trace_pad.value, r_refdef.view.origin, ent->mins, ent->maxs))
                                        ent->last_trace_visibility = realtime;
                                if (ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
                                        r_refdef.viewcache.entityvisible[i] = 0;
@@ -5327,28 +4220,9 @@ static void R_View_SetFrustum(const int *scissor)
                // flipped x coordinates (because x points left here)
                fpx =  1.0 - 2.0 * (scissor[0]              - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
                fnx =  1.0 - 2.0 * (scissor[0] + scissor[2] - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
-
-               // D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one
-               switch(vid.renderpath)
-               {
-                       case RENDERPATH_D3D9:
-                       case RENDERPATH_D3D10:
-                       case RENDERPATH_D3D11:
-                               // non-flipped y coordinates
-                               fny = -1.0 + 2.0 * (vid.height - scissor[1] - scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
-                               fpy = -1.0 + 2.0 * (vid.height - scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
-                               break;
-                       case RENDERPATH_SOFT:
-                       case RENDERPATH_GL11:
-                       case RENDERPATH_GL13:
-                       case RENDERPATH_GL20:
-                       case RENDERPATH_GLES1:
-                       case RENDERPATH_GLES2:
-                               // non-flipped y coordinates
-                               fny = -1.0 + 2.0 * (scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
-                               fpy = -1.0 + 2.0 * (scissor[1] + scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
-                               break;
-               }
+               // non-flipped y coordinates
+               fny = -1.0 + 2.0 * (scissor[1]              - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
+               fpy = -1.0 + 2.0 * (scissor[1] + scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
        }
 
        // we can't trust r_refdef.view.forward and friends in reflected scenes
@@ -5467,16 +4341,16 @@ static void R_View_SetFrustum(const int *scissor)
        }
        else
        {
-               VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
-               VectorScale(left,  r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
-               VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
-               VectorScale(up,  r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
-               VectorCopy(forward, r_refdef.view.frustum[4].normal);
-               r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
-               r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
-               r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
-               r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
-               r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
+               VectorScale(left, -1.0f, r_refdef.view.frustum[0].normal);
+               VectorScale(left,  1.0f, r_refdef.view.frustum[1].normal);
+               VectorScale(up, -1.0f, r_refdef.view.frustum[2].normal);
+               VectorScale(up,  1.0f, r_refdef.view.frustum[3].normal);
+               VectorScale(forward, -1.0f, r_refdef.view.frustum[4].normal);
+               r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) - r_refdef.view.ortho_x;
+               r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) - r_refdef.view.ortho_x;
+               r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) - r_refdef.view.ortho_y;
+               r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) - r_refdef.view.ortho_y;
+               r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) - r_refdef.farclip;
        }
        r_refdef.view.numfrustumplanes = 5;
 
@@ -5523,7 +4397,7 @@ static void R_View_UpdateWithScissor(const int *myscissor)
 {
        R_Main_ResizeViewCache();
        R_View_SetFrustum(myscissor);
-       R_View_WorldVisibility(r_refdef.view.useclipplane);
+       R_View_WorldVisibility(!r_refdef.view.usevieworiginculling);
        R_View_UpdateEntityVisible();
 }
 
@@ -5531,7 +4405,7 @@ static void R_View_Update(void)
 {
        R_Main_ResizeViewCache();
        R_View_SetFrustum(NULL);
-       R_View_WorldVisibility(r_refdef.view.useclipplane);
+       R_View_WorldVisibility(!r_refdef.view.usevieworiginculling);
        R_View_UpdateEntityVisible();
 }
 
@@ -5561,30 +4435,20 @@ void R_SetupView(qboolean allowwaterclippingplane, int viewfbo, rtexture_t *view
                plane[1] = r_refdef.view.clipplane.normal[1];
                plane[2] = r_refdef.view.clipplane.normal[2];
                plane[3] = -dist;
-               if(vid.renderpath != RENDERPATH_SOFT) customclipplane = plane;
+               customclipplane = plane;
        }
 
        //rtwidth = viewfbo ? R_TextureWidth(viewdepthtexture ? viewdepthtexture : viewcolortexture) : vid.width;
        rtheight = viewfbo ? R_TextureHeight(viewdepthtexture ? viewdepthtexture : viewcolortexture) : vid.height;
 
        if (!r_refdef.view.useperspective)
-               R_Viewport_InitOrtho(&r_refdef.view.viewport, &r_refdef.view.matrix, viewx, rtheight - viewheight - viewy, viewwidth, viewheight, -r_refdef.view.ortho_x, -r_refdef.view.ortho_y, r_refdef.view.ortho_x, r_refdef.view.ortho_y, -r_refdef.farclip, r_refdef.farclip, customclipplane);
+               R_Viewport_InitOrtho3D(&r_refdef.view.viewport, &r_refdef.view.matrix, viewx, rtheight - viewheight - viewy, viewwidth, viewheight, r_refdef.view.ortho_x, r_refdef.view.ortho_y, -r_refdef.farclip, r_refdef.farclip, customclipplane);
        else if (vid.stencil && r_useinfinitefarclip.integer)
                R_Viewport_InitPerspectiveInfinite(&r_refdef.view.viewport, &r_refdef.view.matrix, viewx, rtheight - viewheight - viewy, viewwidth, viewheight, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, customclipplane);
        else
                R_Viewport_InitPerspective(&r_refdef.view.viewport, &r_refdef.view.matrix, viewx, rtheight - viewheight - viewy, viewwidth, viewheight, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, r_refdef.farclip, customclipplane);
        R_Mesh_SetRenderTargets(viewfbo, viewdepthtexture, viewcolortexture, NULL, NULL, NULL);
        R_SetViewport(&r_refdef.view.viewport);
-       if (r_refdef.view.useclipplane && allowwaterclippingplane && vid.renderpath == RENDERPATH_SOFT)
-       {
-               matrix4x4_t mvpmatrix, invmvpmatrix, invtransmvpmatrix;
-               float screenplane[4];
-               Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
-               Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
-               Matrix4x4_Transpose(&invtransmvpmatrix, &invmvpmatrix);
-               Matrix4x4_Transform4(&invtransmvpmatrix, plane, screenplane);
-               DPSOFTRAST_ClipPlane(screenplane[0], screenplane[1], screenplane[2], screenplane[3]);
-       }
 }
 
 void R_EntityMatrix(const matrix4x4_t *matrix)
@@ -5600,30 +4464,7 @@ void R_EntityMatrix(const matrix4x4_t *matrix)
                CHECKGLERROR
                switch(vid.renderpath)
                {
-               case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-                       hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
-                       hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
-#endif
-                       break;
-               case RENDERPATH_D3D10:
-                       Con_DPrintf("FIXME D3D10 shader %s:%i\n", __FILE__, __LINE__);
-                       break;
-               case RENDERPATH_D3D11:
-                       Con_DPrintf("FIXME D3D11 shader %s:%i\n", __FILE__, __LINE__);
-                       break;
-               case RENDERPATH_GL11:
-               case RENDERPATH_GL13:
-               case RENDERPATH_GLES1:
-#ifndef USE_GLES2
-                       qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
-#endif
-                       break;
-               case RENDERPATH_SOFT:
-                       DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewProjectionMatrixM1, 1, false, gl_modelviewprojection16f);
-                       DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewMatrixM1, 1, false, gl_modelview16f);
-                       break;
-               case RENDERPATH_GL20:
+               case RENDERPATH_GL32:
                case RENDERPATH_GLES2:
                        if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fv(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
                        if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fv(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
@@ -5654,21 +4495,12 @@ void R_ResetViewRendering2D_Common(int viewfbo, rtexture_t *viewdepthtexture, rt
        R_EntityMatrix(&identitymatrix);
        R_Mesh_ResetTextureState();
        GL_PolygonOffset(0, 0);
-       R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
        switch(vid.renderpath)
        {
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GL20:
-       case RENDERPATH_GLES1:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
                qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
                break;
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_SOFT:
-               break;
        }
        GL_CullFace(GL_NONE);
 
@@ -5677,15 +4509,11 @@ void R_ResetViewRendering2D_Common(int viewfbo, rtexture_t *viewdepthtexture, rt
 
 void R_ResetViewRendering2D(int viewfbo, rtexture_t *viewdepthtexture, rtexture_t *viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
 {
-       DrawQ_Finish();
-
        R_ResetViewRendering2D_Common(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight, 1.0f, 1.0f);
 }
 
 void R_ResetViewRendering3D(int viewfbo, rtexture_t *viewdepthtexture, rtexture_t *viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
 {
-       DrawQ_Finish();
-
        R_SetupView(true, viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
        GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
        GL_Color(1, 1, 1, 1);
@@ -5699,21 +4527,12 @@ void R_ResetViewRendering3D(int viewfbo, rtexture_t *viewdepthtexture, rtexture_
        R_EntityMatrix(&identitymatrix);
        R_Mesh_ResetTextureState();
        GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
-       R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
        switch(vid.renderpath)
        {
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GL20:
-       case RENDERPATH_GLES1:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
                qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
                break;
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_SOFT:
-               break;
        }
        GL_CullFace(r_refdef.view.cullface_back);
 }
@@ -5734,103 +4553,119 @@ void R_RenderView_UpdateViewVectors(void)
        Matrix4x4_Invert_Full(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
 }
 
-static void R_Water_StartFrame(void)
+void R_RenderTarget_FreeUnused(qboolean force)
 {
-       int i;
-       int waterwidth, waterheight, texturewidth, textureheight, camerawidth, cameraheight;
-       r_waterstate_waterplane_t *p;
-       qboolean usewaterfbo = (r_viewfbo.integer >= 1 || r_water_fbo.integer >= 1) && vid.support.ext_framebuffer_object && vid.support.arb_texture_non_power_of_two && vid.samples < 2;
-
-       if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
-               return;
-
-       switch(vid.renderpath)
+       int i, j, end;
+       end = Mem_ExpandableArray_IndexRange(&r_fb.rendertargets);
+       for (i = 0; i < end; i++)
        {
-       case RENDERPATH_GL20:
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_SOFT:
-       case RENDERPATH_GLES2:
-               break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               return;
+               r_rendertarget_t *r = (r_rendertarget_t *)Mem_ExpandableArray_RecordAtIndex(&r_fb.rendertargets, i);
+               // free resources for rendertargets that have not been used for a while
+               // (note: this check is run after the frame render, so any targets used
+               // this frame will not be affected even at low framerates)
+               if (r && (realtime - r->lastusetime > 0.2 || force))
+               {
+                       if (r->fbo)
+                               R_Mesh_DestroyFramebufferObject(r->fbo);
+                       for (j = 0; j < sizeof(r->colortexture) / sizeof(r->colortexture[0]); j++)
+                               if (r->colortexture[j])
+                                       R_FreeTexture(r->colortexture[j]);
+                       if (r->depthtexture)
+                               R_FreeTexture(r->depthtexture);
+                       Mem_ExpandableArray_FreeRecord(&r_fb.rendertargets, r);
+               }
        }
+}
 
-       // set waterwidth and waterheight to the water resolution that will be
-       // used (often less than the screen resolution for faster rendering)
-       R_GetScaledViewSize(bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width), bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height), &waterwidth, &waterheight);
+static void R_CalcTexCoordsForView(float x, float y, float w, float h, float tw, float th, float *texcoord2f)
+{
+       float iw = 1.0f / tw, ih = 1.0f / th, x1, y1, x2, y2;
+       x1 = x * iw;
+       x2 = (x + w) * iw;
+       y1 = (th - y) * ih;
+       y2 = (th - y - h) * ih;
+       texcoord2f[0] = x1;
+       texcoord2f[2] = x2;
+       texcoord2f[4] = x2;
+       texcoord2f[6] = x1;
+       texcoord2f[1] = y1;
+       texcoord2f[3] = y1;
+       texcoord2f[5] = y2;
+       texcoord2f[7] = y2;
+}
 
-       // calculate desired texture sizes
-       // can't use water if the card does not support the texture size
-       if (!r_water.integer || r_showsurfaces.integer)
-               texturewidth = textureheight = waterwidth = waterheight = camerawidth = cameraheight = 0;
-       else if (vid.support.arb_texture_non_power_of_two)
-       {
-               texturewidth = waterwidth;
-               textureheight = waterheight;
-               camerawidth = waterwidth;
-               cameraheight = waterheight;
-       }
-       else
+r_rendertarget_t *R_RenderTarget_Get(int texturewidth, int textureheight, textype_t depthtextype, qboolean depthisrenderbuffer, textype_t colortextype0, textype_t colortextype1, textype_t colortextype2, textype_t colortextype3)
+{
+       int i, j, end;
+       r_rendertarget_t *r = NULL;
+       char vabuf[256];
+       // first try to reuse an existing slot if possible
+       end = Mem_ExpandableArray_IndexRange(&r_fb.rendertargets);
+       for (i = 0; i < end; i++)
        {
-               for (texturewidth   = 1;texturewidth     <  waterwidth ;texturewidth   *= 2);
-               for (textureheight  = 1;textureheight    <  waterheight;textureheight  *= 2);
-               for (camerawidth    = 1;camerawidth  * 2 <= waterwidth ;camerawidth    *= 2);
-               for (cameraheight   = 1;cameraheight * 2 <= waterheight;cameraheight   *= 2);
+               r = (r_rendertarget_t *)Mem_ExpandableArray_RecordAtIndex(&r_fb.rendertargets, i);
+               if (r && r->lastusetime != realtime && r->texturewidth == texturewidth && r->textureheight == textureheight && r->depthtextype == depthtextype && r->colortextype[0] == colortextype0 && r->colortextype[1] == colortextype1 && r->colortextype[2] == colortextype2 && r->colortextype[3] == colortextype3)
+                       break;
        }
-
-       // allocate textures as needed
-       if (r_fb.water.texturewidth != texturewidth || r_fb.water.textureheight != textureheight || r_fb.water.camerawidth != camerawidth || r_fb.water.cameraheight != cameraheight || (r_fb.depthtexture && !usewaterfbo))
-       {
-               r_fb.water.maxwaterplanes = MAX_WATERPLANES;
-               for (i = 0, p = r_fb.water.waterplanes;i < r_fb.water.maxwaterplanes;i++, p++)
-               {
-                       if (p->texture_refraction)
-                               R_FreeTexture(p->texture_refraction);
-                       p->texture_refraction = NULL;
-                       if (p->fbo_refraction)
-                               R_Mesh_DestroyFramebufferObject(p->fbo_refraction);
-                       p->fbo_refraction = 0;
-                       if (p->texture_reflection)
-                               R_FreeTexture(p->texture_reflection);
-                       p->texture_reflection = NULL;
-                       if (p->fbo_reflection)
-                               R_Mesh_DestroyFramebufferObject(p->fbo_reflection);
-                       p->fbo_reflection = 0;
-                       if (p->texture_camera)
-                               R_FreeTexture(p->texture_camera);
-                       p->texture_camera = NULL;
-                       if (p->fbo_camera)
-                               R_Mesh_DestroyFramebufferObject(p->fbo_camera);
-                       p->fbo_camera = 0;
+       if (i == end)
+       {
+               // no unused exact match found, so we have to make one in the first unused slot
+               r = (r_rendertarget_t *)Mem_ExpandableArray_AllocRecord(&r_fb.rendertargets);
+               r->texturewidth = texturewidth;
+               r->textureheight = textureheight;
+               r->colortextype[0] = colortextype0;
+               r->colortextype[1] = colortextype1;
+               r->colortextype[2] = colortextype2;
+               r->colortextype[3] = colortextype3;
+               r->depthtextype = depthtextype;
+               r->depthisrenderbuffer = depthisrenderbuffer;
+               for (j = 0; j < 4; j++)
+                       if (r->colortextype[j])
+                               r->colortexture[j] = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "rendertarget%i_%i_type%i", i, j, (int)r->colortextype[j]), r->texturewidth, r->textureheight, NULL, r->colortextype[j], TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
+               if (r->depthtextype)
+               {
+                       if (r->depthisrenderbuffer)
+                               r->depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, va(vabuf, sizeof(vabuf), "renderbuffer%i_depth_type%i", i, (int)r->depthtextype), r->texturewidth, r->textureheight, r->depthtextype);
+                       else
+                               r->depthtexture = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "rendertarget%i_depth_type%i", i, j, (int)r->depthtextype), r->texturewidth, r->textureheight, NULL, r->depthtextype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
                }
-               memset(&r_fb.water, 0, sizeof(r_fb.water));
-               r_fb.water.texturewidth = texturewidth;
-               r_fb.water.textureheight = textureheight;
-               r_fb.water.camerawidth = camerawidth;
-               r_fb.water.cameraheight = cameraheight;
+               r->fbo = R_Mesh_CreateFramebufferObject(r->depthtexture, r->colortexture[0], r->colortexture[1], r->colortexture[2], r->colortexture[3]);
        }
+       r_refdef.stats[r_stat_rendertargets_used]++;
+       r_refdef.stats[r_stat_rendertargets_pixels] += r->texturewidth * r->textureheight;
+       r->lastusetime = realtime;
+       R_CalcTexCoordsForView(0, 0, r->texturewidth, r->textureheight, r->texturewidth, r->textureheight, r->texcoord2f);
+       return r;
+}
 
-       if (r_fb.water.texturewidth)
-       {
-               int scaledwidth, scaledheight;
+static void R_Water_StartFrame(void)
+{
+       int waterwidth, waterheight;
 
-               r_fb.water.enabled = true;
+       if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
+               return;
 
-               // water resolution is usually reduced
-               r_fb.water.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
-               r_fb.water.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
-               R_GetScaledViewSize(r_fb.water.waterwidth, r_fb.water.waterheight, &scaledwidth, &scaledheight);
+       // set waterwidth and waterheight to the water resolution that will be
+       // used (often less than the screen resolution for faster rendering)
+       waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
+       waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
+       R_GetScaledViewSize(waterwidth, waterheight, &waterwidth, &waterheight);
 
-               // set up variables that will be used in shader setup
-               r_fb.water.screenscale[0] = 0.5f * (float)scaledwidth / (float)r_fb.water.texturewidth;
-               r_fb.water.screenscale[1] = 0.5f * (float)scaledheight / (float)r_fb.water.textureheight;
-               r_fb.water.screencenter[0] = 0.5f * (float)scaledwidth / (float)r_fb.water.texturewidth;
-               r_fb.water.screencenter[1] = 0.5f * (float)scaledheight / (float)r_fb.water.textureheight;
-       }
+       if (!r_water.integer || r_showsurfaces.integer)
+               waterwidth = waterheight = 0;
+
+       // set up variables that will be used in shader setup
+       r_fb.water.waterwidth = waterwidth;
+       r_fb.water.waterheight = waterheight;
+       r_fb.water.texturewidth = waterwidth;
+       r_fb.water.textureheight = waterheight;
+       r_fb.water.camerawidth = waterwidth;
+       r_fb.water.cameraheight = waterheight;
+       r_fb.water.screenscale[0] = 0.5f;
+       r_fb.water.screenscale[1] = 0.5f;
+       r_fb.water.screencenter[0] = 0.5f;
+       r_fb.water.screencenter[1] = 0.5f;
+       r_fb.water.enabled = waterwidth != 0;
 
        r_fb.water.maxwaterplanes = MAX_WATERPLANES;
        r_fb.water.numwaterplanes = 0;
@@ -5953,21 +4788,17 @@ void R_Water_AddWaterPlane(msurface_t *surface, int entno)
 extern cvar_t r_drawparticles;
 extern cvar_t r_drawdecals;
 
-static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, int x, int y, int width, int height)
+static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, int viewx, int viewy, int viewwidth, int viewheight)
 {
        int myscissor[4];
        r_refdef_view_t originalview;
        r_refdef_view_t myview;
        int planeindex, qualityreduction = 0, old_r_dynamic = 0, old_r_shadows = 0, old_r_worldrtlight = 0, old_r_dlight = 0, old_r_particles = 0, old_r_decals = 0;
-       int waterx, watery;
        r_waterstate_waterplane_t *p;
        vec3_t visorigin;
-       qboolean usewaterfbo = (r_viewfbo.integer >= 1 || r_water_fbo.integer >= 1) && vid.support.ext_framebuffer_object && vid.support.arb_texture_non_power_of_two && vid.samples < 2;
-       char vabuf[1024];
+       r_rendertarget_t *rt;
 
        originalview = r_refdef.view;
-       waterx = usewaterfbo ? 0 : x;
-       watery = usewaterfbo ? 0 : y;
 
        // lowquality hack, temporarily shut down some cvars and restore afterwards
        qualityreduction = r_water_lowquality.integer;
@@ -5993,61 +4824,16 @@ static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t
                }
        }
 
-       // make sure enough textures are allocated
-       for (planeindex = 0, p = r_fb.water.waterplanes;planeindex < r_fb.water.numwaterplanes;planeindex++, p++)
+       for (planeindex = 0, p = r_fb.water.waterplanes; planeindex < r_fb.water.numwaterplanes; planeindex++, p++)
        {
-               if (r_water_cameraentitiesonly.value != 0 && !p->camera_entity)
-                       continue;
-               if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
-               {
-                       if (!p->texture_refraction)
-                               p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "waterplane%i_refraction", planeindex), r_fb.water.texturewidth, r_fb.water.textureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
-                       if (!p->texture_refraction)
-                               goto error;
-                       if (usewaterfbo)
-                       {
-                               if (r_fb.water.depthtexture == NULL)
-                                       r_fb.water.depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, "waterviewdepth", r_fb.water.texturewidth, r_fb.water.textureheight, TEXTYPE_DEPTHBUFFER24STENCIL8);
-                               if (p->fbo_refraction == 0)
-                                       p->fbo_refraction = R_Mesh_CreateFramebufferObject(r_fb.water.depthtexture, p->texture_refraction, NULL, NULL, NULL);
-                       }
-               }
-               else if (p->materialflags & MATERIALFLAG_CAMERA)
-               {
-                       if (!p->texture_camera)
-                               p->texture_camera = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "waterplane%i_camera", planeindex), r_fb.water.camerawidth, r_fb.water.cameraheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR, -1, NULL);
-                       if (!p->texture_camera)
-                               goto error;
-                       if (usewaterfbo)
-                       {
-                               if (r_fb.water.depthtexture == NULL)
-                                       r_fb.water.depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, "waterviewdepth", r_fb.water.texturewidth, r_fb.water.textureheight, TEXTYPE_DEPTHBUFFER24STENCIL8);
-                               if (p->fbo_camera == 0)
-                                       p->fbo_camera = R_Mesh_CreateFramebufferObject(r_fb.water.depthtexture, p->texture_camera, NULL, NULL, NULL);
-                       }
-               }
-
-               if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
-               {
-                       if (!p->texture_reflection)
-                               p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "waterplane%i_reflection", planeindex), r_fb.water.texturewidth, r_fb.water.textureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
-                       if (!p->texture_reflection)
-                               goto error;
-                       if (usewaterfbo)
-                       {
-                               if (r_fb.water.depthtexture == NULL)
-                                       r_fb.water.depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, "waterviewdepth", r_fb.water.texturewidth, r_fb.water.textureheight, TEXTYPE_DEPTHBUFFER24STENCIL8);
-                               if (p->fbo_reflection == 0)
-                                       p->fbo_reflection = R_Mesh_CreateFramebufferObject(r_fb.water.depthtexture, p->texture_reflection, NULL, NULL, NULL);
-                       }
-               }
+               p->rt_reflection = NULL;
+               p->rt_refraction = NULL;
+               p->rt_camera = NULL;
        }
 
        // render views
        r_refdef.view = originalview;
        r_refdef.view.showdebug = false;
-       r_refdef.view.x = waterx;
-       r_refdef.view.y = watery;
        r_refdef.view.width = r_fb.water.waterwidth;
        r_refdef.view.height = r_fb.water.waterheight;
        r_refdef.view.useclipplane = true;
@@ -6057,24 +4843,34 @@ static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t
        {
                if (r_water_cameraentitiesonly.value != 0 && !p->camera_entity)
                        continue;
+
                if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
                {
+                       rt = R_RenderTarget_Get(r_fb.water.waterwidth, r_fb.water.waterheight, TEXTYPE_DEPTHBUFFER24STENCIL8, true, r_fb.rt_screen->colortextype[0], TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED);
+                       if (rt->colortexture[0] == NULL || rt->depthtexture == NULL)
+                               goto error;
                        r_refdef.view = myview;
+                       Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
+                       Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
                        if(r_water_scissormode.integer)
                        {
-                               R_SetupView(true, p->fbo_reflection, r_fb.water.depthtexture, p->texture_reflection, waterx, watery, r_fb.water.waterwidth, r_fb.water.waterheight);
-                               if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
-                                       continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
+                               R_SetupView(true, rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, r_fb.water.waterwidth, r_fb.water.waterheight);
+                               if (R_ScissorForBBox(p->mins, p->maxs, myscissor))
+                               {
+                                       p->rt_reflection = NULL;
+                                       p->rt_refraction = NULL;
+                                       p->rt_camera = NULL;
+                                       continue;
+                               }
                        }
 
-                       // render reflected scene and copy into texture
-                       Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
-                       // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
-                       Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
                        r_refdef.view.clipplane = p->plane;
+                       // reflected view origin may be in solid, so don't cull with it
+                       r_refdef.view.usevieworiginculling = false;
                        // reverse the cullface settings for this render
                        r_refdef.view.cullface_front = GL_FRONT;
                        r_refdef.view.cullface_back = GL_BACK;
+                       // combined pvs (based on what can be seen from each surface center)
                        if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
                        {
                                r_refdef.view.usecustompvs = true;
@@ -6085,12 +4881,10 @@ static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t
                        }
 
                        r_fb.water.hideplayer = ((r_water_hideplayer.integer >= 2) && !chase_active.integer);
-                       R_ResetViewRendering3D(p->fbo_reflection, r_fb.water.depthtexture, p->texture_reflection, waterx, watery, r_fb.water.waterwidth, r_fb.water.waterheight);
-                       if (p->fbo_reflection)
-                               GL_ScissorTest(false);
+                       R_ResetViewRendering3D(rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, rt->texturewidth, rt->textureheight);
+                       GL_ScissorTest(false);
                        R_ClearScreen(r_refdef.fogenabled);
-                       if (p->fbo_reflection)
-                               GL_ScissorTest(true);
+                       GL_ScissorTest(true);
                        if(r_water_scissormode.integer & 2)
                                R_View_UpdateWithScissor(myscissor);
                        else
@@ -6098,23 +4892,40 @@ static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t
                        R_AnimCache_CacheVisibleEntities();
                        if(r_water_scissormode.integer & 1)
                                GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
-                       R_RenderScene(p->fbo_reflection, r_fb.water.depthtexture, p->texture_reflection, waterx, watery, r_fb.water.waterwidth, r_fb.water.waterheight);
+                       R_RenderScene(rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, rt->texturewidth, rt->textureheight);
 
-                       if (!p->fbo_reflection)
-                               R_Mesh_CopyToTexture(p->texture_reflection, 0, 0, waterx, watery, r_fb.water.waterwidth, r_fb.water.waterheight);
                        r_fb.water.hideplayer = false;
+                       p->rt_reflection = rt;
                }
 
                // 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)
                if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
                {
+                       rt = R_RenderTarget_Get(r_fb.water.waterwidth, r_fb.water.waterheight, TEXTYPE_DEPTHBUFFER24STENCIL8, true, r_fb.rt_screen->colortextype[0], TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED);
+                       if (rt->colortexture[0] == NULL || rt->depthtexture == NULL)
+                               goto error;
                        r_refdef.view = myview;
                        if(r_water_scissormode.integer)
                        {
-                               R_SetupView(true, p->fbo_refraction, r_fb.water.depthtexture, p->texture_refraction, waterx, watery, r_fb.water.waterwidth, r_fb.water.waterheight);
-                               if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
-                                       continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
+                               R_SetupView(true, rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, r_fb.water.waterwidth, r_fb.water.waterheight);
+                               if (R_ScissorForBBox(p->mins, p->maxs, myscissor))
+                               {
+                                       p->rt_reflection = NULL;
+                                       p->rt_refraction = NULL;
+                                       p->rt_camera = NULL;
+                                       continue;
+                               }
+                       }
+
+                       // combined pvs (based on what can be seen from each surface center)
+                       if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
+                       {
+                               r_refdef.view.usecustompvs = true;
+                               if (p->pvsvalid)
+                                       memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
+                               else
+                                       memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
                        }
 
                        r_fb.water.hideplayer = ((r_water_hideplayer.integer >= 1) && !chase_active.integer);
@@ -6138,12 +4949,10 @@ static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t
 
                        PlaneClassify(&r_refdef.view.clipplane);
 
-                       R_ResetViewRendering3D(p->fbo_refraction, r_fb.water.depthtexture, p->texture_refraction, waterx, watery, r_fb.water.waterwidth, r_fb.water.waterheight);
-                       if (p->fbo_refraction)
-                               GL_ScissorTest(false);
+                       R_ResetViewRendering3D(rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, rt->texturewidth, rt->textureheight);
+                       GL_ScissorTest(false);
                        R_ClearScreen(r_refdef.fogenabled);
-                       if (p->fbo_refraction)
-                               GL_ScissorTest(true);
+                       GL_ScissorTest(true);
                        if(r_water_scissormode.integer & 2)
                                R_View_UpdateWithScissor(myscissor);
                        else
@@ -6151,22 +4960,22 @@ static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t
                        R_AnimCache_CacheVisibleEntities();
                        if(r_water_scissormode.integer & 1)
                                GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
-                       R_RenderScene(p->fbo_refraction, r_fb.water.depthtexture, p->texture_refraction, waterx, watery, r_fb.water.waterwidth, r_fb.water.waterheight);
+                       R_RenderScene(rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, rt->texturewidth, rt->textureheight);
 
-                       if (!p->fbo_refraction)
-                               R_Mesh_CopyToTexture(p->texture_refraction, 0, 0, waterx, watery, r_fb.water.waterwidth, r_fb.water.waterheight);
                        r_fb.water.hideplayer = false;
+                       p->rt_refraction = rt;
                }
                else if (p->materialflags & MATERIALFLAG_CAMERA)
                {
+                       rt = R_RenderTarget_Get(r_fb.water.waterwidth, r_fb.water.waterheight, TEXTYPE_DEPTHBUFFER24STENCIL8, true, r_fb.rt_screen->colortextype[0], TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED);
+                       if (rt->colortexture[0] == NULL || rt->depthtexture == NULL)
+                               goto error;
                        r_refdef.view = myview;
 
                        r_refdef.view.clipplane = p->plane;
                        VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
                        r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
 
-                       r_refdef.view.x = waterx;
-                       r_refdef.view.y = watery;
                        r_refdef.view.width = r_fb.water.camerawidth;
                        r_refdef.view.height = r_fb.water.cameraheight;
                        r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0);
@@ -6197,33 +5006,29 @@ static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t
                        
                        // camera needs no clipplane
                        r_refdef.view.useclipplane = false;
+                       // TODO: is the camera origin always valid?  if so we don't need to clear this
+                       r_refdef.view.usevieworiginculling = false;
 
                        PlaneClassify(&r_refdef.view.clipplane);
 
                        r_fb.water.hideplayer = false;
 
-                       R_ResetViewRendering3D(p->fbo_camera, r_fb.water.depthtexture, p->texture_camera, waterx, watery, r_fb.water.camerawidth, r_fb.water.cameraheight);
-                       if (p->fbo_camera)
-                               GL_ScissorTest(false);
+                       R_ResetViewRendering3D(rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, rt->texturewidth, rt->textureheight);
+                       GL_ScissorTest(false);
                        R_ClearScreen(r_refdef.fogenabled);
-                       if (p->fbo_camera)
-                               GL_ScissorTest(true);
+                       GL_ScissorTest(true);
                        R_View_Update();
                        R_AnimCache_CacheVisibleEntities();
-                       R_RenderScene(p->fbo_camera, r_fb.water.depthtexture, p->texture_camera, waterx, watery, r_fb.water.camerawidth, r_fb.water.cameraheight);
+                       R_RenderScene(rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, rt->texturewidth, rt->textureheight);
 
-                       if (!p->fbo_camera)
-                               R_Mesh_CopyToTexture(p->texture_camera, 0, 0, waterx, watery, r_fb.water.camerawidth, r_fb.water.cameraheight);
                        r_fb.water.hideplayer = false;
+                       p->rt_camera = rt;
                }
 
        }
-       if(vid.renderpath==RENDERPATH_SOFT) DPSOFTRAST_ClipPlane(0, 0, 0, 1);
        r_fb.water.renderingscene = false;
        r_refdef.view = originalview;
-       R_ResetViewRendering3D(fbo, depthtexture, colortexture, x, y, width, height);
-       if (!r_fb.water.depthtexture)
-               R_ClearScreen(r_refdef.fogenabled);
+       R_ResetViewRendering3D(fbo, depthtexture, colortexture, viewx, viewy, viewwidth, viewheight);
        R_View_Update();
        R_AnimCache_CacheVisibleEntities();
        goto finish;
@@ -6253,35 +5058,24 @@ finish:
 
 static void R_Bloom_StartFrame(void)
 {
-       int i;
        int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
        int viewwidth, viewheight;
-       qboolean useviewfbo = r_viewfbo.integer >= 1 && vid.support.ext_framebuffer_object && vid.support.arb_texture_non_power_of_two && vid.samples < 2;
        textype_t textype = TEXTYPE_COLORBUFFER;
 
+       // clear the pointers to rendertargets from last frame as they're stale
+       r_fb.rt_screen = NULL;
+       r_fb.rt_bloom = NULL;
+
        switch (vid.renderpath)
        {
-       case RENDERPATH_GL20:
+       case RENDERPATH_GL32:
                r_fb.usedepthtextures = r_usedepthtextures.integer != 0;
-               if (vid.support.ext_framebuffer_object && vid.support.arb_texture_non_power_of_two)
-               {
-                       if (r_viewfbo.integer == 2) textype = TEXTYPE_COLORBUFFER16F;
-                       if (r_viewfbo.integer == 3) textype = TEXTYPE_COLORBUFFER32F;
-               }
+               if (r_viewfbo.integer == 2) textype = TEXTYPE_COLORBUFFER16F;
+               if (r_viewfbo.integer == 3) textype = TEXTYPE_COLORBUFFER32F;
                break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               return; // don't bother
        case RENDERPATH_GLES2:
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
                r_fb.usedepthtextures = false;
                break;
-       case RENDERPATH_SOFT:
-               r_fb.usedepthtextures = true;
-               break;
        }
 
        if (r_viewscale_fpsscaling.integer)
@@ -6303,21 +5097,6 @@ static void R_Bloom_StartFrame(void)
 
        R_GetScaledViewSize(r_refdef.view.width, r_refdef.view.height, &viewwidth, &viewheight);
 
-       switch(vid.renderpath)
-       {
-       case RENDERPATH_GL20:
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_SOFT:
-       case RENDERPATH_GLES2:
-               break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               return;
-       }
-
        // set bloomwidth and bloomheight to the bloom resolution that will be
        // used (often less than the screen resolution for faster rendering)
        r_fb.bloomwidth = bound(1, r_bloom_resolution.integer, vid.width);
@@ -6327,20 +5106,10 @@ static void R_Bloom_StartFrame(void)
        r_fb.bloomheight = bound(1, r_fb.bloomheight, (int)vid.maxtexturesize_2d);
 
        // calculate desired texture sizes
-       if (vid.support.arb_texture_non_power_of_two)
-       {
-               screentexturewidth = vid.width;
-               screentextureheight = vid.height;
-               bloomtexturewidth = r_fb.bloomwidth;
-               bloomtextureheight = r_fb.bloomheight;
-       }
-       else
-       {
-               for (screentexturewidth  = 1;screentexturewidth  < vid.width       ;screentexturewidth  *= 2);
-               for (screentextureheight = 1;screentextureheight < vid.height      ;screentextureheight *= 2);
-               for (bloomtexturewidth   = 1;bloomtexturewidth   < r_fb.bloomwidth ;bloomtexturewidth   *= 2);
-               for (bloomtextureheight  = 1;bloomtextureheight  < r_fb.bloomheight;bloomtextureheight  *= 2);
-       }
+       screentexturewidth = viewwidth;
+       screentextureheight = viewheight;
+       bloomtexturewidth = r_fb.bloomwidth;
+       bloomtextureheight = r_fb.bloomheight;
 
        if ((r_bloom.integer || (!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))) && ((r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512) || r_refdef.view.width > (int)vid.maxtexturesize_2d || r_refdef.view.height > (int)vid.maxtexturesize_2d))
        {
@@ -6349,55 +5118,15 @@ static void R_Bloom_StartFrame(void)
                Cvar_SetValueQuick(&r_damageblur, 0);
        }
 
-       if (!((r_glsl_postprocess.integer || r_fxaa.integer) || (!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) || !vid_gammatables_trivial)
-        && !r_bloom.integer
-        && (R_Stereo_Active() || (r_motionblur.value <= 0 && r_damageblur.value <= 0))
-        && !useviewfbo
-        && r_viewscale.value == 1.0f
-        && !r_viewscale_fpsscaling.integer)
-               screentexturewidth = screentextureheight = 0;
-       if (!r_bloom.integer)
-               bloomtexturewidth = bloomtextureheight = 0;
-
-       // allocate textures as needed
-       if (r_fb.screentexturewidth != screentexturewidth
-        || r_fb.screentextureheight != screentextureheight
-        || r_fb.bloomtexturewidth != bloomtexturewidth
-        || r_fb.bloomtextureheight != bloomtextureheight
-        || r_fb.textype != textype
-        || useviewfbo != (r_fb.fbo != 0))
+       // allocate motionblur ghost texture if needed - this is the only persistent texture and is only useful on the main view
+       if (r_refdef.view.ismain && (r_fb.screentexturewidth != screentexturewidth || r_fb.screentextureheight != screentextureheight || r_fb.textype != textype))
        {
-               for (i = 0;i < (int)(sizeof(r_fb.bloomtexture)/sizeof(r_fb.bloomtexture[i]));i++)
-               {
-                       if (r_fb.bloomtexture[i])
-                               R_FreeTexture(r_fb.bloomtexture[i]);
-                       r_fb.bloomtexture[i] = NULL;
-
-                       if (r_fb.bloomfbo[i])
-                               R_Mesh_DestroyFramebufferObject(r_fb.bloomfbo[i]);
-                       r_fb.bloomfbo[i] = 0;
-               }
-
-               if (r_fb.fbo)
-                       R_Mesh_DestroyFramebufferObject(r_fb.fbo);
-               r_fb.fbo = 0;
-
-               if (r_fb.colortexture)
-                       R_FreeTexture(r_fb.colortexture);
-               r_fb.colortexture = NULL;
-
-               if (r_fb.depthtexture)
-                       R_FreeTexture(r_fb.depthtexture);
-               r_fb.depthtexture = NULL;
-
                if (r_fb.ghosttexture)
                        R_FreeTexture(r_fb.ghosttexture);
                r_fb.ghosttexture = NULL;
 
                r_fb.screentexturewidth = screentexturewidth;
                r_fb.screentextureheight = screentextureheight;
-               r_fb.bloomtexturewidth = bloomtexturewidth;
-               r_fb.bloomtextureheight = bloomtextureheight;
                r_fb.textype = textype;
 
                if (r_fb.screentexturewidth && r_fb.screentextureheight)
@@ -6405,172 +5134,73 @@ static void R_Bloom_StartFrame(void)
                        if (r_motionblur.value > 0 || r_damageblur.value > 0)
                                r_fb.ghosttexture = R_LoadTexture2D(r_main_texturepool, "framebuffermotionblur", r_fb.screentexturewidth, r_fb.screentextureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
                        r_fb.ghosttexture_valid = false;
-                       r_fb.colortexture = R_LoadTexture2D(r_main_texturepool, "framebuffercolor", r_fb.screentexturewidth, r_fb.screentextureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
-                       if (useviewfbo)
-                       {
-                               r_fb.depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, "framebufferdepth", r_fb.screentexturewidth, r_fb.screentextureheight, TEXTYPE_DEPTHBUFFER24STENCIL8);
-                               r_fb.fbo = R_Mesh_CreateFramebufferObject(r_fb.depthtexture, r_fb.colortexture, NULL, NULL, NULL);
-                               R_Mesh_SetRenderTargets(r_fb.fbo, r_fb.depthtexture, r_fb.colortexture, NULL, NULL, NULL);
-                       }
-               }
-
-               if (r_fb.bloomtexturewidth && r_fb.bloomtextureheight)
-               {
-                       for (i = 0;i < (int)(sizeof(r_fb.bloomtexture)/sizeof(r_fb.bloomtexture[i]));i++)
-                       {
-                               r_fb.bloomtexture[i] = R_LoadTexture2D(r_main_texturepool, "framebufferbloom", r_fb.bloomtexturewidth, r_fb.bloomtextureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
-                               if (useviewfbo)
-                                       r_fb.bloomfbo[i] = R_Mesh_CreateFramebufferObject(NULL, r_fb.bloomtexture[i], NULL, NULL, NULL);
-                       }
                }
        }
 
-       // bloom texture is a different resolution
-       r_fb.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.width);
-       r_fb.bloomheight = r_fb.bloomwidth * r_refdef.view.height / r_refdef.view.width;
-       r_fb.bloomheight = bound(1, r_fb.bloomheight, r_refdef.view.height);
-       r_fb.bloomwidth = bound(1, r_fb.bloomwidth, r_fb.bloomtexturewidth);
-       r_fb.bloomheight = bound(1, r_fb.bloomheight, r_fb.bloomtextureheight);
-
-       // set up a texcoord array for the full resolution screen image
-       // (we have to keep this around to copy back during final render)
-       r_fb.screentexcoord2f[0] = 0;
-       r_fb.screentexcoord2f[1] = 1.0f;
-       r_fb.screentexcoord2f[2] = (float)viewwidth     / (float)r_fb.screentexturewidth;
-       r_fb.screentexcoord2f[3] = 1.0f;
-       r_fb.screentexcoord2f[4] = (float)viewwidth     / (float)r_fb.screentexturewidth;
-       r_fb.screentexcoord2f[5] = 1.0f - (float)viewheight / (float)r_fb.screentextureheight;
-       r_fb.screentexcoord2f[6] = 0;
-       r_fb.screentexcoord2f[7] = 1.0f - (float)viewheight / (float)r_fb.screentextureheight;
-
-       // set up a texcoord array for the reduced resolution bloom image
-       // (which will be additive blended over the screen image)
-       r_fb.bloomtexcoord2f[0] = 0;
-       r_fb.bloomtexcoord2f[1] = (float)r_fb.bloomheight / (float)r_fb.bloomtextureheight;
-       r_fb.bloomtexcoord2f[2] = (float)r_fb.bloomwidth  / (float)r_fb.bloomtexturewidth;
-       r_fb.bloomtexcoord2f[3] = (float)r_fb.bloomheight / (float)r_fb.bloomtextureheight;
-       r_fb.bloomtexcoord2f[4] = (float)r_fb.bloomwidth  / (float)r_fb.bloomtexturewidth;
-       r_fb.bloomtexcoord2f[5] = 0;
-       r_fb.bloomtexcoord2f[6] = 0;
-       r_fb.bloomtexcoord2f[7] = 0;
-
-       switch(vid.renderpath)
+       if (r_bloom.integer)
        {
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GL20:
-       case RENDERPATH_SOFT:
-       case RENDERPATH_GLES1:
-       case RENDERPATH_GLES2:
-               break;
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-               for (i = 0;i < 4;i++)
-               {
-                       r_fb.screentexcoord2f[i*2+0] += 0.5f / (float)r_fb.screentexturewidth;
-                       r_fb.screentexcoord2f[i*2+1] += 0.5f / (float)r_fb.screentextureheight;
-                       r_fb.bloomtexcoord2f[i*2+0] += 0.5f / (float)r_fb.bloomtexturewidth;
-                       r_fb.bloomtexcoord2f[i*2+1] += 0.5f / (float)r_fb.bloomtextureheight;
-               }
-               break;
+               // bloom texture is a different resolution
+               r_fb.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.width);
+               r_fb.bloomheight = r_fb.bloomwidth * r_refdef.view.height / r_refdef.view.width;
+               r_fb.bloomheight = bound(1, r_fb.bloomheight, r_refdef.view.height);
        }
+       else
+               r_fb.bloomwidth = r_fb.bloomheight = 0;
 
-       R_Viewport_InitOrtho(&r_fb.bloomviewport, &identitymatrix, r_fb.fbo ? 0 : r_refdef.view.x, r_fb.fbo ? 0 : r_refdef.view.y, r_fb.bloomwidth, r_fb.bloomheight, 0, 0, 1, 1, -10, 100, NULL);
+       r_fb.rt_screen = R_RenderTarget_Get(screentexturewidth, screentextureheight, TEXTYPE_DEPTHBUFFER24STENCIL8, true, textype, TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED);
 
-       if (r_fb.fbo)
-               r_refdef.view.clear = true;
+       r_refdef.view.clear = true;
 }
 
 static void R_Bloom_MakeTexture(void)
 {
        int x, range, dir;
        float xoffset, yoffset, r, brighten;
-       rtexture_t *intex;
        float colorscale = r_bloom_colorscale.value;
+       r_viewport_t bloomviewport;
+       r_rendertarget_t *prev, *cur;
+       textype_t textype = r_fb.rt_screen->colortextype[0];
 
        r_refdef.stats[r_stat_bloom]++;
-    
-#if 0
-    // this copy is unnecessary since it happens in R_BlendView already
-       if (!r_fb.fbo)
-       {
-               R_Mesh_CopyToTexture(r_fb.colortexture, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
-               r_refdef.stats[r_stat_bloom_copypixels] += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
-       }
-#endif
+
+       R_Viewport_InitOrtho(&bloomviewport, &identitymatrix, 0, 0, r_fb.bloomwidth, r_fb.bloomheight, 0, 0, 1, 1, -10, 100, NULL);
 
        // scale down screen texture to the bloom texture size
        CHECKGLERROR
-       r_fb.bloomindex = 0;
-       R_Mesh_SetRenderTargets(r_fb.bloomfbo[r_fb.bloomindex], NULL, r_fb.bloomtexture[r_fb.bloomindex], NULL, NULL, NULL);
-       R_SetViewport(&r_fb.bloomviewport);
+       prev = r_fb.rt_screen;
+       cur = R_RenderTarget_Get(r_fb.bloomwidth, r_fb.bloomheight, TEXTYPE_UNUSED, false, textype, TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED);
+       R_Mesh_SetRenderTargets(cur->fbo, NULL, cur->colortexture[0], NULL, NULL, NULL);
+       R_SetViewport(&bloomviewport);
        GL_CullFace(GL_NONE);
        GL_DepthTest(false);
        GL_BlendFunc(GL_ONE, GL_ZERO);
        GL_Color(colorscale, colorscale, colorscale, 1);
-       // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that...
-       switch(vid.renderpath)
-       {
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GL20:
-       case RENDERPATH_GLES1:
-       case RENDERPATH_GLES2:
-       case RENDERPATH_SOFT:
-               R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.screentexcoord2f);
-               break;
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-               R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_fb.screentexcoord2f);
-               break;
-       }
+       R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, prev->texcoord2f);
        // TODO: do boxfilter scale-down in shader?
-       R_SetupShader_Generic(r_fb.colortexture, NULL, GL_MODULATE, 1, false, true, true);
+       R_SetupShader_Generic(prev->colortexture[0], false, true, true);
        R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
        r_refdef.stats[r_stat_bloom_drawpixels] += r_fb.bloomwidth * r_fb.bloomheight;
-
        // we now have a properly scaled bloom image
-       if (!r_fb.bloomfbo[r_fb.bloomindex])
-       {
-               // copy it into the bloom texture
-               R_Mesh_CopyToTexture(r_fb.bloomtexture[r_fb.bloomindex], 0, 0, r_fb.bloomviewport.x, r_fb.bloomviewport.y, r_fb.bloomviewport.width, r_fb.bloomviewport.height);
-               r_refdef.stats[r_stat_bloom_copypixels] += r_fb.bloomviewport.width * r_fb.bloomviewport.height;
-       }
 
-       // multiply bloom image by itself as many times as desired
+       // multiply bloom image by itself as many times as desired to darken it
+       // TODO: if people actually use this it could be done more quickly in the previous shader pass
        for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
        {
-               intex = r_fb.bloomtexture[r_fb.bloomindex];
-               r_fb.bloomindex ^= 1;
-               R_Mesh_SetRenderTargets(r_fb.bloomfbo[r_fb.bloomindex], NULL, r_fb.bloomtexture[r_fb.bloomindex], NULL, NULL, NULL);
+               prev = cur;
+               cur = R_RenderTarget_Get(r_fb.bloomwidth, r_fb.bloomheight, TEXTYPE_UNUSED, false, textype, TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED);
+               R_Mesh_SetRenderTargets(cur->fbo, NULL, cur->colortexture[0], NULL, NULL, NULL);
                x *= 2;
                r = bound(0, r_bloom_colorexponent.value / x, 1); // always 0.5 to 1
-               if (!r_fb.bloomfbo[r_fb.bloomindex])
-               {
-                       GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR); // square it and multiply by two
-                       GL_Color(r,r,r,1); // apply fix factor
-               }
-               else
-               {
-                       if(x <= 2)
-                               GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
-                       GL_BlendFunc(GL_SRC_COLOR, GL_ZERO); // square it
-                       GL_Color(1,1,1,1); // no fix factor supported here
-               }
-               R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.bloomtexcoord2f);
-               R_SetupShader_Generic(intex, NULL, GL_MODULATE, 1, false, true, false);
+               if(x <= 2)
+                       GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 0);
+               GL_BlendFunc(GL_SRC_COLOR, GL_ZERO); // square it
+               GL_Color(1,1,1,1); // no fix factor supported here
+               R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, prev->texcoord2f);
+               R_SetupShader_Generic(prev->colortexture[0], false, true, false);
                R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
                r_refdef.stats[r_stat_bloom_drawpixels] += r_fb.bloomwidth * r_fb.bloomheight;
-
-               if (!r_fb.bloomfbo[r_fb.bloomindex])
-               {
-                       // copy the darkened image to a texture
-                       R_Mesh_CopyToTexture(r_fb.bloomtexture[r_fb.bloomindex], 0, 0, r_fb.bloomviewport.x, r_fb.bloomviewport.y, r_fb.bloomviewport.width, r_fb.bloomviewport.height);
-                       r_refdef.stats[r_stat_bloom_copypixels] += r_fb.bloomviewport.width * r_fb.bloomviewport.height;
-               }
        }
+       CHECKGLERROR
 
        range = r_bloom_blur.integer * r_fb.bloomwidth / 320;
        brighten = r_bloom_brighten.value;
@@ -6580,29 +5210,32 @@ static void R_Bloom_MakeTexture(void)
 
        for (dir = 0;dir < 2;dir++)
        {
-               intex = r_fb.bloomtexture[r_fb.bloomindex];
-               r_fb.bloomindex ^= 1;
-               R_Mesh_SetRenderTargets(r_fb.bloomfbo[r_fb.bloomindex], NULL, r_fb.bloomtexture[r_fb.bloomindex], NULL, NULL, NULL);
+               prev = cur;
+               cur = R_RenderTarget_Get(r_fb.bloomwidth, r_fb.bloomheight, TEXTYPE_UNUSED, false, textype, TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED);
+               R_Mesh_SetRenderTargets(cur->fbo, NULL, cur->colortexture[0], NULL, NULL, NULL);
                // blend on at multiple vertical offsets to achieve a vertical blur
                // TODO: do offset blends using GLSL
                // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
+               CHECKGLERROR
                GL_BlendFunc(GL_ONE, GL_ZERO);
-               R_SetupShader_Generic(intex, NULL, GL_MODULATE, 1, false, true, false);
+               CHECKGLERROR
+               R_SetupShader_Generic(prev->colortexture[0], false, true, false);
+               CHECKGLERROR
                for (x = -range;x <= range;x++)
                {
                        if (!dir){xoffset = 0;yoffset = x;}
                        else {xoffset = x;yoffset = 0;}
-                       xoffset /= (float)r_fb.bloomtexturewidth;
-                       yoffset /= (float)r_fb.bloomtextureheight;
+                       xoffset /= (float)prev->texturewidth;
+                       yoffset /= (float)prev->textureheight;
                        // compute a texcoord array with the specified x and y offset
-                       r_fb.offsettexcoord2f[0] = xoffset+r_fb.bloomtexcoord2f[0];
-                       r_fb.offsettexcoord2f[1] = yoffset+r_fb.bloomtexcoord2f[1];
-                       r_fb.offsettexcoord2f[2] = xoffset+r_fb.bloomtexcoord2f[2];
-                       r_fb.offsettexcoord2f[3] = yoffset+r_fb.bloomtexcoord2f[3];
-                       r_fb.offsettexcoord2f[4] = xoffset+r_fb.bloomtexcoord2f[4];
-                       r_fb.offsettexcoord2f[5] = yoffset+r_fb.bloomtexcoord2f[5];
-                       r_fb.offsettexcoord2f[6] = xoffset+r_fb.bloomtexcoord2f[6];
-                       r_fb.offsettexcoord2f[7] = yoffset+r_fb.bloomtexcoord2f[7];
+                       r_fb.offsettexcoord2f[0] = xoffset+prev->texcoord2f[0];
+                       r_fb.offsettexcoord2f[1] = yoffset+prev->texcoord2f[1];
+                       r_fb.offsettexcoord2f[2] = xoffset+prev->texcoord2f[2];
+                       r_fb.offsettexcoord2f[3] = yoffset+prev->texcoord2f[3];
+                       r_fb.offsettexcoord2f[4] = xoffset+prev->texcoord2f[4];
+                       r_fb.offsettexcoord2f[5] = yoffset+prev->texcoord2f[5];
+                       r_fb.offsettexcoord2f[6] = xoffset+prev->texcoord2f[6];
+                       r_fb.offsettexcoord2f[7] = yoffset+prev->texcoord2f[7];
                        // this r value looks like a 'dot' particle, fading sharply to
                        // black at the edges
                        // (probably not realistic but looks good enough)
@@ -6610,250 +5243,161 @@ static void R_Bloom_MakeTexture(void)
                        //r = brighten/(range*2+1);
                        r = brighten / (range * 2 + 1);
                        if(range >= 1)
-                               r *= (1 - x*x/(float)(range*range));
+                               r *= (1 - x*x/(float)((range+1)*(range+1)));
+                       if (r <= 0)
+                               continue;
+                       CHECKGLERROR
                        GL_Color(r, r, r, 1);
+                       CHECKGLERROR
                        R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.offsettexcoord2f);
+                       CHECKGLERROR
                        R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
                        r_refdef.stats[r_stat_bloom_drawpixels] += r_fb.bloomwidth * r_fb.bloomheight;
+                       CHECKGLERROR
                        GL_BlendFunc(GL_ONE, GL_ONE);
-               }
-
-               if (!r_fb.bloomfbo[r_fb.bloomindex])
-               {
-                       // copy the vertically or horizontally blurred bloom view to a texture
-                       R_Mesh_CopyToTexture(r_fb.bloomtexture[r_fb.bloomindex], 0, 0, r_fb.bloomviewport.x, r_fb.bloomviewport.y, r_fb.bloomviewport.width, r_fb.bloomviewport.height);
-                       r_refdef.stats[r_stat_bloom_copypixels] += r_fb.bloomviewport.width * r_fb.bloomviewport.height;
+                       CHECKGLERROR
                }
        }
+
+       // now we have the bloom image, so keep track of it
+       r_fb.rt_bloom = cur;
 }
 
 static void R_BlendView(int viewfbo, rtexture_t *viewdepthtexture, rtexture_t *viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
 {
        dpuint64 permutation;
        float uservecs[4][4];
+       rtexture_t *viewtexture;
+       rtexture_t *bloomtexture;
 
        R_EntityMatrix(&identitymatrix);
 
-       switch (vid.renderpath)
-       {
-       case RENDERPATH_GL20:
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_SOFT:
-       case RENDERPATH_GLES2:
-               permutation =
-                         (r_fb.bloomtexture[r_fb.bloomindex] ? SHADERPERMUTATION_BLOOM : 0)
-                       | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
-                       | (!vid_gammatables_trivial ? SHADERPERMUTATION_GAMMARAMPS : 0)
-                       | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
-                       | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
-
-               if (r_fb.colortexture)
+       if(r_refdef.view.ismain && !R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0) && r_fb.ghosttexture)
+       {
+               // declare variables
+               float blur_factor, blur_mouseaccel, blur_velocity;
+               static float blur_average; 
+               static vec3_t blur_oldangles; // used to see how quickly the mouse is moving
+
+               // set a goal for the factoring
+               blur_velocity = bound(0, (VectorLength(cl.movement_velocity) - r_motionblur_velocityfactor_minspeed.value) 
+                       / max(1, r_motionblur_velocityfactor_maxspeed.value - r_motionblur_velocityfactor_minspeed.value), 1);
+               blur_mouseaccel = bound(0, ((fabs(VectorLength(cl.viewangles) - VectorLength(blur_oldangles)) * 10) - r_motionblur_mousefactor_minspeed.value) 
+                       / max(1, r_motionblur_mousefactor_maxspeed.value - r_motionblur_mousefactor_minspeed.value), 1);
+               blur_factor = ((blur_velocity * r_motionblur_velocityfactor.value) 
+                       + (blur_mouseaccel * r_motionblur_mousefactor.value));
+
+               // from the goal, pick an averaged value between goal and last value
+               cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_averaging.value), 1);
+               blur_average = blur_average * (1 - cl.motionbluralpha) + blur_factor * cl.motionbluralpha;
+
+               // enforce minimum amount of blur 
+               blur_factor = blur_average * (1 - r_motionblur_minblur.value) + r_motionblur_minblur.value;
+
+               //Con_Printf("motionblur: direct factor: %f, averaged factor: %f, velocity: %f, mouse accel: %f \n", blur_factor, blur_average, blur_velocity, blur_mouseaccel);
+
+               // calculate values into a standard alpha
+               cl.motionbluralpha = 1 - exp(-
+                               (
+                                       (r_motionblur.value * blur_factor / 80)
+                                       +
+                                       (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
+                               )
+                               /
+                               max(0.0001, cl.time - cl.oldtime) // fps independent
+                               );
+
+               // randomization for the blur value to combat persistent ghosting
+               cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
+               cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
+
+               // apply the blur
+               R_ResetViewRendering2D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
+               if (cl.motionbluralpha > 0 && !r_refdef.envmap && r_fb.ghosttexture_valid)
                {
-                       if (!r_fb.fbo)
-                       {
-                               R_Mesh_CopyToTexture(r_fb.colortexture, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
-                               r_refdef.stats[r_stat_bloom_copypixels] += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
-                       }
-
-                       if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0) && r_fb.ghosttexture)
-                       {
-                               // declare variables
-                               float blur_factor, blur_mouseaccel, blur_velocity;
-                               static float blur_average; 
-                               static vec3_t blur_oldangles; // used to see how quickly the mouse is moving
-
-                               // set a goal for the factoring
-                               blur_velocity = bound(0, (VectorLength(cl.movement_velocity) - r_motionblur_velocityfactor_minspeed.value) 
-                                       / max(1, r_motionblur_velocityfactor_maxspeed.value - r_motionblur_velocityfactor_minspeed.value), 1);
-                               blur_mouseaccel = bound(0, ((fabs(VectorLength(cl.viewangles) - VectorLength(blur_oldangles)) * 10) - r_motionblur_mousefactor_minspeed.value) 
-                                       / max(1, r_motionblur_mousefactor_maxspeed.value - r_motionblur_mousefactor_minspeed.value), 1);
-                               blur_factor = ((blur_velocity * r_motionblur_velocityfactor.value) 
-                                       + (blur_mouseaccel * r_motionblur_mousefactor.value));
-
-                               // from the goal, pick an averaged value between goal and last value
-                               cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_averaging.value), 1);
-                               blur_average = blur_average * (1 - cl.motionbluralpha) + blur_factor * cl.motionbluralpha;
-
-                               // enforce minimum amount of blur 
-                               blur_factor = blur_average * (1 - r_motionblur_minblur.value) + r_motionblur_minblur.value;
-
-                               //Con_Printf("motionblur: direct factor: %f, averaged factor: %f, velocity: %f, mouse accel: %f \n", blur_factor, blur_average, blur_velocity, blur_mouseaccel);
-
-                               // calculate values into a standard alpha
-                               cl.motionbluralpha = 1 - exp(-
-                                               (
-                                                (r_motionblur.value * blur_factor / 80)
-                                                +
-                                                (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
-                                               )
-                                               /
-                                               max(0.0001, cl.time - cl.oldtime) // fps independent
-                                         );
-
-                               // randomization for the blur value to combat persistent ghosting
-                               cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
-                               cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
-
-                               // apply the blur
-                               R_ResetViewRendering2D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
-                               if (cl.motionbluralpha > 0 && !r_refdef.envmap && r_fb.ghosttexture_valid)
-                               {
-                                       GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                                       GL_Color(1, 1, 1, cl.motionbluralpha);
-                                       switch(vid.renderpath)
-                                       {
-                                       case RENDERPATH_GL11:
-                                       case RENDERPATH_GL13:
-                                       case RENDERPATH_GL20:
-                                       case RENDERPATH_GLES1:
-                                       case RENDERPATH_GLES2:
-                                       case RENDERPATH_SOFT:
-                                               R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.screentexcoord2f);
-                                               break;
-                                       case RENDERPATH_D3D9:
-                                       case RENDERPATH_D3D10:
-                                       case RENDERPATH_D3D11:
-                                               R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_fb.screentexcoord2f);
-                                               break;
-                                       }
-                                       R_SetupShader_Generic(r_fb.ghosttexture, NULL, GL_MODULATE, 1, false, true, true);
-                                       R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
-                                       r_refdef.stats[r_stat_bloom_drawpixels] += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
-                               }
+                       GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+                       GL_Color(1, 1, 1, cl.motionbluralpha);
+                       R_CalcTexCoordsForView(0, 0, viewwidth, viewheight, viewwidth, viewheight, r_fb.ghosttexcoord2f);
+                       R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.ghosttexcoord2f);
+                       R_SetupShader_Generic(r_fb.ghosttexture, false, true, true);
+                       R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
+                       r_refdef.stats[r_stat_bloom_drawpixels] += viewwidth * viewheight;
+               }
 
-                               // updates old view angles for next pass
-                               VectorCopy(cl.viewangles, blur_oldangles);
+               // updates old view angles for next pass
+               VectorCopy(cl.viewangles, blur_oldangles);
 
-                               // copy view into the ghost texture
-                               R_Mesh_CopyToTexture(r_fb.ghosttexture, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
-                               r_refdef.stats[r_stat_bloom_copypixels] += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
-                               r_fb.ghosttexture_valid = true;
-                       }
-               }
-               else
-               {
-                       // no r_fb.colortexture means we're rendering to the real fb
-                       // we may still have to do view tint...
-                       if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
-                       {
-                               // apply a color tint to the whole view
-                               R_ResetViewRendering2D(0, NULL, NULL, viewx, viewy, viewwidth, viewheight);
-                               GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
-                               R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
-                               R_SetupShader_Generic_NoTexture(false, true);
-                               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                               R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
-                       }
-                       break; // no screen processing, no bloom, skip it
-               }
+               // copy view into the ghost texture
+               R_Mesh_CopyToTexture(r_fb.ghosttexture, 0, 0, viewx, viewy, viewwidth, viewheight);
+               r_refdef.stats[r_stat_bloom_copypixels] += viewwidth * viewheight;
+               r_fb.ghosttexture_valid = true;
+       }
 
-               if (r_fb.bloomtexture[0])
-               {
-                       // make the bloom texture
-                       R_Bloom_MakeTexture();
-               }
+       if (r_fb.bloomwidth)
+       {
+               // make the bloom texture
+               R_Bloom_MakeTexture();
+       }
 
 #if _MSC_VER >= 1400
 #define sscanf sscanf_s
 #endif
-               memset(uservecs, 0, sizeof(uservecs));
-               if (r_glsl_postprocess_uservec1_enable.integer)
-                       sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
-               if (r_glsl_postprocess_uservec2_enable.integer)
-                       sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
-               if (r_glsl_postprocess_uservec3_enable.integer)
-                       sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
-               if (r_glsl_postprocess_uservec4_enable.integer)
-                       sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
+       memset(uservecs, 0, sizeof(uservecs));
+       if (r_glsl_postprocess_uservec1_enable.integer)
+               sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
+       if (r_glsl_postprocess_uservec2_enable.integer)
+               sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
+       if (r_glsl_postprocess_uservec3_enable.integer)
+               sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
+       if (r_glsl_postprocess_uservec4_enable.integer)
+               sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
+
+       // render to the screen fbo
+       R_ResetViewRendering2D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
+       GL_Color(1, 1, 1, 1);
+       GL_BlendFunc(GL_ONE, GL_ZERO);
 
-               // render to the screen fbo
-               R_ResetViewRendering2D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
-               GL_Color(1, 1, 1, 1);
-               GL_BlendFunc(GL_ONE, GL_ZERO);
+       viewtexture = r_fb.rt_screen->colortexture[0];
+       bloomtexture = r_fb.rt_bloom ? r_fb.rt_bloom->colortexture[0] : NULL;
 
-               switch(vid.renderpath)
+       if (r_rendertarget_debug.integer >= 0)
+       {
+               r_rendertarget_t *rt = (r_rendertarget_t *)Mem_ExpandableArray_RecordAtIndex(&r_fb.rendertargets, r_rendertarget_debug.integer);
+               if (rt && rt->colortexture[0])
                {
-               case RENDERPATH_GL20:
-               case RENDERPATH_GLES2:
-                       R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_fb.screentexcoord2f, r_fb.bloomtexcoord2f);
-                       R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
-                       if (r_glsl_permutation->tex_Texture_First           >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First     , r_fb.colortexture);
-                       if (r_glsl_permutation->tex_Texture_Second          >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Second    , r_fb.bloomtexture[r_fb.bloomindex]);
-                       if (r_glsl_permutation->tex_Texture_GammaRamps      >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps, r_texture_gammaramps       );
-                       if (r_glsl_permutation->loc_ViewTintColor           >= 0) qglUniform4f(r_glsl_permutation->loc_ViewTintColor     , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
-                       if (r_glsl_permutation->loc_PixelSize               >= 0) qglUniform2f(r_glsl_permutation->loc_PixelSize         , 1.0/r_fb.screentexturewidth, 1.0/r_fb.screentextureheight);
-                       if (r_glsl_permutation->loc_UserVec1                >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec1          , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
-                       if (r_glsl_permutation->loc_UserVec2                >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec2          , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
-                       if (r_glsl_permutation->loc_UserVec3                >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec3          , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
-                       if (r_glsl_permutation->loc_UserVec4                >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec4          , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
-                       if (r_glsl_permutation->loc_Saturation              >= 0) qglUniform1f(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
-                       if (r_glsl_permutation->loc_PixelToScreenTexCoord   >= 0) qglUniform2f(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
-                       if (r_glsl_permutation->loc_BloomColorSubtract      >= 0) qglUniform4f(r_glsl_permutation->loc_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
-                       break;
-               case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-                       // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that...
-                       R_Mesh_PrepareVertices_Mesh_Arrays(4, r_d3dscreenvertex3f, NULL, NULL, NULL, NULL, r_fb.screentexcoord2f, r_fb.bloomtexcoord2f);
-                       R_SetupShader_SetPermutationHLSL(SHADERMODE_POSTPROCESS, permutation);
-                       R_Mesh_TexBind(GL20TU_FIRST     , r_fb.colortexture);
-                       R_Mesh_TexBind(GL20TU_SECOND    , r_fb.bloomtexture[r_fb.bloomindex]);
-                       R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
-                       hlslPSSetParameter4f(D3DPSREGISTER_ViewTintColor        , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
-                       hlslPSSetParameter2f(D3DPSREGISTER_PixelSize            , 1.0/r_fb.screentexturewidth, 1.0/r_fb.screentextureheight);
-                       hlslPSSetParameter4f(D3DPSREGISTER_UserVec1             , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
-                       hlslPSSetParameter4f(D3DPSREGISTER_UserVec2             , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
-                       hlslPSSetParameter4f(D3DPSREGISTER_UserVec3             , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
-                       hlslPSSetParameter4f(D3DPSREGISTER_UserVec4             , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
-                       hlslPSSetParameter1f(D3DPSREGISTER_Saturation           , r_glsl_saturation.value);
-                       hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
-                       hlslPSSetParameter4f(D3DPSREGISTER_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
-#endif
-                       break;
-               case RENDERPATH_D3D10:
-                       Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-                       break;
-               case RENDERPATH_D3D11:
-                       Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-                       break;
-               case RENDERPATH_SOFT:
-                       R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_fb.screentexcoord2f, r_fb.bloomtexcoord2f);
-                       R_SetupShader_SetPermutationSoft(SHADERMODE_POSTPROCESS, permutation);
-                       R_Mesh_TexBind(GL20TU_FIRST     , r_fb.colortexture);
-                       R_Mesh_TexBind(GL20TU_SECOND    , r_fb.bloomtexture[r_fb.bloomindex]);
-                       R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps       );
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ViewTintColor     , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
-                       DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_PixelSize         , 1.0/r_fb.screentexturewidth, 1.0/r_fb.screentextureheight);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_UserVec1          , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_UserVec2          , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_UserVec3          , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_UserVec4          , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
-                       DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_Saturation        , r_glsl_saturation.value);
-                       DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
-                       DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
-                       break;
-               default:
-                       break;
-               }
-               R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
-               r_refdef.stats[r_stat_bloom_drawpixels] += r_refdef.view.width * r_refdef.view.height;
-               break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
-               {
-                       // apply a color tint to the whole view
-                       R_ResetViewRendering2D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
-                       GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
-                       R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
-                       R_SetupShader_Generic_NoTexture(false, true);
-                       GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                       R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
+                       viewtexture = rt->colortexture[0];
+                       bloomtexture = NULL;
                }
+       }
+
+       R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_fb.rt_screen->texcoord2f, bloomtexture ? r_fb.rt_bloom->texcoord2f : NULL);
+       switch(vid.renderpath)
+       {
+       case RENDERPATH_GL32:
+       case RENDERPATH_GLES2:
+               permutation =
+                       (r_fb.bloomwidth ? SHADERPERMUTATION_BLOOM : 0)
+                       | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
+                       | (!vid_gammatables_trivial ? SHADERPERMUTATION_GAMMARAMPS : 0)
+                       | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
+                       | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
+               R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
+               if (r_glsl_permutation->tex_Texture_First           >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First     , viewtexture);
+               if (r_glsl_permutation->tex_Texture_Second          >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Second    , bloomtexture);
+               if (r_glsl_permutation->tex_Texture_GammaRamps      >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps, r_texture_gammaramps       );
+               if (r_glsl_permutation->loc_ViewTintColor           >= 0) qglUniform4f(r_glsl_permutation->loc_ViewTintColor     , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
+               if (r_glsl_permutation->loc_PixelSize               >= 0) qglUniform2f(r_glsl_permutation->loc_PixelSize         , 1.0/r_fb.screentexturewidth, 1.0/r_fb.screentextureheight);
+               if (r_glsl_permutation->loc_UserVec1                >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec1          , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
+               if (r_glsl_permutation->loc_UserVec2                >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec2          , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
+               if (r_glsl_permutation->loc_UserVec3                >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec3          , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
+               if (r_glsl_permutation->loc_UserVec4                >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec4          , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
+               if (r_glsl_permutation->loc_Saturation              >= 0) qglUniform1f(r_glsl_permutation->loc_Saturation        , r_glsl_saturation.value);
+               if (r_glsl_permutation->loc_PixelToScreenTexCoord   >= 0) qglUniform2f(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
+               if (r_glsl_permutation->loc_BloomColorSubtract      >= 0) qglUniform4f(r_glsl_permutation->loc_BloomColorSubtract   , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
                break;
        }
+       R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
+       r_refdef.stats[r_stat_bloom_drawpixels] += r_refdef.view.width * r_refdef.view.height;
 }
 
 matrix4x4_t r_waterscrollmatrix;
@@ -6960,8 +5504,6 @@ void R_UpdateVariables(void)
                Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
        r_refdef.polygonfactor = 0;
        r_refdef.polygonoffset = 0;
-       r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
-       r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
 
        r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
        r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
@@ -6988,12 +5530,8 @@ void R_UpdateVariables(void)
        r_gpuskeletal = false;
        switch(vid.renderpath)
        {
-       case RENDERPATH_GL20:
-               r_gpuskeletal = vid.support.arb_uniform_buffer_object && r_glsl_skeletal.integer && !r_showsurfaces.integer; // FIXME add r_showsurfaces support to GLSL skeletal!
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_SOFT:
+       case RENDERPATH_GL32:
+               r_gpuskeletal = r_glsl_skeletal.integer && !r_showsurfaces.integer;
        case RENDERPATH_GLES2:
                if(!vid_gammatables_trivial)
                {
@@ -7030,10 +5568,6 @@ void R_UpdateVariables(void)
                        // remove GLSL gamma texture
                }
                break;
-       case RENDERPATH_GL11:
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               break;
        }
 }
 
@@ -7105,8 +5639,9 @@ static void R_SortEntities(void)
 R_RenderView
 ================
 */
-int dpsoftrast_test;
 extern cvar_t r_shadow_bouncegrid;
+extern cvar_t v_isometric;
+extern void V_MakeViewIsometric(void);
 void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, int x, int y, int width, int height)
 {
        matrix4x4_t originalmatrix = r_refdef.view.matrix, offsetmatrix;
@@ -7115,7 +5650,8 @@ void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, i
        rtexture_t *viewcolortexture = NULL;
        int viewx = r_refdef.view.x, viewy = r_refdef.view.y, viewwidth = r_refdef.view.width, viewheight = r_refdef.view.height;
 
-       dpsoftrast_test = r_test.integer;
+       // finish any 2D rendering that was queued
+       DrawQ_Finish();
 
        if (r_timereport_active)
                R_TimeReport("start");
@@ -7151,7 +5687,7 @@ void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, i
                r_fb.water.enabled = false;
                r_fb.water.numwaterplanes = 0;
 
-               R_RenderScene(fbo, depthtexture, colortexture, x, y, width, height);
+               R_RenderScene(0, NULL, NULL, r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
 
                r_refdef.view.matrix = originalmatrix;
 
@@ -7165,6 +5701,10 @@ void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, i
                return;
        }
 
+       r_refdef.view.usevieworiginculling = !r_trippy.value && r_refdef.view.useperspective;
+       if (v_isometric.integer && r_refdef.view.ismain)
+               V_MakeViewIsometric();
+
        r_refdef.view.colorscale = r_hdr_scenebrightness.value * r_hdr_irisadaptation_value.value;
 
        if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D)
@@ -7176,19 +5716,19 @@ void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, i
 
        R_Shadow_UpdateWorldLightSelection();
 
-       // this will set up r_fb.fbo
+       // this will set up r_fb.rt_screen
        R_Bloom_StartFrame();
 
        // apply bloom brightness offset
-       if(r_fb.bloomtexture[0])
+       if(r_fb.rt_bloom)
                r_refdef.view.colorscale *= r_bloom_scenebrightness.value;
 
        // R_Bloom_StartFrame probably set up an fbo for us to render into, it will be rendered to the window later in R_BlendView
-       if (r_fb.fbo)
+       if (r_fb.rt_screen)
        {
-               viewfbo = r_fb.fbo;
-               viewdepthtexture = r_fb.depthtexture;
-               viewcolortexture = r_fb.colortexture;
+               viewfbo = r_fb.rt_screen->fbo;
+               viewdepthtexture = r_fb.rt_screen->depthtexture;
+               viewcolortexture = r_fb.rt_screen->colortexture[0];
                viewx = 0;
                viewy = 0;
                viewwidth = width;
@@ -7205,7 +5745,7 @@ void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, i
 
        // clear the whole fbo every frame - otherwise the driver will consider
        // it to be an inter-frame texture and stall in multi-gpu configurations
-       if (viewfbo)
+       if (r_fb.rt_screen)
                GL_ScissorTest(false);
        R_ClearScreen(r_refdef.fogenabled);
        if (r_timereport_active)
@@ -7233,7 +5773,7 @@ void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, i
 
        // for the actual view render we use scissoring a fair amount, so scissor
        // test needs to be on
-       if (viewfbo)
+       if (r_fb.rt_screen)
                GL_ScissorTest(true);
        GL_Scissor(viewx, viewy, viewwidth, viewheight);
        R_RenderScene(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
@@ -7242,8 +5782,6 @@ void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, i
        // postprocess uses textures that are not aligned with the viewport we're rendering, so no scissoring
        GL_ScissorTest(false);
 
-       // R_BlendView will render the viewfbo image into the provided fbo using
-       // the postprocess shader (including gamma correction and sRGB)
        R_BlendView(fbo, depthtexture, colortexture, x, y, width, height);
        if (r_timereport_active)
                R_TimeReport("blendview");
@@ -7251,6 +5789,9 @@ void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, i
        r_refdef.view.matrix = originalmatrix;
 
        CHECKGLERROR
+
+       // go back to 2d rendering
+       DrawQ_Start();
 }
 
 void R_RenderWaterPlanes(int viewfbo, rtexture_t *viewdepthtexture, rtexture_t *viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
@@ -7396,16 +5937,6 @@ void R_RenderScene(int viewfbo, rtexture_t *viewdepthtexture, rtexture_t *viewco
        if (r_refdef.scene.extraupdate)
                S_ExtraUpdate ();
 
-       if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && !r_shadows_drawafterrtlighting.integer && r_refdef.scene.lightmapintensity > 0)
-       {
-               R_ResetViewRendering3D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
-               R_Shadow_DrawModelShadows();
-               R_ResetViewRendering3D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
-               // don't let sound skip if going slow
-               if (r_refdef.scene.extraupdate)
-                       S_ExtraUpdate ();
-       }
-
        if (!r_shadow_usingdeferredprepass)
        {
                R_Shadow_DrawLights();
@@ -7417,16 +5948,6 @@ void R_RenderScene(int viewfbo, rtexture_t *viewdepthtexture, rtexture_t *viewco
        if (r_refdef.scene.extraupdate)
                S_ExtraUpdate ();
 
-       if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && r_shadows_drawafterrtlighting.integer && r_refdef.scene.lightmapintensity > 0)
-       {
-               R_ResetViewRendering3D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
-               R_Shadow_DrawModelShadows();
-               R_ResetViewRendering3D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
-               // don't let sound skip if going slow
-               if (r_refdef.scene.extraupdate)
-                       S_ExtraUpdate ();
-       }
-
        if (cl.csqc_vidvars.drawworld)
        {
                if (cl_decals_newsystem.integer)
@@ -7505,27 +6026,6 @@ void R_RenderScene(int viewfbo, rtexture_t *viewdepthtexture, rtexture_t *viewco
                        R_TimeReport("coronas");
        }
 
-#if 0
-       {
-               GL_DepthTest(false);
-               qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-               GL_Color(1, 1, 1, 1);
-               qglBegin(GL_POLYGON);
-               qglVertex3f(r_refdef.view.frustumcorner[0][0], r_refdef.view.frustumcorner[0][1], r_refdef.view.frustumcorner[0][2]);
-               qglVertex3f(r_refdef.view.frustumcorner[1][0], r_refdef.view.frustumcorner[1][1], r_refdef.view.frustumcorner[1][2]);
-               qglVertex3f(r_refdef.view.frustumcorner[3][0], r_refdef.view.frustumcorner[3][1], r_refdef.view.frustumcorner[3][2]);
-               qglVertex3f(r_refdef.view.frustumcorner[2][0], r_refdef.view.frustumcorner[2][1], r_refdef.view.frustumcorner[2][2]);
-               qglEnd();
-               qglBegin(GL_POLYGON);
-               qglVertex3f(r_refdef.view.frustumcorner[0][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[0][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[0][2] + 1000 * r_refdef.view.forward[2]);
-               qglVertex3f(r_refdef.view.frustumcorner[1][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[1][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[1][2] + 1000 * r_refdef.view.forward[2]);
-               qglVertex3f(r_refdef.view.frustumcorner[3][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[3][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[3][2] + 1000 * r_refdef.view.forward[2]);
-               qglVertex3f(r_refdef.view.frustumcorner[2][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[2][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[2][2] + 1000 * r_refdef.view.forward[2]);
-               qglEnd();
-               qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-       }
-#endif
-
        // don't let sound skip if going slow
        if (r_refdef.scene.extraupdate)
                S_ExtraUpdate ();
@@ -8165,7 +6665,7 @@ texture_t *R_GetCurrentTexture(texture_t *t)
 
        t->currentmaterialflags = t->basematerialflags;
        t->currentalpha = rsurface.entity->alpha * t->basealpha;
-       if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer || r_trippy.integer))
+       if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_water.integer || r_novis.integer || r_trippy.integer))
                t->currentalpha *= r_wateralpha.value;
        if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay)
                t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // we apply wateralpha later
@@ -8465,12 +6965,12 @@ texture_t *R_GetCurrentTexture(texture_t *t)
                if (t->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
                {
                        // basic lit geometry
-                       R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE, t->basetexture, &t->currenttexmatrix, t->render_lightmap_diffuse[0], t->render_lightmap_diffuse[1], t->render_lightmap_diffuse[2], t->currentalpha);
+                       R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE, t->basetexture, &t->currenttexmatrix, 2, 2, 2, t->currentalpha);
                        // add pants/shirt if needed
                        if (VectorLength2(t->render_colormap_pants) >= (1.0f / 1048576.0f) && t->pantstexture)
-                               R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->pantstexture, &t->currenttexmatrix, t->render_colormap_pants[0] * t->render_lightmap_diffuse[0], t->render_colormap_pants[1] * t->render_lightmap_diffuse[1], t->render_colormap_pants[2] * t->render_lightmap_diffuse[2], t->currentalpha);
+                               R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->pantstexture, &t->currenttexmatrix, 2 * t->render_colormap_pants[0], 2 * t->render_colormap_pants[1], 2 * t->render_colormap_pants[2], t->currentalpha);
                        if (VectorLength2(t->render_colormap_shirt) >= (1.0f / 1048576.0f) && t->shirttexture)
-                               R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->shirttexture, &t->currenttexmatrix, t->render_colormap_shirt[0] * t->render_lightmap_diffuse[0], t->render_colormap_shirt[1] * t->render_lightmap_diffuse[1], t->render_colormap_shirt[2] * t->render_lightmap_diffuse[2], t->currentalpha);
+                               R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->shirttexture, &t->currenttexmatrix, 2 * t->render_colormap_shirt[0], 2 * t->render_colormap_shirt[1], 2 * t->render_colormap_shirt[2], t->currentalpha);
                }
                else
                {
@@ -8575,9 +7075,6 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q
                        rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
                        rsurface.modelnormal3f_vertexbuffer = wantnormals ? ent->animcache_normal3f_vertexbuffer : NULL;
                        rsurface.modelnormal3f_bufferoffset = wantnormals ? ent->animcache_normal3f_bufferoffset : 0;
-                       rsurface.modelvertexmesh = ent->animcache_vertexmesh;
-                       rsurface.modelvertexmesh_vertexbuffer = ent->animcache_vertexmesh_vertexbuffer;
-                       rsurface.modelvertexmesh_bufferoffset = ent->animcache_vertexmesh_bufferoffset;
                }
                else if (wanttangents)
                {
@@ -8590,9 +7087,6 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q
                        rsurface.modeltvector3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
                        rsurface.modelnormal3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
                        model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, rsurface.modelnormal3f, rsurface.modelsvector3f, rsurface.modeltvector3f);
-                       rsurface.modelvertexmesh = NULL;
-                       rsurface.modelvertexmesh_vertexbuffer = NULL;
-                       rsurface.modelvertexmesh_bufferoffset = 0;
                        rsurface.modelvertex3f_vertexbuffer = NULL;
                        rsurface.modelvertex3f_bufferoffset = 0;
                        rsurface.modelvertex3f_vertexbuffer = 0;
@@ -8615,9 +7109,6 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q
                        rsurface.modeltvector3f = NULL;
                        rsurface.modelnormal3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
                        model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, rsurface.modelnormal3f, NULL, NULL);
-                       rsurface.modelvertexmesh = NULL;
-                       rsurface.modelvertexmesh_vertexbuffer = NULL;
-                       rsurface.modelvertexmesh_bufferoffset = 0;
                        rsurface.modelvertex3f_vertexbuffer = NULL;
                        rsurface.modelvertex3f_bufferoffset = 0;
                        rsurface.modelvertex3f_vertexbuffer = 0;
@@ -8640,9 +7131,6 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q
                        rsurface.modeltvector3f = NULL;
                        rsurface.modelnormal3f = NULL;
                        model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, NULL, NULL, NULL);
-                       rsurface.modelvertexmesh = NULL;
-                       rsurface.modelvertexmesh_vertexbuffer = NULL;
-                       rsurface.modelvertexmesh_bufferoffset = 0;
                        rsurface.modelvertex3f_vertexbuffer = NULL;
                        rsurface.modelvertex3f_bufferoffset = 0;
                        rsurface.modelvertex3f_vertexbuffer = 0;
@@ -8673,37 +7161,34 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q
                        r_refdef.stats[r_stat_batch_entitystatic_triangles] += model->surfmesh.num_triangles;
                }
                rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
-               rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-               rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
+               rsurface.modelvertex3f_vertexbuffer = model->surfmesh.data_vertex3f_vertexbuffer;
+               rsurface.modelvertex3f_bufferoffset = model->surfmesh.data_vertex3f_bufferoffset;
                rsurface.modelsvector3f = model->surfmesh.data_svector3f;
-               rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-               rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
+               rsurface.modelsvector3f_vertexbuffer = model->surfmesh.data_svector3f_vertexbuffer;
+               rsurface.modelsvector3f_bufferoffset = model->surfmesh.data_svector3f_bufferoffset;
                rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
-               rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-               rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
+               rsurface.modeltvector3f_vertexbuffer = model->surfmesh.data_tvector3f_vertexbuffer;
+               rsurface.modeltvector3f_bufferoffset = model->surfmesh.data_tvector3f_bufferoffset;
                rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
-               rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-               rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
-               rsurface.modelvertexmesh = model->surfmesh.data_vertexmesh;
-               rsurface.modelvertexmesh_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-               rsurface.modelvertexmesh_bufferoffset = model->surfmesh.vbooffset_vertex3f;
+               rsurface.modelnormal3f_vertexbuffer = model->surfmesh.data_normal3f_vertexbuffer;
+               rsurface.modelnormal3f_bufferoffset = model->surfmesh.data_normal3f_bufferoffset;
                rsurface.modelgeneratedvertex = false;
        }
        rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
-       rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-       rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
+       rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.data_lightmapcolor4f_vertexbuffer;
+       rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.data_lightmapcolor4f_bufferoffset;
        rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
-       rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-       rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
+       rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.data_texcoordtexture2f_vertexbuffer;
+       rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.data_texcoordtexture2f_bufferoffset;
        rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
-       rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-       rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
+       rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.data_texcoordlightmap2f_vertexbuffer;
+       rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.data_texcoordlightmap2f_bufferoffset;
        rsurface.modelskeletalindex4ub = model->surfmesh.data_skeletalindex4ub;
-       rsurface.modelskeletalindex4ub_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-       rsurface.modelskeletalindex4ub_bufferoffset = model->surfmesh.vbooffset_skeletalindex4ub;
+       rsurface.modelskeletalindex4ub_vertexbuffer = model->surfmesh.data_skeletalindex4ub_vertexbuffer;
+       rsurface.modelskeletalindex4ub_bufferoffset = model->surfmesh.data_skeletalindex4ub_bufferoffset;
        rsurface.modelskeletalweight4ub = model->surfmesh.data_skeletalweight4ub;
-       rsurface.modelskeletalweight4ub_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
-       rsurface.modelskeletalweight4ub_bufferoffset = model->surfmesh.vbooffset_skeletalweight4ub;
+       rsurface.modelskeletalweight4ub_vertexbuffer = model->surfmesh.data_skeletalweight4ub_vertexbuffer;
+       rsurface.modelskeletalweight4ub_bufferoffset = model->surfmesh.data_skeletalweight4ub_bufferoffset;
        rsurface.modelelement3i = model->surfmesh.data_element3i;
        rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
        rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
@@ -8746,18 +7231,12 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q
        rsurface.batchskeletalweight4ub = NULL;
        rsurface.batchskeletalweight4ub_vertexbuffer = NULL;
        rsurface.batchskeletalweight4ub_bufferoffset = 0;
-       rsurface.batchvertexmesh = NULL;
-       rsurface.batchvertexmesh_vertexbuffer = NULL;
-       rsurface.batchvertexmesh_bufferoffset = 0;
        rsurface.batchelement3i = NULL;
        rsurface.batchelement3i_indexbuffer = NULL;
        rsurface.batchelement3i_bufferoffset = 0;
        rsurface.batchelement3s = NULL;
        rsurface.batchelement3s_indexbuffer = NULL;
        rsurface.batchelement3s_bufferoffset = 0;
-       rsurface.passcolor4f = NULL;
-       rsurface.passcolor4f_vertexbuffer = NULL;
-       rsurface.passcolor4f_bufferoffset = 0;
        rsurface.forcecurrenttextureupdate = false;
 }
 
@@ -8817,9 +7296,6 @@ void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inve
                rsurface.modeltvector3f = NULL;
                rsurface.modelnormal3f = NULL;
        }
-       rsurface.modelvertexmesh = NULL;
-       rsurface.modelvertexmesh_vertexbuffer = NULL;
-       rsurface.modelvertexmesh_bufferoffset = 0;
        rsurface.modelvertex3f_vertexbuffer = 0;
        rsurface.modelvertex3f_bufferoffset = 0;
        rsurface.modelsvector3f_vertexbuffer = 0;
@@ -8884,18 +7360,12 @@ void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inve
        rsurface.batchskeletalweight4ub = NULL;
        rsurface.batchskeletalweight4ub_vertexbuffer = NULL;
        rsurface.batchskeletalweight4ub_bufferoffset = 0;
-       rsurface.batchvertexmesh = NULL;
-       rsurface.batchvertexmesh_vertexbuffer = NULL;
-       rsurface.batchvertexmesh_bufferoffset = 0;
        rsurface.batchelement3i = NULL;
        rsurface.batchelement3i_indexbuffer = NULL;
        rsurface.batchelement3i_bufferoffset = 0;
        rsurface.batchelement3s = NULL;
        rsurface.batchelement3s_indexbuffer = NULL;
        rsurface.batchelement3s_bufferoffset = 0;
-       rsurface.passcolor4f = NULL;
-       rsurface.passcolor4f_vertexbuffer = NULL;
-       rsurface.passcolor4f_bufferoffset = 0;
        rsurface.forcecurrenttextureupdate = true;
 
        if (rsurface.modelnumvertices && rsurface.modelelement3i)
@@ -8946,6 +7416,46 @@ float RSurf_FogVertex(const float *v)
        return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
 }
 
+void RSurf_UploadBuffersForBatch(void)
+{
+       // upload buffer data for generated vertex data (dynamicvertex case) or index data (copytriangles case) and models that lack it to begin with (e.g. DrawQ_FlushUI)
+       // note that if rsurface.batchvertex3f_vertexbuffer is NULL, dynamicvertex is forced as we don't account for the proper base vertex here.
+       if (rsurface.batchvertex3f && !rsurface.batchvertex3f_vertexbuffer)
+               rsurface.batchvertex3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f, R_BUFFERDATA_VERTEX, &rsurface.batchvertex3f_bufferoffset);
+       if (rsurface.batchsvector3f && !rsurface.batchsvector3f_vertexbuffer)
+               rsurface.batchsvector3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchsvector3f, R_BUFFERDATA_VERTEX, &rsurface.batchsvector3f_bufferoffset);
+       if (rsurface.batchtvector3f && !rsurface.batchtvector3f_vertexbuffer)
+               rsurface.batchtvector3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchtvector3f, R_BUFFERDATA_VERTEX, &rsurface.batchtvector3f_bufferoffset);
+       if (rsurface.batchnormal3f && !rsurface.batchnormal3f_vertexbuffer)
+               rsurface.batchnormal3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f, R_BUFFERDATA_VERTEX, &rsurface.batchnormal3f_bufferoffset);
+       if (rsurface.batchlightmapcolor4f && !rsurface.batchlightmapcolor4f_vertexbuffer)
+               rsurface.batchlightmapcolor4f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[4]), rsurface.batchlightmapcolor4f, R_BUFFERDATA_VERTEX, &rsurface.batchlightmapcolor4f_bufferoffset);
+       if (rsurface.batchtexcoordtexture2f && !rsurface.batchtexcoordtexture2f_vertexbuffer)
+               rsurface.batchtexcoordtexture2f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[2]), rsurface.batchtexcoordtexture2f, R_BUFFERDATA_VERTEX, &rsurface.batchtexcoordtexture2f_bufferoffset);
+       if (rsurface.batchtexcoordlightmap2f && !rsurface.batchtexcoordlightmap2f_vertexbuffer)
+               rsurface.batchtexcoordlightmap2f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[2]), rsurface.batchtexcoordlightmap2f, R_BUFFERDATA_VERTEX, &rsurface.batchtexcoordlightmap2f_bufferoffset);
+       if (rsurface.batchskeletalindex4ub && !rsurface.batchskeletalindex4ub_vertexbuffer)
+               rsurface.batchskeletalindex4ub_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(unsigned char[4]), rsurface.batchskeletalindex4ub, R_BUFFERDATA_VERTEX, &rsurface.batchskeletalindex4ub_bufferoffset);
+       if (rsurface.batchskeletalweight4ub && !rsurface.batchskeletalweight4ub_vertexbuffer)
+               rsurface.batchskeletalweight4ub_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(unsigned char[4]), rsurface.batchskeletalweight4ub, R_BUFFERDATA_VERTEX, &rsurface.batchskeletalweight4ub_bufferoffset);
+
+       if (rsurface.batchelement3s && !rsurface.batchelement3s_indexbuffer)
+               rsurface.batchelement3s_indexbuffer = R_BufferData_Store(rsurface.batchnumtriangles * sizeof(short[3]), rsurface.batchelement3s, R_BUFFERDATA_INDEX16, &rsurface.batchelement3s_bufferoffset);
+       else if (rsurface.batchelement3i && !rsurface.batchelement3i_indexbuffer)
+               rsurface.batchelement3i_indexbuffer = R_BufferData_Store(rsurface.batchnumtriangles * sizeof(int[3]), rsurface.batchelement3i, R_BUFFERDATA_INDEX32, &rsurface.batchelement3i_bufferoffset);
+
+       R_Mesh_VertexPointer(     3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
+       R_Mesh_ColorPointer(      4, GL_FLOAT, sizeof(float[4]), rsurface.batchlightmapcolor4f, rsurface.batchlightmapcolor4f_vertexbuffer, rsurface.batchlightmapcolor4f_bufferoffset);
+       R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
+       R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset);
+       R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset);
+       R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset);
+       R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
+       R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
+       R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE | 0x80000000, sizeof(unsigned char[4]), rsurface.batchskeletalindex4ub, rsurface.batchskeletalindex4ub_vertexbuffer, rsurface.batchskeletalindex4ub_bufferoffset);
+       R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), rsurface.batchskeletalweight4ub, rsurface.batchskeletalweight4ub_vertexbuffer, rsurface.batchskeletalweight4ub_bufferoffset);
+}
+
 static void RSurf_RenumberElements(const int *inelement3i, int *outelement3i, int numelements, int adjust)
 {
        int i;
@@ -8954,7 +7464,6 @@ static void RSurf_RenumberElements(const int *inelement3i, int *outelement3i, in
 }
 
 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
-extern cvar_t gl_vbo;
 void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const msurface_t **texturesurfacelist)
 {
        int deformindex;
@@ -8971,7 +7480,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
        int batchnumsurfaces = texturenumsurfaces;
        int batchnumvertices;
        int batchnumtriangles;
-       int needsupdate;
        int i, j;
        qboolean gaps;
        qboolean dynamicvertex;
@@ -8982,7 +7490,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
        unsigned char *ub;
        q3shaderinfo_deform_t *deform;
        const msurface_t *surface, *firstsurface;
-       r_vertexmesh_t *vertexmesh;
        if (!texturenumsurfaces)
                return;
        // find vertex range of this surface batch
@@ -9022,13 +7529,17 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
        rsurface.batchfirsttriangle = firsttriangle;
        rsurface.batchnumtriangles = batchnumtriangles;
 
-       // this variable holds flags for which properties have been updated that
-       // may require regenerating vertexmesh array...
-       needsupdate = 0;
-
        // check if any dynamic vertex processing must occur
        dynamicvertex = false;
 
+       // we must use vertexbuffers for rendering, we can upload vertex buffers
+       // easily enough but if the basevertex is non-zero it becomes more
+       // difficult, so force dynamicvertex path in that case - it's suboptimal
+       // but the most optimal case is to have the geometry sources provide their
+       // own anyway.
+       if (!rsurface.modelvertex3f_vertexbuffer && firstvertex != 0)
+               dynamicvertex = true;
+
        // a cvar to force the dynamic vertex path to be taken, for debugging
        if (r_batch_debugdynamicvertexpath.integer)
        {
@@ -9043,7 +7554,7 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
        }
 
        // if there is a chance of animated vertex colors, it's a dynamic batch
-       if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
+       if ((batchneed & BATCHNEED_ARRAY_VERTEXCOLOR) && texturesurfacelist[0]->lightmapinfo)
        {
                if (!dynamicvertex)
                {
@@ -9053,7 +7564,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        r_refdef.stats[r_stat_batch_dynamic_triangles_because_lightmapvertex] += batchnumtriangles;
                }
                dynamicvertex = true;
-               needsupdate |= BATCHNEED_VERTEXMESH_VERTEXCOLOR;
        }
 
        for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform && r_deformvertexes.integer;deformindex++, deform++)
@@ -9082,7 +7592,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_TEXCOORD;
-                       needsupdate |= BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
                        break;
                case Q3DEFORM_AUTOSPRITE2:
                        if (!dynamicvertex)
@@ -9094,7 +7603,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD;
-                       needsupdate |= BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
                        break;
                case Q3DEFORM_NORMAL:
                        if (!dynamicvertex)
@@ -9106,7 +7614,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD;
-                       needsupdate |= BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
                        break;
                case Q3DEFORM_WAVE:
                        if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
@@ -9120,7 +7627,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD;
-                       needsupdate |= BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
                        break;
                case Q3DEFORM_BULGE:
                        if (!dynamicvertex)
@@ -9132,7 +7638,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD;
-                       needsupdate |= BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
                        break;
                case Q3DEFORM_MOVE:
                        if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
@@ -9146,7 +7651,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX;
-                       needsupdate |= BATCHNEED_VERTEXMESH_VERTEX;
                        break;
                }
        }
@@ -9167,7 +7671,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_LIGHTMAP;
-                       needsupdate |= BATCHNEED_VERTEXMESH_LIGHTMAP;
                        break;
                case Q3TCGEN_VECTOR:
                        if (!dynamicvertex)
@@ -9179,7 +7682,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX;
-                       needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
                        break;
                case Q3TCGEN_ENVIRONMENT:
                        if (!dynamicvertex)
@@ -9191,7 +7693,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL;
-                       needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
                        break;
                }
                if (rsurface.texture->materialshaderpass->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
@@ -9205,32 +7706,13 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                        dynamicvertex = true;
                        batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD;
-                       needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
-               }
-       }
-
-       if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
-       {
-               if (!dynamicvertex)
-               {
-                       r_refdef.stats[r_stat_batch_dynamic_batches_because_interleavedarrays] += 1;
-                       r_refdef.stats[r_stat_batch_dynamic_surfaces_because_interleavedarrays] += batchnumsurfaces;
-                       r_refdef.stats[r_stat_batch_dynamic_vertices_because_interleavedarrays] += batchnumvertices;
-                       r_refdef.stats[r_stat_batch_dynamic_triangles_because_interleavedarrays] += batchnumtriangles;
                }
-               dynamicvertex = true;
-               needsupdate |= (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP));
        }
 
-       // when the model data has no vertex buffer (dynamic mesh), we need to
-       // eliminate gaps
-       if (vid.useinterleavedarrays && !rsurface.modelvertexmesh_vertexbuffer)
-               batchneed |= BATCHNEED_NOGAPS;
-
        // the caller can specify BATCHNEED_NOGAPS to force a batch with
        // firstvertex = 0 and endvertex = numvertices (no gaps, no firstvertex),
        // we ensure this by treating the vertex batch as dynamic...
-       if ((batchneed & BATCHNEED_NOGAPS) && (gaps || firstvertex > 0))
+       if ((batchneed & BATCHNEED_ALWAYSCOPY) || ((batchneed & BATCHNEED_NOGAPS) && (gaps || firstvertex > 0)))
        {
                if (!dynamicvertex)
                {
@@ -9242,44 +7724,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                dynamicvertex = true;
        }
 
-       if (dynamicvertex)
-       {
-               // when copying, we need to consider the regeneration of vertexmesh, any dependencies it may have must be set...
-               if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)      batchneed |= BATCHNEED_ARRAY_VERTEX;
-               if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)      batchneed |= BATCHNEED_ARRAY_NORMAL;
-               if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)      batchneed |= BATCHNEED_ARRAY_VECTOR;
-               if (batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) batchneed |= BATCHNEED_ARRAY_VERTEXCOLOR;
-               if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)    batchneed |= BATCHNEED_ARRAY_TEXCOORD;
-               if (batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP)    batchneed |= BATCHNEED_ARRAY_LIGHTMAP;
-               if (batchneed & BATCHNEED_VERTEXMESH_SKELETAL)    batchneed |= BATCHNEED_ARRAY_SKELETAL;
-       }
-
-       // if needsupdate, we have to do a dynamic vertex batch for sure
-       if (needsupdate & batchneed)
-       {
-               if (!dynamicvertex)
-               {
-                       r_refdef.stats[r_stat_batch_dynamic_batches_because_derived] += 1;
-                       r_refdef.stats[r_stat_batch_dynamic_surfaces_because_derived] += batchnumsurfaces;
-                       r_refdef.stats[r_stat_batch_dynamic_vertices_because_derived] += batchnumvertices;
-                       r_refdef.stats[r_stat_batch_dynamic_triangles_because_derived] += batchnumtriangles;
-               }
-               dynamicvertex = true;
-       }
-
-       // see if we need to build vertexmesh from arrays
-       if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
-       {
-               if (!dynamicvertex)
-               {
-                       r_refdef.stats[r_stat_batch_dynamic_batches_because_interleavedarrays] += 1;
-                       r_refdef.stats[r_stat_batch_dynamic_surfaces_because_interleavedarrays] += batchnumsurfaces;
-                       r_refdef.stats[r_stat_batch_dynamic_vertices_because_interleavedarrays] += batchnumvertices;
-                       r_refdef.stats[r_stat_batch_dynamic_triangles_because_interleavedarrays] += batchnumtriangles;
-               }
-               dynamicvertex = true;
-       }
-
        // if we're going to have to apply the skeletal transform manually, we need to batch the skeletal data
        if (dynamicvertex && rsurface.entityskeletaltransform3x4)
                batchneed |= BATCHNEED_ARRAY_SKELETAL;
@@ -9311,9 +7755,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
        rsurface.batchskeletalweight4ub = rsurface.modelskeletalweight4ub;
        rsurface.batchskeletalweight4ub_vertexbuffer = rsurface.modelskeletalweight4ub_vertexbuffer;
        rsurface.batchskeletalweight4ub_bufferoffset = rsurface.modelskeletalweight4ub_bufferoffset;
-       rsurface.batchvertexmesh = rsurface.modelvertexmesh;
-       rsurface.batchvertexmesh_vertexbuffer = rsurface.modelvertexmesh_vertexbuffer;
-       rsurface.batchvertexmesh_bufferoffset = rsurface.modelvertexmesh_bufferoffset;
        rsurface.batchelement3i = rsurface.modelelement3i;
        rsurface.batchelement3i_indexbuffer = rsurface.modelelement3i_indexbuffer;
        rsurface.batchelement3i_bufferoffset = rsurface.modelelement3i_bufferoffset;
@@ -9386,14 +7827,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                                for (i = 0;i < numtriangles*3;i++)
                                        rsurface.batchelement3s[i] = rsurface.batchelement3i[i];
                        }
-                       // upload buffer data for the copytriangles batch
-                       if (((r_batch_dynamicbuffer.integer || gl_vbo_dynamicindex.integer) && vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo)
-                       {
-                               if (rsurface.batchelement3s)
-                                       rsurface.batchelement3s_indexbuffer = R_BufferData_Store(rsurface.batchnumtriangles * sizeof(short[3]), rsurface.batchelement3s, R_BUFFERDATA_INDEX16, &rsurface.batchelement3s_bufferoffset);
-                               else if (rsurface.batchelement3i)
-                                       rsurface.batchelement3i_indexbuffer = R_BufferData_Store(rsurface.batchnumtriangles * sizeof(int[3]), rsurface.batchelement3i, R_BUFFERDATA_INDEX32, &rsurface.batchelement3i_bufferoffset);
-                       }
                }
                else
                {
@@ -9421,9 +7854,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
        // need actual vertex positions and normals
        //if (dynamicvertex)
        {
-               rsurface.batchvertexmesh = NULL;
-               rsurface.batchvertexmesh_vertexbuffer = NULL;
-               rsurface.batchvertexmesh_bufferoffset = 0;
                rsurface.batchvertex3f = NULL;
                rsurface.batchvertex3f_vertexbuffer = NULL;
                rsurface.batchvertex3f_bufferoffset = 0;
@@ -9461,8 +7891,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                rsurface.batchskeletaltransform3x4offset = 0;
                rsurface.batchskeletaltransform3x4size = 0;
                // we'll only be setting up certain arrays as needed
-               if (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
-                       rsurface.batchvertexmesh = (r_vertexmesh_t *)R_FrameData_Alloc(batchnumvertices * sizeof(r_vertexmesh_t));
                if (batchneed & BATCHNEED_ARRAY_VERTEX)
                        rsurface.batchvertex3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
                if (batchneed & BATCHNEED_ARRAY_NORMAL)
@@ -9492,8 +7920,6 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
                        surfacenumtriangles = texturesurfacelist[i]->num_triangles;
                        // copy only the data requested
-                       if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)) && rsurface.modelvertexmesh)
-                               memcpy(rsurface.batchvertexmesh + numvertices, rsurface.modelvertexmesh + surfacefirstvertex, surfacenumvertices * sizeof(rsurface.batchvertexmesh[0]));
                        if (batchneed & (BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_ARRAY_LIGHTMAP))
                        {
                                if (batchneed & BATCHNEED_ARRAY_VERTEX)
@@ -9711,7 +8137,7 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
 
        // q1bsp surfaces rendered in vertex color mode have to have colors
        // calculated based on lightstyles
-       if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
+       if ((batchneed & BATCHNEED_ARRAY_VERTEXCOLOR) && texturesurfacelist[0]->lightmapinfo)
        {
                // generate color arrays for the surfaces in this list
                int c[4];
@@ -10125,78 +8551,7 @@ void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const
                        }
                }
        }
-
-       if (needsupdate & batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
-       {
-               // convert the modified arrays to vertex structs
-//             rsurface.batchvertexmesh = R_FrameData_Alloc(batchnumvertices * sizeof(r_vertexmesh_t));
-//             rsurface.batchvertexmesh_vertexbuffer = NULL;
-//             rsurface.batchvertexmesh_bufferoffset = 0;
-               if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)
-                       for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
-                               VectorCopy(rsurface.batchvertex3f + 3*j, vertexmesh->vertex3f);
-               if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)
-                       for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
-                               VectorCopy(rsurface.batchnormal3f + 3*j, vertexmesh->normal3f);
-               if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)
-               {
-                       for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
-                       {
-                               VectorCopy(rsurface.batchsvector3f + 3*j, vertexmesh->svector3f);
-                               VectorCopy(rsurface.batchtvector3f + 3*j, vertexmesh->tvector3f);
-                       }
-               }
-               if ((batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) && rsurface.batchlightmapcolor4f)
-                       for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
-                               Vector4Copy(rsurface.batchlightmapcolor4f + 4*j, vertexmesh->color4f);
-               if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)
-                       for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
-                               Vector2Copy(rsurface.batchtexcoordtexture2f + 2*j, vertexmesh->texcoordtexture2f);
-               if ((batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP) && rsurface.batchtexcoordlightmap2f)
-                       for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
-                               Vector2Copy(rsurface.batchtexcoordlightmap2f + 2*j, vertexmesh->texcoordlightmap2f);
-               if ((batchneed & BATCHNEED_VERTEXMESH_SKELETAL) && rsurface.batchskeletalindex4ub)
-               {
-                       for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
-                       {
-                               Vector4Copy(rsurface.batchskeletalindex4ub + 4*j, vertexmesh->skeletalindex4ub);
-                               Vector4Copy(rsurface.batchskeletalweight4ub + 4*j, vertexmesh->skeletalweight4ub);
-                       }
-               }
-       }
-
-       // upload buffer data for the dynamic batch
-       if (((r_batch_dynamicbuffer.integer || gl_vbo_dynamicvertex.integer || gl_vbo_dynamicindex.integer) && vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo)
-       {
-               if (rsurface.batchvertexmesh)
-                       rsurface.batchvertexmesh_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(r_vertexmesh_t), rsurface.batchvertexmesh, R_BUFFERDATA_VERTEX, &rsurface.batchvertexmesh_bufferoffset);
-               else
-               {
-                       if (rsurface.batchvertex3f)
-                               rsurface.batchvertex3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f, R_BUFFERDATA_VERTEX, &rsurface.batchvertex3f_bufferoffset);
-                       if (rsurface.batchsvector3f)
-                               rsurface.batchsvector3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchsvector3f, R_BUFFERDATA_VERTEX, &rsurface.batchsvector3f_bufferoffset);
-                       if (rsurface.batchtvector3f)
-                               rsurface.batchtvector3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchtvector3f, R_BUFFERDATA_VERTEX, &rsurface.batchtvector3f_bufferoffset);
-                       if (rsurface.batchnormal3f)
-                               rsurface.batchnormal3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f, R_BUFFERDATA_VERTEX, &rsurface.batchnormal3f_bufferoffset);
-                       if (rsurface.batchlightmapcolor4f)
-                               rsurface.batchlightmapcolor4f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[4]), rsurface.batchlightmapcolor4f, R_BUFFERDATA_VERTEX, &rsurface.batchlightmapcolor4f_bufferoffset);
-                       if (rsurface.batchtexcoordtexture2f)
-                               rsurface.batchtexcoordtexture2f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[2]), rsurface.batchtexcoordtexture2f, R_BUFFERDATA_VERTEX, &rsurface.batchtexcoordtexture2f_bufferoffset);
-                       if (rsurface.batchtexcoordlightmap2f)
-                               rsurface.batchtexcoordlightmap2f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[2]), rsurface.batchtexcoordlightmap2f, R_BUFFERDATA_VERTEX, &rsurface.batchtexcoordlightmap2f_bufferoffset);
-                       if (rsurface.batchskeletalindex4ub)
-                               rsurface.batchskeletalindex4ub_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(unsigned char[4]), rsurface.batchskeletalindex4ub, R_BUFFERDATA_VERTEX, &rsurface.batchskeletalindex4ub_bufferoffset);
-                       if (rsurface.batchskeletalweight4ub)
-                               rsurface.batchskeletalweight4ub_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(unsigned char[4]), rsurface.batchskeletalweight4ub, R_BUFFERDATA_VERTEX, &rsurface.batchskeletalweight4ub_bufferoffset);
-               }
-               if (rsurface.batchelement3s)
-                       rsurface.batchelement3s_indexbuffer = R_BufferData_Store(rsurface.batchnumtriangles * sizeof(short[3]), rsurface.batchelement3s, R_BUFFERDATA_INDEX16, &rsurface.batchelement3s_bufferoffset);
-               else if (rsurface.batchelement3i)
-                       rsurface.batchelement3i_indexbuffer = R_BufferData_Store(rsurface.batchnumtriangles * sizeof(int[3]), rsurface.batchelement3i, R_BUFFERDATA_INDEX32, &rsurface.batchelement3i_bufferoffset);
-       }
-}
+}
 
 void RSurf_DrawBatch(void)
 {
@@ -10297,295 +8652,6 @@ static int RSurf_FindWaterPlaneForSurface(const msurface_t *surface)
        // render multiple smaller batches
 }
 
-static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(void)
-{
-       int i;
-       rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-       rsurface.passcolor4f_vertexbuffer = 0;
-       rsurface.passcolor4f_bufferoffset = 0;
-       for (i = 0;i < rsurface.batchnumvertices;i++)
-               Vector4Set(rsurface.passcolor4f + 4*i, 0.5f, 0.5f, 0.5f, 1.0f);
-}
-
-static void RSurf_DrawBatch_GL11_ApplyFog(void)
-{
-       int i;
-       float f;
-       const float *v;
-       const float *c;
-       float *c2;
-       if (rsurface.passcolor4f)
-       {
-               // generate color arrays
-               c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;
-               rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-               rsurface.passcolor4f_vertexbuffer = 0;
-               rsurface.passcolor4f_bufferoffset = 0;
-               for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4, c2 += 4)
-               {
-                       f = RSurf_FogVertex(v);
-                       c2[0] = c[0] * f;
-                       c2[1] = c[1] * f;
-                       c2[2] = c[2] * f;
-                       c2[3] = c[3];
-               }
-       }
-       else
-       {
-               rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-               rsurface.passcolor4f_vertexbuffer = 0;
-               rsurface.passcolor4f_bufferoffset = 0;
-               for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c2 += 4)
-               {
-                       f = RSurf_FogVertex(v);
-                       c2[0] = f;
-                       c2[1] = f;
-                       c2[2] = f;
-                       c2[3] = 1;
-               }
-       }
-}
-
-static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(void)
-{
-       int i;
-       float f;
-       const float *v;
-       const float *c;
-       float *c2;
-       if (!rsurface.passcolor4f)
-               return;
-       c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;
-       rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-       rsurface.passcolor4f_vertexbuffer = 0;
-       rsurface.passcolor4f_bufferoffset = 0;
-       for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4, c2 += 4)
-       {
-               f = RSurf_FogVertex(v);
-               c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
-               c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
-               c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
-               c2[3] = c[3];
-       }
-}
-
-static void RSurf_DrawBatch_GL11_ApplyColor(float r, float g, float b, float a)
-{
-       int i;
-       const float *c;
-       float *c2;
-       if (!rsurface.passcolor4f)
-               return;
-       c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;
-       rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-       rsurface.passcolor4f_vertexbuffer = 0;
-       rsurface.passcolor4f_bufferoffset = 0;
-       for (i = 0, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
-       {
-               c2[0] = c[0] * r;
-               c2[1] = c[1] * g;
-               c2[2] = c[2] * b;
-               c2[3] = c[3] * a;
-       }
-}
-
-static void RSurf_DrawBatch_GL11_ApplyAmbient(void)
-{
-       int i;
-       const float *c;
-       float *c2;
-       if (!rsurface.passcolor4f)
-               return;
-       c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;
-       rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-       rsurface.passcolor4f_vertexbuffer = 0;
-       rsurface.passcolor4f_bufferoffset = 0;
-       for (i = 0, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
-       {
-               c2[0] = c[0] + rsurface.texture->render_lightmap_ambient[0];
-               c2[1] = c[1] + rsurface.texture->render_lightmap_ambient[1];
-               c2[2] = c[2] + rsurface.texture->render_lightmap_ambient[2];
-               c2[3] = c[3];
-       }
-}
-
-static void RSurf_DrawBatch_GL11_Lightmap(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
-{
-       // TODO: optimize
-       rsurface.passcolor4f = NULL;
-       rsurface.passcolor4f_vertexbuffer = 0;
-       rsurface.passcolor4f_bufferoffset = 0;
-       if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
-       if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
-       R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
-       GL_Color(r, g, b, a);
-       R_Mesh_TexBind(0, rsurface.lightmaptexture);
-       R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-       R_Mesh_TexMatrix(0, NULL);
-       RSurf_DrawBatch();
-}
-
-static void RSurf_DrawBatch_GL11_Unlit(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
-{
-       // TODO: optimize applyfog && applycolor case
-       // just apply fog if necessary, and tint the fog color array if necessary
-       rsurface.passcolor4f = NULL;
-       rsurface.passcolor4f_vertexbuffer = 0;
-       rsurface.passcolor4f_bufferoffset = 0;
-       if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
-       if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
-       R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
-       GL_Color(r, g, b, a);
-       RSurf_DrawBatch();
-}
-
-static void RSurf_DrawBatch_GL11_VertexColor(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
-{
-       // TODO: optimize
-       rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
-       rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
-       rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
-       if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
-       if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
-       R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
-       GL_Color(r, g, b, a);
-       RSurf_DrawBatch();
-}
-
-static void RSurf_DrawBatch_GL11_ClampColor(void)
-{
-       int i;
-       const float *c1;
-       float *c2;
-       if (!rsurface.passcolor4f)
-               return;
-       for (i = 0, c1 = rsurface.passcolor4f + 4*rsurface.batchfirstvertex, c2 = rsurface.passcolor4f + 4*rsurface.batchfirstvertex;i < rsurface.batchnumvertices;i++, c1 += 4, c2 += 4)
-       {
-               c2[0] = bound(0.0f, c1[0], 1.0f);
-               c2[1] = bound(0.0f, c1[1], 1.0f);
-               c2[2] = bound(0.0f, c1[2], 1.0f);
-               c2[3] = bound(0.0f, c1[3], 1.0f);
-       }
-}
-
-static void RSurf_DrawBatch_GL11_ApplyFakeLight(float fakelightintensity)
-{
-       int i;
-       float f;
-       const float *v;
-       const float *n;
-       float *c;
-       //vec3_t eyedir;
-
-       // fake shading
-       rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-       rsurface.passcolor4f_vertexbuffer = 0;
-       rsurface.passcolor4f_bufferoffset = 0;
-       for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4)
-       {
-               f = -DotProduct(r_refdef.view.forward, n);
-               f = max(0, f);
-               f = f * 0.85 + 0.15; // work around so stuff won't get black
-               f *= fakelightintensity;
-               Vector4Set(c, f, f, f, 1);
-       }
-}
-
-static void RSurf_DrawBatch_GL11_FakeLight(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
-{
-       RSurf_DrawBatch_GL11_ApplyFakeLight(r_refdef.scene.lightmapintensity * r_fakelight_intensity.value);
-       if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
-       if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
-       R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
-       GL_Color(r, g, b, a);
-       RSurf_DrawBatch();
-}
-
-static void RSurf_DrawBatch_GL11_ApplyVertexShade(float *r, float *g, float *b, float *a, float lightmapintensity, qboolean *applycolor)
-{
-       int i;
-       float f;
-       float alpha;
-       const float *v;
-       const float *n;
-       float *c;
-       vec3_t ambientcolor;
-       vec3_t diffusecolor;
-       vec3_t lightdir;
-       // TODO: optimize
-       // model lighting
-       VectorCopy(rsurface.texture->render_modellight_lightdir, lightdir);
-       f = 0.5f * lightmapintensity;
-       ambientcolor[0] = rsurface.texture->render_modellight_ambient[0] * *r * f;
-       ambientcolor[1] = rsurface.texture->render_modellight_ambient[1] * *g * f;
-       ambientcolor[2] = rsurface.texture->render_modellight_ambient[2] * *b * f;
-       diffusecolor[0] = rsurface.texture->render_modellight_diffuse[0] * *r * f;
-       diffusecolor[1] = rsurface.texture->render_modellight_diffuse[1] * *g * f;
-       diffusecolor[2] = rsurface.texture->render_modellight_diffuse[2] * *b * f;
-       alpha = *a;
-       if (VectorLength2(diffusecolor) > 0)
-       {
-               // q3-style directional shading
-               rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-               rsurface.passcolor4f_vertexbuffer = 0;
-               rsurface.passcolor4f_bufferoffset = 0;
-               for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4)
-               {
-                       if ((f = DotProduct(n, lightdir)) > 0)
-                               VectorMA(ambientcolor, f, diffusecolor, c);
-                       else
-                               VectorCopy(ambientcolor, c);
-                       c[3] = alpha;
-               }
-               *r = 1;
-               *g = 1;
-               *b = 1;
-               *a = 1;
-               *applycolor = false;
-       }
-       else
-       {
-               *r = ambientcolor[0];
-               *g = ambientcolor[1];
-               *b = ambientcolor[2];
-               rsurface.passcolor4f = NULL;
-               rsurface.passcolor4f_vertexbuffer = 0;
-               rsurface.passcolor4f_bufferoffset = 0;
-       }
-}
-
-static void RSurf_DrawBatch_GL11_VertexShade(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
-{
-       RSurf_DrawBatch_GL11_ApplyVertexShade(&r, &g, &b, &a, r_refdef.scene.lightmapintensity, &applycolor);
-       if (applyfog)   RSurf_DrawBatch_GL11_ApplyFog();
-       if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
-       R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
-       GL_Color(r, g, b, a);
-       RSurf_DrawBatch();
-}
-
-static void RSurf_DrawBatch_GL11_MakeFogColor(float r, float g, float b, float a)
-{
-       int i;
-       float f;
-       const float *v;
-       float *c;
-
-       // fake shading
-       rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
-       rsurface.passcolor4f_vertexbuffer = 0;
-       rsurface.passcolor4f_bufferoffset = 0;
-
-       for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4)
-       {
-               f = 1 - RSurf_FogVertex(v);
-               c[0] = r;
-               c[1] = g;
-               c[2] = b;
-               c[3] = f * a;
-       }
-}
-
 void RSurf_SetupDepthAndCulling(void)
 {
        // submodels are biased to avoid z-fighting with world surfaces that they
@@ -10761,420 +8827,53 @@ static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface
        RSurf_DrawBatch();
 }
 
-static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
-{
-       // OpenGL 1.3 path - anything not completely ancient
-       qboolean applycolor;
-       qboolean applyfog;
-       int layerindex;
-       const texturelayer_t *layer;
-       RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | ((!rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)) ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.modeltexcoordlightmap2f ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-       R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
-
-       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 (layerindex == 0)
-                               GL_AlphaTest(true);
-                       else
-                       {
-                               GL_AlphaTest(false);
-                               GL_DepthFunc(GL_EQUAL);
-                       }
-               }
-               GL_DepthMask(layer->depthmask && writedepth);
-               GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
-               if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
-               {
-                       layertexrgbscale = 4;
-                       VectorScale(layer->color, 0.25f, layercolor);
-               }
-               else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
-               {
-                       layertexrgbscale = 2;
-                       VectorScale(layer->color, 0.5f, layercolor);
-               }
-               else
-               {
-                       layertexrgbscale = 1;
-                       VectorScale(layer->color, 1.0f, layercolor);
-               }
-               layercolor[3] = layer->color[3];
-               applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
-               R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
-               applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
-               switch (layer->type)
-               {
-               case TEXTURELAYERTYPE_LITTEXTURE:
-                       // single-pass lightmapped texture with 2x rgbscale
-                       R_Mesh_TexBind(0, r_texture_white);
-                       R_Mesh_TexMatrix(0, NULL);
-                       R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-                       R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
-                       R_Mesh_TexBind(1, layer->texture);
-                       R_Mesh_TexMatrix(1, &layer->texmatrix);
-                       R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
-                       R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
-                       if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
-                               RSurf_DrawBatch_GL11_VertexShade(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
-                       else if (FAKELIGHT_ENABLED)
-                               RSurf_DrawBatch_GL11_FakeLight(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
-                       else if (rsurface.uselightmaptexture)
-                               RSurf_DrawBatch_GL11_Lightmap(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
-                       else
-                               RSurf_DrawBatch_GL11_VertexColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
-                       break;
-               case TEXTURELAYERTYPE_TEXTURE:
-                       // singletexture unlit texture with transparency support
-                       R_Mesh_TexBind(0, layer->texture);
-                       R_Mesh_TexMatrix(0, &layer->texmatrix);
-                       R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
-                       R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
-                       R_Mesh_TexBind(1, 0);
-                       R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
-                       RSurf_DrawBatch_GL11_Unlit(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
-                       break;
-               case TEXTURELAYERTYPE_FOG:
-                       // singletexture fogging
-                       if (layer->texture)
-                       {
-                               R_Mesh_TexBind(0, layer->texture);
-                               R_Mesh_TexMatrix(0, &layer->texmatrix);
-                               R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
-                               R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
-                       }
-                       else
-                       {
-                               R_Mesh_TexBind(0, 0);
-                               R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
-                       }
-                       R_Mesh_TexBind(1, 0);
-                       R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
-                       // generate a color array for the fog pass
-                       RSurf_DrawBatch_GL11_MakeFogColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3]);
-                       R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
-                       RSurf_DrawBatch();
-                       break;
-               default:
-                       Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
-               }
-       }
-       if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
-       {
-               GL_DepthFunc(GL_LEQUAL);
-               GL_AlphaTest(false);
-       }
-}
-
-static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
-{
-       // OpenGL 1.1 - crusty old voodoo path
-       qboolean applyfog;
-       int layerindex;
-       const texturelayer_t *layer;
-       RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | ((!rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)) ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.modeltexcoordlightmap2f ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-       R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
-
-       for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
-       {
-               if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
-               {
-                       if (layerindex == 0)
-                               GL_AlphaTest(true);
-                       else
-                       {
-                               GL_AlphaTest(false);
-                               GL_DepthFunc(GL_EQUAL);
-                       }
-               }
-               GL_DepthMask(layer->depthmask && writedepth);
-               GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
-               R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
-               applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
-               switch (layer->type)
-               {
-               case TEXTURELAYERTYPE_LITTEXTURE:
-                       if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))
-                       {
-                               // two-pass lit texture with 2x rgbscale
-                               // first the lightmap pass
-                               R_Mesh_TexBind(0, r_texture_white);
-                               R_Mesh_TexMatrix(0, NULL);
-                               R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-                               R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
-                               if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
-                                       RSurf_DrawBatch_GL11_VertexShade(1, 1, 1, 1, false, false);
-                               else if (FAKELIGHT_ENABLED)
-                                       RSurf_DrawBatch_GL11_FakeLight(1, 1, 1, 1, false, false);
-                               else if (rsurface.uselightmaptexture)
-                                       RSurf_DrawBatch_GL11_Lightmap(1, 1, 1, 1, false, false);
-                               else
-                                       RSurf_DrawBatch_GL11_VertexColor(1, 1, 1, 1, false, false);
-                               // then apply the texture to it
-                               GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
-                               R_Mesh_TexBind(0, layer->texture);
-                               R_Mesh_TexMatrix(0, &layer->texmatrix);
-                               R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-                               R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
-                               RSurf_DrawBatch_GL11_Unlit(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);
-                       }
-                       else
-                       {
-                               // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
-                               R_Mesh_TexBind(0, layer->texture);
-                               R_Mesh_TexMatrix(0, &layer->texmatrix);
-                               R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-                               R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
-                               if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
-                                       RSurf_DrawBatch_GL11_VertexShade(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 if (FAKELIGHT_ENABLED)
-                                       RSurf_DrawBatch_GL11_FakeLight(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(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_TEXTURE:
-                       // singletexture unlit texture with transparency support
-                       R_Mesh_TexBind(0, layer->texture);
-                       R_Mesh_TexMatrix(0, &layer->texmatrix);
-                       R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-                       R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
-                       RSurf_DrawBatch_GL11_Unlit(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
-                       if (layer->texture)
-                       {
-                               R_Mesh_TexBind(0, layer->texture);
-                               R_Mesh_TexMatrix(0, &layer->texmatrix);
-                               R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
-                               R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
-                       }
-                       else
-                       {
-                               R_Mesh_TexBind(0, 0);
-                               R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
-                       }
-                       // generate a color array for the fog pass
-                       RSurf_DrawBatch_GL11_MakeFogColor(layer->color[0], layer->color[1], layer->color[2], layer->color[3]);
-                       R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
-                       RSurf_DrawBatch();
-                       break;
-               default:
-                       Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
-               }
-       }
-       if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
-       {
-               GL_DepthFunc(GL_LEQUAL);
-               GL_AlphaTest(false);
-       }
-}
-
 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
 {
        int vi;
        int j;
-       r_vertexgeneric_t *batchvertex;
-       float c[4];
-       texture_t *t = rsurface.texture;
+       int texturesurfaceindex;
+       int k;
+       const msurface_t *surface;
+       float surfacecolor4f[4];
 
 //     R_Mesh_ResetTextureState();
        R_SetupShader_Generic_NoTexture(false, false);
 
-       if(t && t->currentskinframe)
-       {
-               memcpy(c, t->currentskinframe->avgcolor, sizeof(c));
-               c[3] *= t->currentalpha;
-       }
-       else
-       {
-               c[0] = 1;
-               c[1] = 0;
-               c[2] = 1;
-               c[3] = 1;
-       }
-
-       if (t->pantstexture || t->shirttexture)
-       {
-               c[0] = 0.5 * (t->render_colormap_pants[0] * 0.3 + t->render_colormap_shirt[0] * 0.7);
-               c[1] = 0.5 * (t->render_colormap_pants[1] * 0.3 + t->render_colormap_shirt[1] * 0.7);
-               c[2] = 0.5 * (t->render_colormap_pants[2] * 0.3 + t->render_colormap_shirt[2] * 0.7);
-       }
-
-       // brighten it up (as texture value 127 means "unlit")
-       c[0] *= 2 * r_refdef.view.colorscale;
-       c[1] *= 2 * r_refdef.view.colorscale;
-       c[2] *= 2 * r_refdef.view.colorscale;
-
-       if(t->currentmaterialflags & MATERIALFLAG_WATERALPHA)
-               c[3] *= r_wateralpha.value;
-
-       if(t->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
-       {
-               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-               GL_DepthMask(false);
-       }
-       else if(t->currentmaterialflags & MATERIALFLAG_ADD)
-       {
-               GL_BlendFunc(GL_ONE, GL_ONE);
-               GL_DepthMask(false);
-       }
-       else if(t->currentmaterialflags & MATERIALFLAG_ALPHATEST)
-       {
-               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
-               GL_DepthMask(false);
-       }
-       else if(t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
-       {
-               GL_BlendFunc(t->customblendfunc[0], t->customblendfunc[1]);
-               GL_DepthMask(false);
-       }
-       else
-       {
-               GL_BlendFunc(GL_ONE, GL_ZERO);
-               GL_DepthMask(writedepth);
-       }
-
-       if (r_showsurfaces.integer == 3)
-       {
-               rsurface.passcolor4f = NULL;
-
-               if (t->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
-               {
-                       qboolean applycolor = true;
-                       float one = 1.0;
-
-                       RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-
-                       RSurf_DrawBatch_GL11_ApplyVertexShade(&one, &one, &one, &one, 1.0f, &applycolor);
-               }
-               else if (FAKELIGHT_ENABLED)
-               {
-                       RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-
-                       RSurf_DrawBatch_GL11_ApplyFakeLight(r_fakelight_intensity.value);
-               }
-               else
-               {
-                       RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-
-                       rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
-                       rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
-                       rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
-                       RSurf_DrawBatch_GL11_ApplyAmbient();
-               }
-
-               if(!rsurface.passcolor4f)
-                       RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray();
-
-               RSurf_DrawBatch_GL11_ApplyColor(c[0], c[1], c[2], c[3]);
-               if(r_refdef.fogenabled)
-                       RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors();
-               RSurf_DrawBatch_GL11_ClampColor();
+       GL_BlendFunc(GL_ONE, GL_ZERO);
+       GL_DepthMask(writedepth);
 
-               R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.passcolor4f, NULL);
-               R_SetupShader_Generic_NoTexture(false, false);
-               RSurf_DrawBatch();
-       }
-       else if (!r_refdef.view.showdebug)
-       {
-               RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-               batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
-               for (j = 0, vi = 0;j < rsurface.batchnumvertices;j++, vi++)
-               {
-                       VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
-                       Vector4Set(batchvertex[vi].color4f, 0, 0, 0, 1);
-               }
-               R_Mesh_PrepareVertices_Generic_Unlock();
-               RSurf_DrawBatch();
-       }
-       else if (r_showsurfaces.integer == 4)
-       {
-               RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-               batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
-               for (j = 0, vi = 0;j < rsurface.batchnumvertices;j++, vi++)
-               {
-                       unsigned char d = (vi << 3) * (1.0f / 256.0f);
-                       VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
-                       Vector4Set(batchvertex[vi].color4f, d, d, d, 1);
-               }
-               R_Mesh_PrepareVertices_Generic_Unlock();
-               RSurf_DrawBatch();
-       }
-       else if (r_showsurfaces.integer == 2)
+       RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_ALWAYSCOPY, texturenumsurfaces, texturesurfacelist);
+       vi = 0;
+       for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
        {
-               const int *e;
-               RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-               batchvertex = R_Mesh_PrepareVertices_Generic_Lock(3*rsurface.batchnumtriangles);
-               for (j = 0, e = rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle;j < rsurface.batchnumtriangles;j++, e += 3)
+               surface = texturesurfacelist[texturesurfaceindex];
+               k = (int)(((size_t)surface) / sizeof(msurface_t));
+               Vector4Set(surfacecolor4f, (k & 0xF) * (1.0f / 16.0f), (k & 0xF0) * (1.0f / 256.0f), (k & 0xF00) * (1.0f / 4096.0f), 1);
+               for (j = 0;j < surface->num_vertices;j++)
                {
-                       unsigned char d = ((j + rsurface.batchfirsttriangle) << 3) * (1.0f / 256.0f);
-                       VectorCopy(rsurface.batchvertex3f + 3*e[0], batchvertex[j*3+0].vertex3f);
-                       VectorCopy(rsurface.batchvertex3f + 3*e[1], batchvertex[j*3+1].vertex3f);
-                       VectorCopy(rsurface.batchvertex3f + 3*e[2], batchvertex[j*3+2].vertex3f);
-                       Vector4Set(batchvertex[j*3+0].color4f, d, d, d, 1);
-                       Vector4Set(batchvertex[j*3+1].color4f, d, d, d, 1);
-                       Vector4Set(batchvertex[j*3+2].color4f, d, d, d, 1);
+                       Vector4Copy(surfacecolor4f, rsurface.batchlightmapcolor4f + 4 * vi);
+                       vi++;
                }
-               R_Mesh_PrepareVertices_Generic_Unlock();
-               R_Mesh_Draw(0, rsurface.batchnumtriangles*3, 0, rsurface.batchnumtriangles, NULL, NULL, 0, NULL, NULL, 0);
-       }
-       else
-       {
-               int texturesurfaceindex;
-               int k;
-               const msurface_t *surface;
-               float surfacecolor4f[4];
-               RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
-               batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchfirstvertex + rsurface.batchnumvertices);
-               vi = 0;
-               for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
-               {
-                       surface = texturesurfacelist[texturesurfaceindex];
-                       k = (int)(((size_t)surface) / sizeof(msurface_t));
-                       Vector4Set(surfacecolor4f, (k & 0xF) * (1.0f / 16.0f), (k & 0xF0) * (1.0f / 256.0f), (k & 0xF00) * (1.0f / 4096.0f), 1);
-                       for (j = 0;j < surface->num_vertices;j++)
-                       {
-                               VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
-                               Vector4Copy(surfacecolor4f, batchvertex[vi].color4f);
-                               vi++;
-                       }
-               }
-               R_Mesh_PrepareVertices_Generic_Unlock();
-               RSurf_DrawBatch();
        }
+       R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchlightmapcolor4f, rsurface.batchtexcoordtexture2f);
+       RSurf_DrawBatch();
 }
 
 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
 {
        CHECKGLERROR
        RSurf_SetupDepthAndCulling();
-       if (r_showsurfaces.integer)
+       if (r_showsurfaces.integer && r_refdef.view.showdebug)
        {
                R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
                return;
        }
        switch (vid.renderpath)
        {
-       case RENDERPATH_GL20:
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-       case RENDERPATH_SOFT:
+       case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
                R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
                break;
-       case RENDERPATH_GL13:
-       case RENDERPATH_GLES1:
-               R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
-               break;
-       case RENDERPATH_GL11:
-               R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
-               break;
        }
        CHECKGLERROR
 }
@@ -11187,27 +8886,7 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const
        const msurface_t *surface;
        const msurface_t *texturesurfacelist[MESHQUEUE_TRANSPARENT_BATCHSIZE];
 
-       if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
-               RSurf_ActiveModelEntity(ent, false, false, false);
-       else
-       {
-               switch (vid.renderpath)
-               {
-               case RENDERPATH_GL20:
-               case RENDERPATH_D3D9:
-               case RENDERPATH_D3D10:
-               case RENDERPATH_D3D11:
-               case RENDERPATH_SOFT:
-               case RENDERPATH_GLES2:
-                       RSurf_ActiveModelEntity(ent, true, true, false);
-                       break;
-               case RENDERPATH_GL11:
-               case RENDERPATH_GL13:
-               case RENDERPATH_GLES1:
-                       RSurf_ActiveModelEntity(ent, true, false, false);
-                       break;
-               }
-       }
+       RSurf_ActiveModelEntity(ent, true, true, false);
 
        if (r_transparentdepthmasking.integer)
        {
@@ -11342,10 +9021,12 @@ static void R_DrawTextureSurfaceList_DepthOnly(int texturenumsurfaces, const msu
        RSurf_DrawBatch();
 }
 
-static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
+static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass, qboolean ui)
 {
        CHECKGLERROR
-       if (depthonly)
+       if (ui)
+               R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
+       else if (depthonly)
                R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
        else if (prepass)
        {
@@ -11374,7 +9055,7 @@ static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurf
        CHECKGLERROR
 }
 
-static void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
+static void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass, qboolean ui)
 {
        int i, j;
        texture_t *texture;
@@ -11415,7 +9096,7 @@ static void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const
                                ;
                }
                // render the range of surfaces
-               R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
+               R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass, ui);
        }
        R_FrameData_ReturnToMark();
 }
@@ -12101,7 +9782,7 @@ static void R_DrawModelDecals_Entity(entity_render_t *ent)
                GL_DepthTest(true);
                GL_CullFace(GL_NONE);
                GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
-               R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1, false, false, false);
+               R_SetupShader_Generic(decalskinframe->base, false, false, false);
                R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, NULL, 0, decalsystem->element3s, NULL, 0);
        }
 }
@@ -12243,7 +9924,7 @@ static void R_DrawDebugModel(void)
        GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
 
 #ifndef USE_GLES2
-       if (r_showtris.integer && qglPolygonMode)
+       if (r_showtris.value > 0 && qglPolygonMode)
        {
                if (r_showdisabledepthtest.integer)
                {
@@ -12278,6 +9959,8 @@ static void R_DrawDebugModel(void)
                rsurface.texture = NULL;
        }
 
+# if 0
+       // FIXME!  implement r_shownormals with just triangles
        if (r_shownormals.value != 0 && qglBegin)
        {
                int l, k;
@@ -12355,12 +10038,13 @@ static void R_DrawDebugModel(void)
                }
                rsurface.texture = NULL;
        }
+# endif
 #endif
 }
 
 int r_maxsurfacelist = 0;
 const msurface_t **r_surfacelist = NULL;
-void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
+void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass, qboolean ui)
 {
        int i, j, endj, flagsmask;
        dp_model_t *model = ent->model;
@@ -12383,43 +10067,9 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr
        else if (prepass)
                RSurf_ActiveModelEntity(ent, true, true, true);
        else if (depthonly)
-       {
-               switch (vid.renderpath)
-               {
-               case RENDERPATH_GL20:
-               case RENDERPATH_D3D9:
-               case RENDERPATH_D3D10:
-               case RENDERPATH_D3D11:
-               case RENDERPATH_SOFT:
-               case RENDERPATH_GLES2:
-                       RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
-                       break;
-               case RENDERPATH_GL11:
-               case RENDERPATH_GL13:
-               case RENDERPATH_GLES1:
-                       RSurf_ActiveModelEntity(ent, model->wantnormals, false, false);
-                       break;
-               }
-       }
+               RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
        else
-       {
-               switch (vid.renderpath)
-               {
-               case RENDERPATH_GL20:
-               case RENDERPATH_D3D9:
-               case RENDERPATH_D3D10:
-               case RENDERPATH_D3D11:
-               case RENDERPATH_SOFT:
-               case RENDERPATH_GLES2:
-                       RSurf_ActiveModelEntity(ent, true, true, false);
-                       break;
-               case RENDERPATH_GL11:
-               case RENDERPATH_GL13:
-               case RENDERPATH_GLES1:
-                       RSurf_ActiveModelEntity(ent, true, false, false);
-                       break;
-               }
-       }
+               RSurf_ActiveModelEntity(ent, true, true, false);
 
        surfaces = model->data_surfaces;
        update = model->brushq1.lightmapupdateflags;
@@ -12466,6 +10116,12 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr
                                r_surfacelist[numsurfacelist++] = surfaces + j;
                }
        }
+       else if (ui)
+       {
+               // for ui we have to preserve the order of surfaces
+               for (i = 0; i < model->nummodelsurfaces; i++)
+                       r_surfacelist[numsurfacelist++] = surfaces + model->firstmodelsurface + i;
+       }
        else
        {
                // add all surfaces
@@ -12492,7 +10148,7 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr
                }
        }
 
-       R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
+       R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass, ui);
 
        // add to stats if desired
        if (r_speeds.integer && !skysurfaces && !depthonly)
@@ -12505,6 +10161,51 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr
        rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
 }
 
+void R_DebugLine(vec3_t start, vec3_t end)
+{
+       dp_model_t *mod = CL_Mesh_UI();
+       msurface_t *surf;
+       int e0, e1, e2, e3;
+       float offsetx, offsety, x1, y1, x2, y2, width = 1.0f;
+       float r1 = 1.0f, g1 = 0.0f, b1 = 0.0f, alpha1 = 0.25f;
+       float r2 = 1.0f, g2 = 1.0f, b2 = 0.0f, alpha2 = 0.25f;
+       vec4_t w[2], s[2];
+
+       // transform to screen coords first
+       Vector4Set(w[0], start[0], start[1], start[2], 1);
+       Vector4Set(w[1], end[0], end[1], end[2], 1);
+       R_Viewport_TransformToScreen(&r_refdef.view.viewport, w[0], s[0]);
+       R_Viewport_TransformToScreen(&r_refdef.view.viewport, w[1], s[1]);
+       x1 = s[0][0] * vid_conwidth.value / vid.width;
+       y1 = (vid.height - s[0][1]) * vid_conheight.value / vid.height;
+       x2 = s[1][0] * vid_conwidth.value / vid.width;
+       y2 = (vid.height - s[1][1]) * vid_conheight.value / vid.height;
+       //Con_DPrintf("R_DebugLine: %.0f,%.0f to %.0f,%.0f\n", x1, y1, x2, y2);
+
+       // add the line to the UI mesh for drawing later
+
+       // width is measured in real pixels
+       if (fabs(x2 - x1) > fabs(y2 - y1))
+       {
+               offsetx = 0;
+               offsety = 0.5f * width * vid_conheight.value / vid.height;
+       }
+       else
+       {
+               offsetx = 0.5f * width * vid_conwidth.value / vid.width;
+               offsety = 0;
+       }
+       surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, "white", 0, 0, MATERIALFLAG_WALL | MATERIALFLAG_VERTEXCOLOR | MATERIALFLAG_ALPHAGEN_VERTEX), true);
+       e0 = Mod_Mesh_IndexForVertex(mod, surf, x1 - offsetx, y1 - offsety, 10, 0, 0, -1, 0, 0, 0, 0, r1, g1, b1, alpha1);
+       e1 = Mod_Mesh_IndexForVertex(mod, surf, x2 - offsetx, y2 - offsety, 10, 0, 0, -1, 0, 0, 0, 0, r2, g2, b2, alpha2);
+       e2 = Mod_Mesh_IndexForVertex(mod, surf, x2 + offsetx, y2 + offsety, 10, 0, 0, -1, 0, 0, 0, 0, r2, g2, b2, alpha2);
+       e3 = Mod_Mesh_IndexForVertex(mod, surf, x1 + offsetx, y1 + offsety, 10, 0, 0, -1, 0, 0, 0, 0, r1, g1, b1, alpha1);
+       Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
+       Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
+
+}
+
+
 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
 {
        int q;