GL20 path now uses same shader as GLES2 (albeit with the precision

modifiers disabled), this means vertex attrib arrays instead of the
legacy pointers...  one side effect is that colors are no longer clamped

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@10835 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/cl_particles.c b/cl_particles.c
index a1af7730169c4b9833b0ade7d74a6df65e624730..187934c32d4dd69bf81ea46a526896c0a6d197b4 100644 (file)
--- a/cl_particles.c
+++ b/cl_particles.c
@@ -2484,7 +2484,6 @@ void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtligh
        GL_DepthRange(0, 1);
        GL_PolygonOffset(0, 0);
        GL_DepthTest(true);
-       GL_AlphaTest(false);
        GL_CullFace(GL_NONE);
 
        spintime = r_refdef.scene.time;

diff --git a/dpsoftrast.h b/dpsoftrast.h
index b724940f8d94d0f6ef39e86b15224ed6c9f14819..28d72cabbee72558ba01f8a14a6775f6c3870109 100644 (file)
--- a/dpsoftrast.h
+++ b/dpsoftrast.h
@@ -123,20 +123,20 @@ typedef enum gl20_texunit_e
 }
 gl20_texunit;
 
-typedef enum gles2_attrib_e
+typedef enum glsl_attrib_e
 {
-       GLES2ATTRIB_POSITION = 0,
-       GLES2ATTRIB_COLOR = 1,
-       GLES2ATTRIB_TEXCOORD0 = 2,
-       GLES2ATTRIB_TEXCOORD1 = 3,
-       GLES2ATTRIB_TEXCOORD2 = 4,
-       GLES2ATTRIB_TEXCOORD3 = 5,
-       GLES2ATTRIB_TEXCOORD4 = 6,
-       GLES2ATTRIB_TEXCOORD5 = 7,
-       GLES2ATTRIB_TEXCOORD6 = 8,
-       GLES2ATTRIB_TEXCOORD7 = 9,
+       GLSLATTRIB_POSITION = 0,
+       GLSLATTRIB_COLOR = 1,
+       GLSLATTRIB_TEXCOORD0 = 2,
+       GLSLATTRIB_TEXCOORD1 = 3,
+       GLSLATTRIB_TEXCOORD2 = 4,
+       GLSLATTRIB_TEXCOORD3 = 5,
+       GLSLATTRIB_TEXCOORD4 = 6,
+       GLSLATTRIB_TEXCOORD5 = 7,
+       GLSLATTRIB_TEXCOORD6 = 8,
+       GLSLATTRIB_TEXCOORD7 = 9,
 }
-gles2_attrib;
+glsl_attrib;
 
 // this enum selects which of the glslshadermodeinfo entries should be used
 typedef enum shadermode_e

diff --git a/gl_backend.c b/gl_backend.c
index e6f3b17d77725adff0b169a5dd69e0b05a11386b..24381fb63251cf7e36444c4918630980ee9cb50b 100644 (file)
--- a/gl_backend.c
+++ b/gl_backend.c
@@ -147,7 +147,7 @@ typedef struct gl_state_s
        int vertexbufferobject;
        int elementbufferobject;
        int framebufferobject;
-       int defaultframebufferobject; // RENDERPATH_GLES2 has a non-zero fbo provided by the OS
+       int defaultframebufferobject; // deal with platforms that use a non-zero default fbo
        qboolean pointer_color_enabled;
 
        int pointer_vertex_components;
@@ -1061,11 +1061,7 @@ void R_SetViewport(const r_viewport_t *v)
 
        switch(vid.renderpath)
        {
-       case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
-//             CHECKGLERROR
-//             qglViewport(v->x, v->y, v->width, v->height);CHECKGLERROR
-//             break;
        case RENDERPATH_GL13:
        case RENDERPATH_GL11:
                CHECKGLERROR
@@ -1099,6 +1095,7 @@ void R_SetViewport(const r_viewport_t *v)
        case RENDERPATH_SOFT:
                DPSOFTRAST_Viewport(v->x, v->y, v->width, v->height);
                break;
+       case RENDERPATH_GL20:
        case RENDERPATH_GLES2:
                CHECKGLERROR
                qglViewport(v->x, v->y, v->width, v->height);CHECKGLERROR
@@ -1406,13 +1403,12 @@ static void GL_Backend_ResetState(void)
        case RENDERPATH_D3D11:
                Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
                break;
-       case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
                CHECKGLERROR
 
                qglColorMask(1, 1, 1, 1);CHECKGLERROR
-               qglAlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);CHECKGLERROR
-               qglDisable(GL_ALPHA_TEST);CHECKGLERROR
+       //      qglAlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);CHECKGLERROR
+       //      qglDisable(GL_ALPHA_TEST);CHECKGLERROR
                qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
                qglDisable(GL_BLEND);CHECKGLERROR
                qglCullFace(gl_state.cullface);CHECKGLERROR
@@ -1546,6 +1542,7 @@ static void GL_Backend_ResetState(void)
                DPSOFTRAST_SetRenderTargets(vid.width, vid.height, vid.softdepthpixels, vid.softpixels, NULL, NULL, NULL);
                DPSOFTRAST_Viewport(0, 0, vid.width, vid.height);
                break;
+       case RENDERPATH_GL20:
        case RENDERPATH_GLES2:
                CHECKGLERROR
                qglColorMask(1, 1, 1, 1);CHECKGLERROR
@@ -1557,16 +1554,23 @@ static void GL_Backend_ResetState(void)
                qglEnable(GL_DEPTH_TEST);CHECKGLERROR
                qglDepthMask(gl_state.depthmask);CHECKGLERROR
                qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
-               qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
-               qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
-               qglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+       //      if (vid.renderpath == RENDERPATH_GL20)
+       //      {
+       //              qglAlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);CHECKGLERROR
+       //              qglDisable(GL_ALPHA_TEST);CHECKGLERROR
+       //      }
+               if (vid.support.arb_vertex_buffer_object)
+               {
+                       qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+                       qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
+               }
                if (vid.support.ext_framebuffer_object)
                        qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, gl_state.defaultframebufferobject);
-               qglEnableVertexAttribArray(GLES2ATTRIB_POSITION);
-               qglVertexAttribPointer(GLES2ATTRIB_POSITION, 3, GL_FLOAT, false, sizeof(float[3]), NULL);CHECKGLERROR
-               qglDisableVertexAttribArray(GLES2ATTRIB_COLOR);
-               qglVertexAttribPointer(GLES2ATTRIB_COLOR, 4, GL_FLOAT, false, sizeof(float[4]), NULL);CHECKGLERROR
-               qglVertexAttrib4f(GLES2ATTRIB_COLOR, 1, 1, 1, 1);
+               qglEnableVertexAttribArray(GLSLATTRIB_POSITION);
+               qglVertexAttribPointer(GLSLATTRIB_POSITION, 3, GL_FLOAT, false, sizeof(float[3]), NULL);CHECKGLERROR
+               qglDisableVertexAttribArray(GLSLATTRIB_COLOR);
+               qglVertexAttribPointer(GLSLATTRIB_COLOR, 4, GL_FLOAT, false, sizeof(float[4]), NULL);CHECKGLERROR
+               qglVertexAttrib4f(GLSLATTRIB_COLOR, 1, 1, 1, 1);
                gl_state.unit = MAX_TEXTUREUNITS;
                gl_state.clientunit = MAX_TEXTUREUNITS;
                for (i = 0;i < vid.teximageunits;i++)
@@ -1585,8 +1589,8 @@ static void GL_Backend_ResetState(void)
                for (i = 0;i < vid.texarrayunits;i++)
                {
                        GL_BindVBO(0);
-                       qglVertexAttribPointer(i+GLES2ATTRIB_TEXCOORD0, 2, GL_FLOAT, false, sizeof(float[2]), NULL);CHECKGLERROR
-                       qglDisableVertexAttribArray(i+GLES2ATTRIB_TEXCOORD0);CHECKGLERROR
+                       qglVertexAttribPointer(i+GLSLATTRIB_TEXCOORD0, 2, GL_FLOAT, false, sizeof(float[2]), NULL);CHECKGLERROR
+                       qglDisableVertexAttribArray(i+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
                }
                CHECKGLERROR
                break;
@@ -1631,7 +1635,6 @@ void GL_ClientActiveTexture(unsigned int num)
                {
                case RENDERPATH_GL11:
                case RENDERPATH_GL13:
-               case RENDERPATH_GL20:
                case RENDERPATH_CGGL:
                        if (qglActiveTexture)
                        {
@@ -1646,6 +1649,7 @@ void GL_ClientActiveTexture(unsigned int num)
                        break;
                case RENDERPATH_SOFT:
                        break;
+               case RENDERPATH_GL20:
                case RENDERPATH_GLES2:
                        break;
                }
@@ -1847,6 +1851,7 @@ void GL_DepthRange(float nearfrac, float farfrac)
                case RENDERPATH_GL13:
                case RENDERPATH_GL20:
                case RENDERPATH_CGGL:
+               case RENDERPATH_GLES2:
                        qglDepthRange(gl_state.depthrange[0], gl_state.depthrange[1]);
                        break;
                case RENDERPATH_D3D9:
@@ -1872,11 +1877,6 @@ void GL_DepthRange(float nearfrac, float farfrac)
                case RENDERPATH_SOFT:
                        DPSOFTRAST_DepthRange(gl_state.depthrange[0], gl_state.depthrange[1]);
                        break;
-               case RENDERPATH_GLES2:
-                       //Con_DPrintf("FIXME GLES2 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-                       // FIXME: qglDepthRangef instead...  faster...
-                       qglDepthRange(gl_state.depthrange[0], gl_state.depthrange[1]);
-                       break;
                }
        }
 }
@@ -1889,6 +1889,7 @@ void R_SetStencilSeparate(qboolean enable, int writemask, int frontfail, int fro
        case RENDERPATH_GL13:
        case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
+       case RENDERPATH_GLES2:
                CHECKGLERROR
                if (enable)
                {
@@ -1944,9 +1945,6 @@ void R_SetStencilSeparate(qboolean enable, int writemask, int frontfail, int fro
        case RENDERPATH_SOFT:
                //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
                break;
-       case RENDERPATH_GLES2:
-               //Con_DPrintf("FIXME GLES2 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
        }
 }
 
@@ -2165,8 +2163,7 @@ void GL_AlphaTest(int state)
                {
                case RENDERPATH_GL11:
                case RENDERPATH_GL13:
-               case RENDERPATH_GL20:
-               case RENDERPATH_CGGL:
+                       // only fixed function uses alpha test, other paths use pixel kill capability in shaders
                        CHECKGLERROR
                        if (gl_state.alphatest)
                        {
@@ -2179,54 +2176,18 @@ void GL_AlphaTest(int state)
                        break;
                case RENDERPATH_D3D9:
 #ifdef SUPPORTD3D
-                       IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHATESTENABLE, gl_state.alphatest);
+//                     IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHATESTENABLE, gl_state.alphatest);
 #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:
-                       DPSOFTRAST_AlphaTest(gl_state.alphatest);
-                       break;
-               case RENDERPATH_GLES2:
+//                     DPSOFTRAST_AlphaTest(gl_state.alphatest);
                        break;
-               }
-       }
-}
-
-void GL_AlphaFunc(int state, float value)
-{
-       if (gl_state.alphafunc != state || gl_state.alphafuncvalue != value)
-       {
-               gl_state.alphafunc = state;
-               gl_state.alphafuncvalue = value;
-               switch(vid.renderpath)
-               {
-               case RENDERPATH_GL11:
-               case RENDERPATH_GL13:
-               case RENDERPATH_GL20:
                case RENDERPATH_CGGL:
-                       CHECKGLERROR
-                       qglAlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);CHECKGLERROR
-                       break;
-               case RENDERPATH_D3D9:
-#ifdef SUPPORTD3D
-                       IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHAFUNC, d3dcmpforglfunc(gl_state.alphafunc));
-                       IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHAREF, (int)bound(0, value * 256.0f, 255));
-#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:
-                       DPSOFTRAST_AlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);
-                       break;
+               case RENDERPATH_GL20:
                case RENDERPATH_GLES2:
                        break;
                }
@@ -2280,7 +2241,6 @@ void GL_Color(float cr, float cg, float cb, float ca)
                {
                case RENDERPATH_GL11:
                case RENDERPATH_GL13:
-               case RENDERPATH_GL20:
                case RENDERPATH_CGGL:
                        CHECKGLERROR
                        qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);
@@ -2294,8 +2254,9 @@ void GL_Color(float cr, float cg, float cb, float ca)
                case RENDERPATH_SOFT:
                        DPSOFTRAST_Color4f(cr, cg, cb, ca);
                        break;
+               case RENDERPATH_GL20:
                case RENDERPATH_GLES2:
-                       qglVertexAttrib4f(GLES2ATTRIB_COLOR, cr, cg, cb, ca);
+                       qglVertexAttrib4f(GLSLATTRIB_COLOR, cr, cg, cb, ca);
                        break;
                }
        }
@@ -2543,19 +2504,16 @@ unsigned int GL_Backend_CompileProgram(int vertexstrings_count, const char **ver
        if (!programobject)
                return 0;
 
-       if (vid.renderpath == RENDERPATH_GLES2)
-       {
-               qglBindAttribLocation(programobject, GLES2ATTRIB_POSITION , "Attrib_Position" );
-               qglBindAttribLocation(programobject, GLES2ATTRIB_COLOR    , "Attrib_Color"    );
-               qglBindAttribLocation(programobject, GLES2ATTRIB_TEXCOORD0, "Attrib_TexCoord0");
-               qglBindAttribLocation(programobject, GLES2ATTRIB_TEXCOORD1, "Attrib_TexCoord1");
-               qglBindAttribLocation(programobject, GLES2ATTRIB_TEXCOORD2, "Attrib_TexCoord2");
-               qglBindAttribLocation(programobject, GLES2ATTRIB_TEXCOORD3, "Attrib_TexCoord3");
-               qglBindAttribLocation(programobject, GLES2ATTRIB_TEXCOORD4, "Attrib_TexCoord4");
-               qglBindAttribLocation(programobject, GLES2ATTRIB_TEXCOORD5, "Attrib_TexCoord5");
-               qglBindAttribLocation(programobject, GLES2ATTRIB_TEXCOORD6, "Attrib_TexCoord6");
-               qglBindAttribLocation(programobject, GLES2ATTRIB_TEXCOORD7, "Attrib_TexCoord7");
-       }
+       qglBindAttribLocation(programobject, GLSLATTRIB_POSITION , "Attrib_Position" );
+       qglBindAttribLocation(programobject, GLSLATTRIB_COLOR    , "Attrib_Color"    );
+       qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD0, "Attrib_TexCoord0");
+       qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD1, "Attrib_TexCoord1");
+       qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD2, "Attrib_TexCoord2");
+       qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD3, "Attrib_TexCoord3");
+       qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD4, "Attrib_TexCoord4");
+       qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD5, "Attrib_TexCoord5");
+       qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD6, "Attrib_TexCoord6");
+       qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD7, "Attrib_TexCoord7");
 
        if (vertexstrings_count && !GL_Backend_CompileShader(programobject, GL_VERTEX_SHADER, "vertex", vertexstrings_count, vertexstrings_list))
                goto cleanup;
@@ -3224,7 +3182,6 @@ void R_Mesh_VertexPointer(int components, int gltype, size_t stride, const void
        {
        case RENDERPATH_GL11:
        case RENDERPATH_GL13:
-       case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
                if (gl_state.pointer_vertex_components != components || gl_state.pointer_vertex_gltype != gltype || gl_state.pointer_vertex_stride != stride || gl_state.pointer_vertex_pointer != pointer || gl_state.pointer_vertex_vertexbuffer != vertexbuffer || gl_state.pointer_vertex_offset != bufferoffset)
                {
@@ -3240,6 +3197,7 @@ void R_Mesh_VertexPointer(int components, int gltype, size_t stride, const void
                        qglVertexPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
                }
                break;
+       case RENDERPATH_GL20:
        case RENDERPATH_GLES2:
                if (gl_state.pointer_vertex_components != components || gl_state.pointer_vertex_gltype != gltype || gl_state.pointer_vertex_stride != stride || gl_state.pointer_vertex_pointer != pointer || gl_state.pointer_vertex_vertexbuffer != vertexbuffer || gl_state.pointer_vertex_offset != bufferoffset)
                {
@@ -3252,7 +3210,7 @@ void R_Mesh_VertexPointer(int components, int gltype, size_t stride, const void
                        gl_state.pointer_vertex_offset = bufferoffset;
                        CHECKGLERROR
                        GL_BindVBO(bufferobject);
-                       qglVertexAttribPointer(GLES2ATTRIB_POSITION, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
+                       qglVertexAttribPointer(GLSLATTRIB_POSITION, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
                }
                break;
        case RENDERPATH_D3D9:
@@ -3271,7 +3229,6 @@ void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *
        {
        case RENDERPATH_GL11:
        case RENDERPATH_GL13:
-       case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
                CHECKGLERROR
                if (pointer)
@@ -3310,6 +3267,7 @@ void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *
                        }
                }
                break;
+       case RENDERPATH_GL20:
        case RENDERPATH_GLES2:
                CHECKGLERROR
                if (pointer)
@@ -3320,7 +3278,7 @@ void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *
                        {
                                gl_state.pointer_color_enabled = true;
                                CHECKGLERROR
-                               qglEnableVertexAttribArray(GLES2ATTRIB_COLOR);CHECKGLERROR
+                               qglEnableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR
                        }
                        if (gl_state.pointer_color_components != components || gl_state.pointer_color_gltype != gltype || gl_state.pointer_color_stride != stride || gl_state.pointer_color_pointer != pointer || gl_state.pointer_color_vertexbuffer != vertexbuffer || gl_state.pointer_color_offset != bufferoffset)
                        {
@@ -3332,7 +3290,7 @@ void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *
                                gl_state.pointer_color_offset = bufferoffset;
                                CHECKGLERROR
                                GL_BindVBO(bufferobject);
-                               qglVertexAttribPointer(GLES2ATTRIB_COLOR, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
+                               qglVertexAttribPointer(GLSLATTRIB_COLOR, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
                        }
                }
                else
@@ -3342,9 +3300,9 @@ void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *
                        {
                                gl_state.pointer_color_enabled = false;
                                CHECKGLERROR
-                               qglDisableVertexAttribArray(GLES2ATTRIB_COLOR);CHECKGLERROR
+                               qglDisableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR
                                // when color array is on the glColor gets trashed, set it again
-                               qglVertexAttrib4f(GLES2ATTRIB_COLOR, gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
+                               qglVertexAttrib4f(GLSLATTRIB_COLOR, gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
                        }
                }
                break;
@@ -3366,7 +3324,6 @@ void R_Mesh_TexCoordPointer(unsigned int unitnum, int components, int gltype, si
        {
        case RENDERPATH_GL11:
        case RENDERPATH_GL13:
-       case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
                CHECKGLERROR
                if (pointer)
@@ -3404,6 +3361,7 @@ void R_Mesh_TexCoordPointer(unsigned int unitnum, int components, int gltype, si
                        }
                }
                break;
+       case RENDERPATH_GL20:
        case RENDERPATH_GLES2:
                CHECKGLERROR
                if (pointer)
@@ -3413,7 +3371,7 @@ void R_Mesh_TexCoordPointer(unsigned int unitnum, int components, int gltype, si
                        if (!unit->arrayenabled)
                        {
                                unit->arrayenabled = true;
-                               qglEnableVertexAttribArray(unitnum+GLES2ATTRIB_TEXCOORD0);CHECKGLERROR
+                               qglEnableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
                        }
                        // texcoord array
                        if (unit->pointer_texcoord_components != components || unit->pointer_texcoord_gltype != gltype || unit->pointer_texcoord_stride != stride || unit->pointer_texcoord_pointer != pointer || unit->pointer_texcoord_vertexbuffer != vertexbuffer || unit->pointer_texcoord_offset != bufferoffset)
@@ -3425,7 +3383,7 @@ void R_Mesh_TexCoordPointer(unsigned int unitnum, int components, int gltype, si
                                unit->pointer_texcoord_vertexbuffer = vertexbuffer;
                                unit->pointer_texcoord_offset = bufferoffset;
                                GL_BindVBO(bufferobject);
-                               qglVertexAttribPointer(unitnum+GLES2ATTRIB_TEXCOORD0, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
+                               qglVertexAttribPointer(unitnum+GLSLATTRIB_TEXCOORD0, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
                        }
                }
                else
@@ -3434,7 +3392,7 @@ void R_Mesh_TexCoordPointer(unsigned int unitnum, int components, int gltype, si
                        if (unit->arrayenabled)
                        {
                                unit->arrayenabled = false;
-                               qglDisableVertexAttribArray(unitnum+GLES2ATTRIB_TEXCOORD0);CHECKGLERROR
+                               qglDisableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
                        }
                }
                break;
@@ -3694,6 +3652,7 @@ void R_Mesh_TexMatrix(unsigned int unitnum, const matrix4x4_t *matrix)
        case RENDERPATH_GL13:
        case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
+       case RENDERPATH_GLES2:
                if (matrix && matrix->m[3][3])
                {
                        // texmatrix specified, check if it is different
@@ -3731,8 +3690,6 @@ void R_Mesh_TexMatrix(unsigned int unitnum, const matrix4x4_t *matrix)
                break;
        case RENDERPATH_SOFT:
                break;
-       case RENDERPATH_GLES2:
-               break;
        }
 }
 
@@ -3829,116 +3786,28 @@ void R_Mesh_ResetTextureState(void)
 
        BACKENDACTIVECHECK
 
-       CHECKGLERROR
+       for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
+               R_Mesh_TexBind(unitnum, NULL);
+       for (unitnum = 0;unitnum < vid.texarrayunits;unitnum++)
+               R_Mesh_TexCoordPointer(unitnum, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
        switch(vid.renderpath)
        {
        case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
-               for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
-               {
-                       gltextureunit_t *unit = gl_state.units + unitnum;
-                       if (unit->t2d)
-                       {
-                               unit->t2d = 0;
-                               GL_ActiveTexture(unitnum);
-                               qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR
-                       }
-                       if (unit->t3d)
-                       {
-                               unit->t3d = 0;
-                               GL_ActiveTexture(unitnum);
-                               qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR
-                       }
-                       if (unit->tcubemap)
-                       {
-                               unit->tcubemap = 0;
-                               GL_ActiveTexture(unitnum);
-                               qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR
-                       }
-               }
-               for (unitnum = 0;unitnum < vid.texarrayunits;unitnum++)
-               {
-                       gltextureunit_t *unit = gl_state.units + unitnum;
-                       if (unit->arrayenabled)
-                       {
-                               unit->arrayenabled = false;
-                               GL_ClientActiveTexture(unitnum);
-                               qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
-                       }
-               }
-               for (unitnum = 0;unitnum < vid.texunits;unitnum++)
-               {
-                       gltextureunit_t *unit = gl_state.units + unitnum;
-                       if (unit->texmatrixenabled)
-                       {
-                               unit->texmatrixenabled = false;
-                               unit->matrix = identitymatrix;
-                               CHECKGLERROR
-                               GL_ActiveTexture(unitnum);
-                               qglMatrixMode(GL_TEXTURE);CHECKGLERROR
-                               qglLoadIdentity();CHECKGLERROR
-                               qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
-                       }
-               }
+       case RENDERPATH_GLES2:
+       case RENDERPATH_D3D9:
+       case RENDERPATH_D3D10:
+       case RENDERPATH_D3D11:
+       case RENDERPATH_SOFT:
                break;
        case RENDERPATH_GL13:
        case RENDERPATH_GL11:
                for (unitnum = 0;unitnum < vid.texunits;unitnum++)
                {
-                       gltextureunit_t *unit = gl_state.units + unitnum;
-                       if (unit->t2d)
-                       {
-                               unit->t2d = 0;
-                               GL_ActiveTexture(unitnum);
-                               qglDisable(GL_TEXTURE_2D);CHECKGLERROR
-                               qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR
-                       }
-                       if (unit->t3d)
-                       {
-                               unit->t3d = 0;
-                               GL_ActiveTexture(unitnum);
-                               qglDisable(GL_TEXTURE_3D);CHECKGLERROR
-                               qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR
-                       }
-                       if (unit->tcubemap)
-                       {
-                               unit->tcubemap = 0;
-                               GL_ActiveTexture(unitnum);
-                               qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR
-                               qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR
-                       }
-                       if (unit->arrayenabled)
-                       {
-                               unit->arrayenabled = false;
-                               GL_ClientActiveTexture(unitnum);
-                               qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
-                       }
-                       if (unit->texmatrixenabled)
-                       {
-                               unit->texmatrixenabled = false;
-                               unit->matrix = identitymatrix;
-                               CHECKGLERROR
-                               GL_ActiveTexture(unitnum);
-                               qglMatrixMode(GL_TEXTURE);CHECKGLERROR
-                               qglLoadIdentity();CHECKGLERROR
-                               qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
-                       }
-                       if (unit->combine != GL_MODULATE)
-                       {
-                               unit->combine = GL_MODULATE;
-                               GL_ActiveTexture(unitnum);
-                               qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
-                       }
+                       R_Mesh_TexCombine(unitnum, GL_MODULATE, GL_MODULATE, 1, 1);
+                       R_Mesh_TexMatrix(unitnum, NULL);
                }
                break;
-       case RENDERPATH_D3D9:
-       case RENDERPATH_D3D10:
-       case RENDERPATH_D3D11:
-               break;
-       case RENDERPATH_SOFT:
-               break;
-       case RENDERPATH_GLES2:
-               break;
        }
 }
 

diff --git a/gl_backend.h b/gl_backend.h
index 30c3c780838fa07f75657468091f537769bad229..fb634492045fb1e5aa2666642f05e5dc5d302b16 100644 (file)
--- a/gl_backend.h
+++ b/gl_backend.h
@@ -39,7 +39,6 @@ void R_SetStencil(qboolean enable, int writemask, int fail, int zfail, int zpass
 void GL_PolygonOffset(float planeoffset, float depthoffset);
 void GL_CullFace(int state);
 void GL_AlphaTest(int state);
-void GL_AlphaFunc(int state, float value);
 void GL_ColorMask(int r, int g, int b, int a);
 void GL_Color(float cr, float cg, float cb, float ca);
 void GL_ActiveTexture(unsigned int num);

diff --git a/gl_draw.c b/gl_draw.c
index 1de605a25bed32977129cfd54f390f32fc946be9..70600ab34da628e4f52c5e704469d18356ba5d43 100644 (file)
--- a/gl_draw.c
+++ b/gl_draw.c
@@ -1026,7 +1026,6 @@ static void _DrawQ_Setup(void)
        GL_PolygonOffset(0, 0);
        GL_DepthTest(false);
        GL_Color(1,1,1,1);
-       GL_AlphaTest(false);
 }
 
 qboolean r_draw2d_force = false;

diff --git a/gl_rmain.c b/gl_rmain.c
index 196c4fefd580122c02d3e65e0dc43b2f3375b9fc..5b6f2cc4af380593927537636c26112343a46555 100644 (file)
--- a/gl_rmain.c
+++ b/gl_rmain.c
@@ -591,6 +591,24 @@ static const char *builtinshaderstring =
 "// written by Forest 'LordHavoc' Hale\n"
 "// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
 "\n"
+"// GL ES shaders use precision modifiers, standard GL does not\n"
+"#ifndef GL_ES\n"
+"#define lowp\n"
+"#define mediump\n"
+"#define highp\n"
+"#endif\n"
+"\n"
+"#ifdef VERTEX_SHADER\n"
+"attribute vec4 Attrib_Position;  // vertex\n"
+"attribute vec4 Attrib_Color;     // color\n"
+"attribute vec4 Attrib_TexCoord0; // material texcoords\n"
+"attribute vec3 Attrib_TexCoord1; // svector\n"
+"attribute vec3 Attrib_TexCoord2; // tvector\n"
+"attribute vec3 Attrib_TexCoord3; // normal\n"
+"attribute vec4 Attrib_TexCoord4; // lightmap texcoords\n"
+"#endif\n"
+"varying lowp vec4 VertexColor;\n"
+"\n"
 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
 "# define USEFOG\n"
 "#endif\n"
@@ -624,21 +642,21 @@ static const char *builtinshaderstring =
 "//# define myhalf3 half3\n"
 "//# define myhalf4 half4\n"
 "//#else\n"
-"# define myhalf float\n"
-"# define myhalf2 vec2\n"
-"# define myhalf3 vec3\n"
-"# define myhalf4 vec4\n"
+"# define myhalf mediump float\n"
+"# define myhalf2 mediump vec2\n"
+"# define myhalf3 mediump vec3\n"
+"# define myhalf4 mediump vec4\n"
 "//#endif\n"
 "\n"
 "#ifdef VERTEX_SHADER\n"
-"uniform mat4 ModelViewProjectionMatrix;\n"
+"uniform highp mat4 ModelViewProjectionMatrix;\n"
 "#endif\n"
 "\n"
 "#ifdef MODE_DEPTH_OR_SHADOW\n"
 "#ifdef VERTEX_SHADER\n"
 "void main(void)\n"
 "{\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
 "}\n"
 "#endif\n"
 "#else // !MODE_DEPTH_ORSHADOW\n"
@@ -650,15 +668,15 @@ static const char *builtinshaderstring =
 "#ifdef VERTEX_SHADER\n"
 "void main(void)\n"
 "{\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
-"      gl_FrontColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
+"      VertexColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
 "}\n"
 "#endif\n"
 "\n"
 "#ifdef FRAGMENT_SHADER\n"
 "void main(void)\n"
 "{\n"
-"      gl_FragColor = gl_Color;\n"
+"      gl_FragColor = VertexColor;\n"
 "}\n"
 "#endif\n"
 "#else // !MODE_SHOWDEPTH\n"
@@ -667,16 +685,16 @@ static const char *builtinshaderstring =
 "\n"
 "\n"
 "#ifdef MODE_POSTPROCESS\n"
-"varying vec2 TexCoord1;\n"
-"varying vec2 TexCoord2;\n"
+"varying mediump vec2 TexCoord1;\n"
+"varying mediump vec2 TexCoord2;\n"
 "\n"
 "#ifdef VERTEX_SHADER\n"
 "void main(void)\n"
 "{\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
-"      TexCoord1 = gl_MultiTexCoord0.xy;\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
+"      TexCoord1 = Attrib_TexCoord0.xy;\n"
 "#ifdef USEBLOOM\n"
-"      TexCoord2 = gl_MultiTexCoord4.xy;\n"
+"      TexCoord2 = Attrib_TexCoord4.xy;\n"
 "#endif\n"
 "}\n"
 "#endif\n"
@@ -685,24 +703,24 @@ static const char *builtinshaderstring =
 "uniform sampler2D Texture_First;\n"
 "#ifdef USEBLOOM\n"
 "uniform sampler2D Texture_Second;\n"
-"uniform vec4 BloomColorSubtract;\n"
+"uniform lowp vec4 BloomColorSubtract;\n"
 "#endif\n"
 "#ifdef USEGAMMARAMPS\n"
 "uniform sampler2D Texture_GammaRamps;\n"
 "#endif\n"
 "#ifdef USESATURATION\n"
-"uniform float Saturation;\n"
+"uniform lowp float Saturation;\n"
 "#endif\n"
 "#ifdef USEVIEWTINT\n"
-"uniform vec4 ViewTintColor;\n"
+"uniform lowp vec4 ViewTintColor;\n"
 "#endif\n"
 "//uncomment these if you want to use them:\n"
-"uniform vec4 UserVec1;\n"
-"uniform vec4 UserVec2;\n"
-"// uniform vec4 UserVec3;\n"
-"// uniform vec4 UserVec4;\n"
-"// uniform float ClientTime;\n"
-"uniform vec2 PixelSize;\n"
+"uniform mediump vec4 UserVec1;\n"
+"uniform mediump vec4 UserVec2;\n"
+"// uniform mediump vec4 UserVec3;\n"
+"// uniform mediump vec4 UserVec4;\n"
+"// uniform highp float ClientTime;\n"
+"uniform mediump vec2 PixelSize;\n"
 "void main(void)\n"
 "{\n"
 "      gl_FragColor = texture2D(Texture_First, TexCoord1);\n"
@@ -783,22 +801,22 @@ static const char *builtinshaderstring =
 "\n"
 "#ifdef MODE_GENERIC\n"
 "#ifdef USEDIFFUSE\n"
-"varying vec2 TexCoord1;\n"
+"varying mediump vec2 TexCoord1;\n"
 "#endif\n"
 "#ifdef USESPECULAR\n"
-"varying vec2 TexCoord2;\n"
+"varying mediump vec2 TexCoord2;\n"
 "#endif\n"
 "#ifdef VERTEX_SHADER\n"
 "void main(void)\n"
 "{\n"
-"      gl_FrontColor = gl_Color;\n"
+"      VertexColor = Attrib_Color;\n"
 "#ifdef USEDIFFUSE\n"
-"      TexCoord1 = gl_MultiTexCoord0.xy;\n"
+"      TexCoord1 = Attrib_TexCoord0.xy;\n"
 "#endif\n"
 "#ifdef USESPECULAR\n"
-"      TexCoord2 = gl_MultiTexCoord1.xy;\n"
+"      TexCoord2 = Attrib_TexCoord1.xy;\n"
 "#endif\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
 "}\n"
 "#endif\n"
 "\n"
@@ -813,7 +831,7 @@ static const char *builtinshaderstring =
 "void main(void)\n"
 "{\n"
 "#ifdef USEVIEWTINT\n"
-"      gl_FragColor = gl_Color;\n"
+"      gl_FragColor = VertexColor;\n"
 "#else\n"
 "      gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
 "#endif\n"
@@ -841,19 +859,19 @@ static const char *builtinshaderstring =
 "\n"
 "\n"
 "#ifdef MODE_BLOOMBLUR\n"
-"varying TexCoord;\n"
+"varying mediump vec2 TexCoord;\n"
 "#ifdef VERTEX_SHADER\n"
 "void main(void)\n"
 "{\n"
-"      gl_FrontColor = gl_Color;\n"
-"      TexCoord = gl_MultiTexCoord0.xy;\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
+"      VertexColor = Attrib_Color;\n"
+"      TexCoord = Attrib_TexCoord0.xy;\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
 "}\n"
 "#endif\n"
 "\n"
 "#ifdef FRAGMENT_SHADER\n"
 "uniform sampler2D Texture_First;\n"
-"uniform vec4 BloomBlur_Parameters;\n"
+"uniform mediump vec4 BloomBlur_Parameters;\n"
 "\n"
 "void main(void)\n"
 "{\n"
@@ -871,15 +889,15 @@ static const char *builtinshaderstring =
 "#endif\n"
 "#else // !MODE_BLOOMBLUR\n"
 "#ifdef MODE_REFRACTION\n"
-"varying vec2 TexCoord;\n"
-"varying vec4 ModelViewProjectionPosition;\n"
-"uniform mat4 TexMatrix;\n"
+"varying mediump vec2 TexCoord;\n"
+"varying highp vec4 ModelViewProjectionPosition;\n"
+"uniform highp mat4 TexMatrix;\n"
 "#ifdef VERTEX_SHADER\n"
 "\n"
 "void main(void)\n"
 "{\n"
-"      TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
+"      TexCoord = vec2(TexMatrix * Attrib_TexCoord0);\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
 "      ModelViewProjectionPosition = gl_Position;\n"
 "}\n"
 "#endif\n"
@@ -889,13 +907,13 @@ static const char *builtinshaderstring =
 "uniform sampler2D Texture_Refraction;\n"
 "uniform sampler2D Texture_Reflection;\n"
 "\n"
-"uniform vec4 DistortScaleRefractReflect;\n"
-"uniform vec4 ScreenScaleRefractReflect;\n"
-"uniform vec4 ScreenCenterRefractReflect;\n"
-"uniform vec4 RefractColor;\n"
-"uniform vec4 ReflectColor;\n"
-"uniform float ReflectFactor;\n"
-"uniform float ReflectOffset;\n"
+"uniform mediump vec4 DistortScaleRefractReflect;\n"
+"uniform mediump vec4 ScreenScaleRefractReflect;\n"
+"uniform mediump vec4 ScreenCenterRefractReflect;\n"
+"uniform lowp vec4 RefractColor;\n"
+"uniform lowp vec4 ReflectColor;\n"
+"uniform mediump float ReflectFactor;\n"
+"uniform mediump float ReflectOffset;\n"
 "\n"
 "void main(void)\n"
 "{\n"
@@ -922,21 +940,21 @@ static const char *builtinshaderstring =
 "\n"
 "\n"
 "#ifdef MODE_WATER\n"
-"varying vec2 TexCoord;\n"
-"varying vec3 EyeVector;\n"
-"varying vec4 ModelViewProjectionPosition;\n"
+"varying mediump vec2 TexCoord;\n"
+"varying highp vec3 EyeVector;\n"
+"varying highp vec4 ModelViewProjectionPosition;\n"
 "#ifdef VERTEX_SHADER\n"
-"uniform vec3 EyePosition;\n"
-"uniform mat4 TexMatrix;\n"
+"uniform highp vec3 EyePosition;\n"
+"uniform highp mat4 TexMatrix;\n"
 "\n"
 "void main(void)\n"
 "{\n"
-"      TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
-"      vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
-"      EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
-"      EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
-"      EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
+"      TexCoord = vec2(TexMatrix * Attrib_TexCoord0);\n"
+"      vec3 EyeVectorModelSpace = EyePosition - Attrib_Position.xyz;\n"
+"      EyeVector.x = dot(EyeVectorModelSpace, Attrib_TexCoord1.xyz);\n"
+"      EyeVector.y = dot(EyeVectorModelSpace, Attrib_TexCoord2.xyz);\n"
+"      EyeVector.z = dot(EyeVectorModelSpace, Attrib_TexCoord3.xyz);\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
 "      ModelViewProjectionPosition = gl_Position;\n"
 "}\n"
 "#endif\n"
@@ -946,16 +964,16 @@ static const char *builtinshaderstring =
 "uniform sampler2D Texture_Refraction;\n"
 "uniform sampler2D Texture_Reflection;\n"
 "\n"
-"uniform vec4 DistortScaleRefractReflect;\n"
-"uniform vec4 ScreenScaleRefractReflect;\n"
-"uniform vec4 ScreenCenterRefractReflect;\n"
-"uniform vec4 RefractColor;\n"
-"uniform vec4 ReflectColor;\n"
-"uniform float ReflectFactor;\n"
-"uniform float ReflectOffset;\n"
-"uniform float ClientTime;\n"
+"uniform mediump vec4 DistortScaleRefractReflect;\n"
+"uniform mediump vec4 ScreenScaleRefractReflect;\n"
+"uniform mediump vec4 ScreenCenterRefractReflect;\n"
+"uniform lowp vec4 RefractColor;\n"
+"uniform lowp vec4 ReflectColor;\n"
+"uniform mediump float ReflectFactor;\n"
+"uniform mediump float ReflectOffset;\n"
+"uniform highp float ClientTime;\n"
 "#ifdef USENORMALMAPSCROLLBLEND\n"
-"uniform vec2 NormalmapScrollBlend;\n"
+"uniform highp vec2 NormalmapScrollBlend;\n"
 "#endif\n"
 "\n"
 "void main(void)\n"
@@ -998,54 +1016,54 @@ static const char *builtinshaderstring =
 "\n"
 "// common definitions between vertex shader and fragment shader:\n"
 "\n"
-"varying vec2 TexCoord;\n"
+"varying mediump vec2 TexCoord;\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"varying vec2 TexCoord2;\n"
+"varying mediump vec2 TexCoord2;\n"
 "#endif\n"
 "#ifdef USELIGHTMAP\n"
-"varying vec2 TexCoordLightmap;\n"
+"varying mediump vec2 TexCoordLightmap;\n"
 "#endif\n"
 "\n"
 "#ifdef MODE_LIGHTSOURCE\n"
-"varying vec3 CubeVector;\n"
+"varying mediump vec3 CubeVector;\n"
 "#endif\n"
 "\n"
 "#if (defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)) && defined(USEDIFFUSE)\n"
-"varying vec3 LightVector;\n"
+"varying mediump vec3 LightVector;\n"
 "#endif\n"
 "\n"
 "#ifdef USEEYEVECTOR\n"
-"varying vec3 EyeVector;\n"
+"varying highp vec3 EyeVector;\n"
 "#endif\n"
 "#ifdef USEFOG\n"
-"varying vec4 EyeVectorModelSpaceFogPlaneVertexDist;\n"
+"varying highp vec4 EyeVectorModelSpaceFogPlaneVertexDist;\n"
 "#endif\n"
 "\n"
 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
-"varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
-"varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
-"varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
+"varying lowp vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
+"varying lowp vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
+"varying lowp vec3 VectorR; // direction of R texcoord (surface normal)\n"
 "#endif\n"
 "\n"
 "#ifdef USEREFLECTION\n"
-"varying vec4 ModelViewProjectionPosition;\n"
+"varying highp vec4 ModelViewProjectionPosition;\n"
 "#endif\n"
 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
-"uniform vec3 LightPosition;\n"
-"varying vec4 ModelViewPosition;\n"
+"uniform highp vec3 LightPosition;\n"
+"varying highp vec4 ModelViewPosition;\n"
 "#endif\n"
 "\n"
 "#ifdef MODE_LIGHTSOURCE\n"
-"uniform vec3 LightPosition;\n"
+"uniform highp vec3 LightPosition;\n"
 "#endif\n"
-"uniform vec3 EyePosition;\n"
+"uniform highp vec3 EyePosition;\n"
 "#ifdef MODE_LIGHTDIRECTION\n"
-"uniform vec3 LightDir;\n"
+"uniform highp vec3 LightDir;\n"
 "#endif\n"
-"uniform vec4 FogPlane;\n"
+"uniform highp vec4 FogPlane;\n"
 "\n"
 "#ifdef USESHADOWMAPORTHO\n"
-"varying vec3 ShadowMapTC;\n"
+"varying mediump vec3 ShadowMapTC;\n"
 "#endif\n"
 "\n"
 "\n"
@@ -1100,14 +1118,14 @@ static const char *builtinshaderstring =
 "uniform sampler2D Texture_ScreenSpecular;\n"
 "#endif\n"
 "\n"
-"uniform myhalf3 Color_Pants;\n"
-"uniform myhalf3 Color_Shirt;\n"
-"uniform myhalf3 FogColor;\n"
+"uniform lowp vec3 Color_Pants;\n"
+"uniform lowp vec3 Color_Shirt;\n"
+"uniform lowp vec3 FogColor;\n"
 "\n"
 "#ifdef USEFOG\n"
-"uniform float FogRangeRecip;\n"
-"uniform float FogPlaneViewDist;\n"
-"uniform float FogHeightFade;\n"
+"uniform highp float FogRangeRecip;\n"
+"uniform highp float FogPlaneViewDist;\n"
+"uniform highp float FogHeightFade;\n"
 "vec3 FogVertex(vec3 surfacecolor)\n"
 "{\n"
 "      vec3 EyeVectorModelSpace = EyeVectorModelSpaceFogPlaneVertexDist.xyz;\n"
@@ -1129,7 +1147,7 @@ static const char *builtinshaderstring =
 "#endif\n"
 "\n"
 "#ifdef USEOFFSETMAPPING\n"
-"uniform float OffsetMapping_Scale;\n"
+"uniform mediump float OffsetMapping_Scale;\n"
 "vec2 OffsetMapping(vec2 TexCoord)\n"
 "{\n"
 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
@@ -1193,8 +1211,8 @@ static const char *builtinshaderstring =
 "#endif\n"
 "\n"
 "#if defined(USESHADOWMAP2D)\n"
-"uniform vec2 ShadowMap_TextureScale;\n"
-"uniform vec4 ShadowMap_Parameters;\n"
+"uniform mediump vec2 ShadowMap_TextureScale;\n"
+"uniform mediump vec4 ShadowMap_Parameters;\n"
 "#endif\n"
 "\n"
 "#if defined(USESHADOWMAP2D)\n"
@@ -1319,31 +1337,31 @@ static const char *builtinshaderstring =
 "\n"
 "#ifdef MODE_DEFERREDGEOMETRY\n"
 "#ifdef VERTEX_SHADER\n"
-"uniform mat4 TexMatrix;\n"
+"uniform highp mat4 TexMatrix;\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"uniform mat4 BackgroundTexMatrix;\n"
+"uniform highp mat4 BackgroundTexMatrix;\n"
 "#endif\n"
-"uniform mat4 ModelViewMatrix;\n"
+"uniform highp mat4 ModelViewMatrix;\n"
 "void main(void)\n"
 "{\n"
-"      TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
+"      TexCoord = vec2(TexMatrix * Attrib_TexCoord0);\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"      gl_FrontColor = gl_Color;\n"
-"      TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
+"      VertexColor = Attrib_Color;\n"
+"      TexCoord2 = vec2(BackgroundTexMatrix * Attrib_TexCoord0);\n"
 "#endif\n"
 "\n"
 "      // transform unnormalized eye direction into tangent space\n"
 "#ifdef USEOFFSETMAPPING\n"
-"      vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
-"      EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
-"      EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
-"      EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
+"      vec3 EyeVectorModelSpace = EyePosition - Attrib_Position.xyz;\n"
+"      EyeVector.x = dot(EyeVectorModelSpace, Attrib_TexCoord1.xyz);\n"
+"      EyeVector.y = dot(EyeVectorModelSpace, Attrib_TexCoord2.xyz);\n"
+"      EyeVector.z = dot(EyeVectorModelSpace, Attrib_TexCoord3.xyz);\n"
 "#endif\n"
 "\n"
-"      VectorS = (ModelViewMatrix * vec4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
-"      VectorT = (ModelViewMatrix * vec4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
-"      VectorR = (ModelViewMatrix * vec4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
+"      VectorS = (ModelViewMatrix * vec4(Attrib_TexCoord1.xyz, 0)).xyz;\n"
+"      VectorT = (ModelViewMatrix * vec4(Attrib_TexCoord2.xyz, 0)).xyz;\n"
+"      VectorR = (ModelViewMatrix * vec4(Attrib_TexCoord3.xyz, 0)).xyz;\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
 "}\n"
 "#endif // VERTEX_SHADER\n"
 "\n"
@@ -1363,9 +1381,9 @@ static const char *builtinshaderstring =
 "\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
 "      float alpha = texture2D(Texture_Color, TexCoord).a;\n"
-"      float terrainblend = clamp(float(gl_Color.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
-"      //float terrainblend = min(float(gl_Color.a) * alpha * 2.0, float(1.0));\n"
-"      //float terrainblend = float(gl_Color.a) * alpha > 0.5;\n"
+"      float terrainblend = clamp(float(VertexColor.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
+"      //float terrainblend = min(float(VertexColor.a) * alpha * 2.0, float(1.0));\n"
+"      //float terrainblend = float(VertexColor.a) * alpha > 0.5;\n"
 "#endif\n"
 "\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
@@ -1386,18 +1404,18 @@ static const char *builtinshaderstring =
 "\n"
 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
 "#ifdef VERTEX_SHADER\n"
-"uniform mat4 ModelViewMatrix;\n"
+"uniform highp mat4 ModelViewMatrix;\n"
 "void main(void)\n"
 "{\n"
-"      ModelViewPosition = ModelViewMatrix * gl_Vertex;\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
+"      ModelViewPosition = ModelViewMatrix * Attrib_Position;\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
 "}\n"
 "#endif // VERTEX_SHADER\n"
 "\n"
 "#ifdef FRAGMENT_SHADER\n"
-"uniform mat4 ViewToLight;\n"
+"uniform highp mat4 ViewToLight;\n"
 "// ScreenToDepth = vec2(Far / (Far - Near), Far * Near / (Near - Far));\n"
-"uniform vec2 ScreenToDepth;\n"
+"uniform highp vec2 ScreenToDepth;\n"
 "uniform myhalf3 DeferredColor_Ambient;\n"
 "uniform myhalf3 DeferredColor_Diffuse;\n"
 "#ifdef USESPECULAR\n"
@@ -1465,73 +1483,73 @@ static const char *builtinshaderstring =
 "\n"
 "\n"
 "#ifdef VERTEX_SHADER\n"
-"uniform mat4 TexMatrix;\n"
+"uniform highp mat4 TexMatrix;\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"uniform mat4 BackgroundTexMatrix;\n"
+"uniform highp mat4 BackgroundTexMatrix;\n"
 "#endif\n"
 "#ifdef MODE_LIGHTSOURCE\n"
-"uniform mat4 ModelToLight;\n"
+"uniform highp mat4 ModelToLight;\n"
 "#endif\n"
 "#ifdef USESHADOWMAPORTHO\n"
-"uniform mat4 ShadowMapMatrix;\n"
+"uniform highp mat4 ShadowMapMatrix;\n"
 "#endif\n"
 "void main(void)\n"
 "{\n"
 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
-"      gl_FrontColor = gl_Color;\n"
+"      VertexColor = Attrib_Color;\n"
 "#endif\n"
 "      // copy the surface texcoord\n"
-"      TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
+"      TexCoord = vec2(TexMatrix * Attrib_TexCoord0);\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"      TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
+"      TexCoord2 = vec2(BackgroundTexMatrix * Attrib_TexCoord0);\n"
 "#endif\n"
 "#ifdef USELIGHTMAP\n"
-"      TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
+"      TexCoordLightmap = vec2(Attrib_TexCoord4);\n"
 "#endif\n"
 "\n"
 "#ifdef MODE_LIGHTSOURCE\n"
 "      // transform vertex position into light attenuation/cubemap space\n"
 "      // (-1 to +1 across the light box)\n"
-"      CubeVector = vec3(ModelToLight * gl_Vertex);\n"
+"      CubeVector = vec3(ModelToLight * Attrib_Position);\n"
 "\n"
 "# ifdef USEDIFFUSE\n"
 "      // transform unnormalized light direction into tangent space\n"
 "      // (we use unnormalized to ensure that it interpolates correctly and then\n"
 "      //  normalize it per pixel)\n"
-"      vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
-"      LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
-"      LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
-"      LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
+"      vec3 lightminusvertex = LightPosition - Attrib_Position.xyz;\n"
+"      LightVector.x = dot(lightminusvertex, Attrib_TexCoord1.xyz);\n"
+"      LightVector.y = dot(lightminusvertex, Attrib_TexCoord2.xyz);\n"
+"      LightVector.z = dot(lightminusvertex, Attrib_TexCoord3.xyz);\n"
 "# endif\n"
 "#endif\n"
 "\n"
 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
-"      LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
-"      LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
-"      LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
+"      LightVector.x = dot(LightDir, Attrib_TexCoord1.xyz);\n"
+"      LightVector.y = dot(LightDir, Attrib_TexCoord2.xyz);\n"
+"      LightVector.z = dot(LightDir, Attrib_TexCoord3.xyz);\n"
 "#endif\n"
 "\n"
 "      // transform unnormalized eye direction into tangent space\n"
 "#ifdef USEEYEVECTOR\n"
-"      vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
-"      EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
-"      EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
-"      EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
+"      vec3 EyeVectorModelSpace = EyePosition - Attrib_Position.xyz;\n"
+"      EyeVector.x = dot(EyeVectorModelSpace, Attrib_TexCoord1.xyz);\n"
+"      EyeVector.y = dot(EyeVectorModelSpace, Attrib_TexCoord2.xyz);\n"
+"      EyeVector.z = dot(EyeVectorModelSpace, Attrib_TexCoord3.xyz);\n"
 "#endif\n"
 "\n"
 "#ifdef USEFOG\n"
-"      EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - gl_Vertex.xyz;\n"
-"      EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n"
+"      EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - Attrib_Position.xyz;\n"
+"      EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, Attrib_Position);\n"
 "#endif\n"
 "\n"
 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE)\n"
-"      VectorS = gl_MultiTexCoord1.xyz;\n"
-"      VectorT = gl_MultiTexCoord2.xyz;\n"
-"      VectorR = gl_MultiTexCoord3.xyz;\n"
+"      VectorS = Attrib_TexCoord1.xyz;\n"
+"      VectorT = Attrib_TexCoord2.xyz;\n"
+"      VectorR = Attrib_TexCoord3.xyz;\n"
 "#endif\n"
 "\n"
 "      // transform vertex to camera space, using ftransform to match non-VS rendering\n"
-"      gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
+"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
 "\n"
 "#ifdef USESHADOWMAPORTHO\n"
 "      ShadowMapTC = vec3(ShadowMapMatrix * gl_Position);\n"
@@ -1561,13 +1579,13 @@ static const char *builtinshaderstring =
 "#endif\n"
 "uniform myhalf Alpha;\n"
 "#ifdef USEREFLECTION\n"
-"uniform vec4 DistortScaleRefractReflect;\n"
-"uniform vec4 ScreenScaleRefractReflect;\n"
-"uniform vec4 ScreenCenterRefractReflect;\n"
-"uniform myhalf4 ReflectColor;\n"
+"uniform mediump vec4 DistortScaleRefractReflect;\n"
+"uniform mediump vec4 ScreenScaleRefractReflect;\n"
+"uniform mediump vec4 ScreenCenterRefractReflect;\n"
+"uniform lowp vec4 ReflectColor;\n"
 "#endif\n"
 "#ifdef USEREFLECTCUBE\n"
-"uniform mat4 ModelToReflectCube;\n"
+"uniform highp mat4 ModelToReflectCube;\n"
 "uniform sampler2D Texture_ReflectMask;\n"
 "uniform samplerCube Texture_ReflectCube;\n"
 "#endif\n"
@@ -1596,9 +1614,9 @@ static const char *builtinshaderstring =
 "      color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
 "#endif\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"      myhalf terrainblend = clamp(myhalf(gl_Color.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
-"      //myhalf terrainblend = min(myhalf(gl_Color.a) * color.a * 2.0, myhalf(1.0));\n"
-"      //myhalf terrainblend = myhalf(gl_Color.a) * color.a > 0.5;\n"
+"      myhalf terrainblend = clamp(myhalf(VertexColor.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
+"      //myhalf terrainblend = min(myhalf(VertexColor.a) * color.a * 2.0, myhalf(1.0));\n"
+"      //myhalf terrainblend = myhalf(VertexColor.a) * color.a > 0.5;\n"
 "      color.rgb = mix(myhalf3(texture2D(Texture_SecondaryColor, TexCoord2)), color.rgb, terrainblend);\n"
 "      color.a = 1.0;\n"
 "      //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
@@ -1714,7 +1732,7 @@ static const char *builtinshaderstring =
 "      color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
 "#endif // MODE_LIGHTMAP\n"
 "#ifdef MODE_VERTEXCOLOR\n"
-"      color.rgb = diffusetex * (Color_Ambient + myhalf3(gl_Color.rgb) * Color_Diffuse);\n"
+"      color.rgb = diffusetex * (Color_Ambient + myhalf3(VertexColor.rgb) * Color_Diffuse);\n"
 "#endif // MODE_VERTEXCOLOR\n"
 "#ifdef MODE_FLATCOLOR\n"
 "      color.rgb = diffusetex * Color_Ambient;\n"
@@ -3017,1388 +3035,108 @@ const char *builtincgshaderstring =
 "uniform half3 Color_Ambient : register(c3),\n"
 "uniform half3 Color_Diffuse : register(c4),\n"
 "uniform half3 Color_Specular : register(c5),\n"
-"uniform half SpecularPower : register(c36),\n"
-"#ifdef USEGLOW\n"
-"uniform half3 Color_Glow : register(c6),\n"
-"#endif\n"
-"uniform half Alpha : register(c0),\n"
-"#ifdef USEREFLECTION\n"
-"uniform float4 DistortScaleRefractReflect : register(c14),\n"
-"uniform float4 ScreenScaleRefractReflect : register(c32),\n"
-"uniform float4 ScreenCenterRefractReflect : register(c31),\n"
-"uniform half4 ReflectColor : register(c26),\n"
-"#endif\n"
-"#ifdef USEREFLECTCUBE\n"
-"uniform float4x4 ModelToReflectCube : register(c48),\n"
-"uniform sampler Texture_ReflectMask : register(s5),\n"
-"uniform samplerCUBE Texture_ReflectCube : register(s6),\n"
-"#endif\n"
-"#ifdef MODE_LIGHTDIRECTION\n"
-"uniform half3 LightColor : register(c21),\n"
-"#endif\n"
-"#ifdef MODE_LIGHTSOURCE\n"
-"uniform half3 LightColor : register(c21),\n"
-"#endif\n"
-"\n"
-"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
-"uniform sampler Texture_Attenuation : register(s9),\n"
-"uniform samplerCUBE Texture_Cube : register(s10),\n"
-"#endif\n"
-"\n"
-"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
-"\n"
-"#ifdef USESHADOWMAP2D\n"
-"# ifdef USESHADOWSAMPLER\n"
-"uniform sampler Texture_ShadowMap2D : register(s15),\n"
-"# else\n"
-"uniform sampler Texture_ShadowMap2D : register(s15),\n"
-"# endif\n"
-"#endif\n"
-"\n"
-"#ifdef USESHADOWMAPVSDCT\n"
-"uniform samplerCUBE Texture_CubeProjection : register(s12),\n"
-"#endif\n"
-"\n"
-"#if defined(USESHADOWMAP2D)\n"
-"uniform float2 ShadowMap_TextureScale : register(c35),\n"
-"uniform float4 ShadowMap_Parameters : register(c34),\n"
-"#endif\n"
-"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
-"\n"
-"out float4 gl_FragColor : COLOR\n"
-")\n"
-"{\n"
-"      float2 TexCoord = TexCoordBoth.xy;\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"      float2 TexCoord2 = TexCoordBoth.zw;\n"
-"#endif\n"
-"#ifdef USEOFFSETMAPPING\n"
-"      // apply offsetmapping\n"
-"      float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
-"#define TexCoord TexCoordOffset\n"
-"#endif\n"
-"\n"
-"      // combine the diffuse textures (base, pants, shirt)\n"
-"      half4 color = half4(tex2D(Texture_Color, TexCoord));\n"
-"#ifdef USEALPHAKILL\n"
-"      if (color.a < 0.5)\n"
-"              discard;\n"
-"#endif\n"
-"      color.a *= Alpha;\n"
-"#ifdef USECOLORMAPPING\n"
-"      color.rgb += half3(tex2D(Texture_Pants, TexCoord).rgb) * Color_Pants + half3(tex2D(Texture_Shirt, TexCoord).rgb) * Color_Shirt;\n"
-"#endif\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"      half terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n"
-"      //half terrainblend = min(half(gl_FrontColor.a) * color.a * 2.0, half(1.0));\n"
-"      //half terrainblend = half(gl_FrontColor.a) * color.a > 0.5;\n"
-"      color.rgb = half3(lerp(tex2D(Texture_SecondaryColor, TexCoord2).rgb, float3(color.rgb), terrainblend));\n"
-"      color.a = 1.0;\n"
-"      //color = half4(lerp(float4(1, 0, 0, 1), color, terrainblend));\n"
-"#endif\n"
-"\n"
-"      // get the surface normal\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"      half3 surfacenormal = normalize(half3(lerp(tex2D(Texture_SecondaryNormal, TexCoord2).rgb, tex2D(Texture_Normal, TexCoord).rgb, terrainblend)) - half3(0.5, 0.5, 0.5));\n"
-"#else\n"
-"      half3 surfacenormal = half3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5, 0.5, 0.5)));\n"
-"#endif\n"
-"\n"
-"      // get the material colors\n"
-"      half3 diffusetex = color.rgb;\n"
-"#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
-"# ifdef USEVERTEXTEXTUREBLEND\n"
-"      half4 glosstex = half4(lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord), terrainblend));\n"
-"# else\n"
-"      half4 glosstex = half4(tex2D(Texture_Gloss, TexCoord));\n"
-"# endif\n"
-"#endif\n"
-"\n"
-"#ifdef USEREFLECTCUBE\n"
-"      float3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
-"      float3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
-"      float3 ReflectCubeTexCoord = mul(ModelToReflectCube, float4(ModelReflectVector, 0)).xyz;\n"
-"      diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord).rgb) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord).rgb);\n"
-"#endif\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_LIGHTSOURCE\n"
-"      // light source\n"
-"#ifdef USEDIFFUSE\n"
-"      half3 lightnormal = half3(normalize(LightVector));\n"
-"      half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
-"      color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
-"#ifdef USESPECULAR\n"
-"#ifdef USEEXACTSPECULARMATH\n"
-"      half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n"
-"#else\n"
-"      half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n"
-"      half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n"
-"#endif\n"
-"      color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
-"#endif\n"
-"#else\n"
-"      color.rgb = diffusetex * Color_Ambient;\n"
-"#endif\n"
-"      color.rgb *= LightColor;\n"
-"      color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)).r);\n"
-"#if defined(USESHADOWMAP2D)\n"
-"      color.rgb *= half(ShadowMapCompare(CubeVector, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
-"#ifdef USESHADOWMAPVSDCT\n"
-", Texture_CubeProjection\n"
-"#endif\n"
-"      ));\n"
-"\n"
-"#endif\n"
-"# ifdef USECUBEFILTER\n"
-"      color.rgb *= half3(texCUBE(Texture_Cube, CubeVector).rgb);\n"
-"# endif\n"
-"\n"
-"#ifdef USESHADOWMAP2D\n"
-"#ifdef USESHADOWMAPVSDCT\n"
-"//    float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters, Texture_CubeProjection);\n"
-"#else\n"
-"//    float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters);\n"
-"#endif\n"
-"//    color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n"
-"//    color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n"
-"//    color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n"
-"//    color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
-"//    color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n"
-"//    color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n"
-"//    color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n"
-"//    color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
-"//    color.r = half(shadowmaptc.z - texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
-"//    color.r = half(shadowmaptc.z);\n"
-"//    color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
-"//    color.r = half(shadowmaptc.z);\n"
-"//    color.r = 1;\n"
-"//    color.rgb = abs(CubeVector);\n"
-"#endif\n"
-"//    color.rgb = half3(1,1,1);\n"
-"#endif // MODE_LIGHTSOURCE\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_LIGHTDIRECTION\n"
-"#define SHADING\n"
-"#ifdef USEDIFFUSE\n"
-"      half3 lightnormal = half3(normalize(LightVector));\n"
-"#endif\n"
-"#define lightcolor LightColor\n"
-"#endif // MODE_LIGHTDIRECTION\n"
-"#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
-"#define SHADING\n"
-"      // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
-"      half3 lightnormal_modelspace = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
-"      half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n"
-"      // convert modelspace light vector to tangentspace\n"
-"      half3 lightnormal;\n"
-"      lightnormal.x = dot(lightnormal_modelspace, half3(VectorS));\n"
-"      lightnormal.y = dot(lightnormal_modelspace, half3(VectorT));\n"
-"      lightnormal.z = dot(lightnormal_modelspace, half3(VectorR));\n"
-"      // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
-"      // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
-"      // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
-"      // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
-"      // to map the luxels to coordinates on the draw surfaces), which also causes\n"
-"      // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
-"      // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
-"      // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
-"      // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
-"      lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
-"#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
-"#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
-"#define SHADING\n"
-"      // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
-"      half3 lightnormal = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
-"      half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n"
-"#endif\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_FAKELIGHT\n"
-"#define SHADING\n"
-"half3 lightnormal = half3(normalize(EyeVector));\n"
-"half3 lightcolor = half3(1.0,1.0,1.0);\n"
-"#endif // MODE_FAKELIGHT\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_LIGHTMAP\n"
-"      color.rgb = diffusetex * (Color_Ambient + half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb) * Color_Diffuse);\n"
-"#endif // MODE_LIGHTMAP\n"
-"#ifdef MODE_VERTEXCOLOR\n"
-"      color.rgb = diffusetex * (Color_Ambient + half3(gl_FrontColor.rgb) * Color_Diffuse);\n"
-"#endif // MODE_VERTEXCOLOR\n"
-"#ifdef MODE_FLATCOLOR\n"
-"      color.rgb = diffusetex * Color_Ambient;\n"
-"#endif // MODE_FLATCOLOR\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef SHADING\n"
-"# ifdef USEDIFFUSE\n"
-"      half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
-"#  ifdef USESPECULAR\n"
-"#   ifdef USEEXACTSPECULARMATH\n"
-"      half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n"
-"#   else\n"
-"      half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n"
-"      half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n"
-"#   endif\n"
-"      color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
-"#  else\n"
-"      color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
-"#  endif\n"
-"# else\n"
-"      color.rgb = diffusetex * Color_Ambient;\n"
-"# endif\n"
-"#endif\n"
-"\n"
-"#ifdef USESHADOWMAPORTHO\n"
-"      color.rgb *= half(ShadowMapCompare(ShadowMapTC, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale));\n"
-"#endif\n"
-"\n"
-"#ifdef USEDEFERREDLIGHTMAP\n"
-"      float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
-"      color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord).rgb) * DeferredMod_Diffuse;\n"
-"      color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord).rgb) * DeferredMod_Specular;\n"
-"//    color.rgb = half3(tex2D(Texture_ScreenDepth, ScreenTexCoord).rgb);\n"
-"//    color.r = half(texDepth2D(Texture_ScreenDepth, ScreenTexCoord)) * 1.0;\n"
-"#endif\n"
-"\n"
-"#ifdef USEGLOW\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"      color.rgb += half3(lerp(tex2D(Texture_SecondaryGlow, TexCoord2).rgb, tex2D(Texture_Glow, TexCoord).rgb, terrainblend)) * Color_Glow;\n"
-"#else\n"
-"      color.rgb += half3(tex2D(Texture_Glow, TexCoord).rgb) * Color_Glow;\n"
-"#endif\n"
-"#endif\n"
-"\n"
-"#ifdef USEFOG\n"
-"      color.rgb = FogVertex(color.rgb, FogColor, EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask, Texture_FogHeightTexture);\n"
-"#endif\n"
-"\n"
-"      // reflection must come last because it already contains exactly the correct fog (the reflection render preserves camera distance from the plane, it only flips the side) and ContrastBoost/SceneBrightness\n"
-"#ifdef USEREFLECTION\n"
-"      float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
-"      //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
-"      float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
-"      float2 ScreenTexCoord = SafeScreenTexCoord + float3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5))).xy * DistortScaleRefractReflect.zw;\n"
-"      // FIXME temporary hack to detect the case that the reflection\n"
-"      // gets blackened at edges due to leaving the area that contains actual\n"
-"      // content.\n"
-"      // Remove this 'ack once we have a better way to stop this thing from\n"
-"      // 'appening.\n"
-"      float f = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
-"      ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
-"      color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord).rgb) * ReflectColor.rgb, ReflectColor.a);\n"
-"#endif\n"
-"\n"
-"      gl_FragColor = float4(color);\n"
-"}\n"
-"#endif // FRAGMENT_SHADER\n"
-"\n"
-"#endif // !MODE_DEFERREDLIGHTSOURCE\n"
-"#endif // !MODE_DEFERREDGEOMETRY\n"
-"#endif // !MODE_WATER\n"
-"#endif // !MODE_REFRACTION\n"
-"#endif // !MODE_BLOOMBLUR\n"
-"#endif // !MODE_GENERIC\n"
-"#endif // !MODE_POSTPROCESS\n"
-"#endif // !MODE_SHOWDEPTH\n"
-"#endif // !MODE_DEPTH_OR_SHADOW\n"
-;
-
-/*
-=========================================================================================================================================================
-
-
-
-=========================================================================================================================================================
-
-
-
-=========================================================================================================================================================
-
-
-
-=========================================================================================================================================================
-
-
-
-=========================================================================================================================================================
-
-
-
-=========================================================================================================================================================
-
-
-
-=========================================================================================================================================================
-*/
-
-const char *builtingles2shaderstring =
-"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
-"// written by Forest 'LordHavoc' Hale\n"
-"// shadowmapping enhancements by Lee 'eihrul' Salzman\n"
-"\n"
-"#ifdef VERTEX_SHADER\n"
-"attribute vec4 Attrib_Position;\n"
-"attribute vec4 Attrib_Color;\n"
-"attribute vec4 Attrib_TexCoord0;\n"
-"attribute vec3 Attrib_TexCoord1;\n"
-"attribute vec3 Attrib_TexCoord2;\n"
-"attribute vec3 Attrib_TexCoord3;\n"
-"attribute vec4 Attrib_TexCoord4;\n"
-"#endif\n"
-"varying lowp vec4 VertexColor;\n"
-"\n"
-"#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE) || defined(USEFOGHEIGHTTEXTURE)\n"
-"# define USEFOG\n"
-"#endif\n"
-"#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
-"#define USELIGHTMAP\n"
-"#endif\n"
-"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(MODE_FAKELIGHT)\n"
-"#define USEEYEVECTOR\n"
-"#endif\n"
-"\n"
-"#ifdef USESHADOWMAP2D\n"
-"# ifdef GL_EXT_gpu_shader4\n"
-"#   extension GL_EXT_gpu_shader4 : enable\n"
-"# endif\n"
-"# ifdef GL_ARB_texture_gather\n"
-"#   extension GL_ARB_texture_gather : enable\n"
-"# else\n"
-"#   ifdef GL_AMD_texture_texture4\n"
-"#     extension GL_AMD_texture_texture4 : enable\n"
-"#   endif\n"
-"# endif\n"
-"#endif\n"
-"\n"
-"//#ifdef USESHADOWSAMPLER\n"
-"//# extension GL_ARB_shadow : enable\n"
-"//#endif\n"
-"\n"
-"//#ifdef __GLSL_CG_DATA_TYPES\n"
-"//# define myhalf half\n"
-"//# define myhalf2 half2\n"
-"//# define myhalf3 half3\n"
-"//# define myhalf4 half4\n"
-"//#else\n"
-"# define myhalf mediump float\n"
-"# define myhalf2 mediump vec2\n"
-"# define myhalf3 mediump vec3\n"
-"# define myhalf4 mediump vec4\n"
-"//#endif\n"
-"\n"
-"#ifdef VERTEX_SHADER\n"
-"uniform highp mat4 ModelViewProjectionMatrix;\n"
-"#endif\n"
-"\n"
-"#ifdef MODE_DEPTH_OR_SHADOW\n"
-"#ifdef VERTEX_SHADER\n"
-"void main(void)\n"
-"{\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"}\n"
-"#endif\n"
-"#else // !MODE_DEPTH_ORSHADOW\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_SHOWDEPTH\n"
-"#ifdef VERTEX_SHADER\n"
-"void main(void)\n"
-"{\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"      VertexColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
-"}\n"
-"#endif\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"void main(void)\n"
-"{\n"
-"      gl_FragColor = VertexColor;\n"
-"}\n"
-"#endif\n"
-"#else // !MODE_SHOWDEPTH\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_POSTPROCESS\n"
-"varying mediump vec2 TexCoord1;\n"
-"varying mediump vec2 TexCoord2;\n"
-"\n"
-"#ifdef VERTEX_SHADER\n"
-"void main(void)\n"
-"{\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"      TexCoord1 = Attrib_TexCoord0.xy;\n"
-"#ifdef USEBLOOM\n"
-"      TexCoord2 = Attrib_TexCoord4.xy;\n"
-"#endif\n"
-"}\n"
-"#endif\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"uniform sampler2D Texture_First;\n"
-"#ifdef USEBLOOM\n"
-"uniform sampler2D Texture_Second;\n"
-"uniform lowp vec4 BloomColorSubtract;\n"
-"#endif\n"
-"#ifdef USEGAMMARAMPS\n"
-"uniform sampler2D Texture_GammaRamps;\n"
-"#endif\n"
-"#ifdef USESATURATION\n"
-"uniform lowp float Saturation;\n"
-"#endif\n"
-"#ifdef USEVIEWTINT\n"
-"uniform lowp vec4 ViewTintColor;\n"
-"#endif\n"
-"//uncomment these if you want to use them:\n"
-"uniform mediump vec4 UserVec1;\n"
-"uniform mediump vec4 UserVec2;\n"
-"// uniform mediump vec4 UserVec3;\n"
-"// uniform mediump vec4 UserVec4;\n"
-"// uniform highp float ClientTime;\n"
-"uniform mediump vec2 PixelSize;\n"
-"void main(void)\n"
-"{\n"
-"      gl_FragColor = texture2D(Texture_First, TexCoord1);\n"
-"#ifdef USEBLOOM\n"
-"      gl_FragColor += max(vec4(0,0,0,0), texture2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n"
-"#endif\n"
-"#ifdef USEVIEWTINT\n"
-"      gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
-"#endif\n"
-"\n"
-"#ifdef USEPOSTPROCESSING\n"
-"// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
-"// this code does a blur with the radius specified in the first component of r_glsl_postprocess_uservec1 and blends it using the second component\n"
-"      float sobel = 1.0;\n"
-"      // vec2 ts = textureSize(Texture_First, 0);\n"
-"      // vec2 px = vec2(1/ts.x, 1/ts.y);\n"
-"      vec2 px = PixelSize;\n"
-"      vec3 x1 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
-"      vec3 x2 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,  0.0)).rgb;\n"
-"      vec3 x3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
-"      vec3 x4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
-"      vec3 x5 = texture2D(Texture_First, TexCoord1 + vec2( px.x,  0.0)).rgb;\n"
-"      vec3 x6 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
-"      vec3 y1 = texture2D(Texture_First, TexCoord1 + vec2( px.x,-px.y)).rgb;\n"
-"      vec3 y2 = texture2D(Texture_First, TexCoord1 + vec2(  0.0,-px.y)).rgb;\n"
-"      vec3 y3 = texture2D(Texture_First, TexCoord1 + vec2(-px.x,-px.y)).rgb;\n"
-"      vec3 y4 = texture2D(Texture_First, TexCoord1 + vec2( px.x, px.y)).rgb;\n"
-"      vec3 y5 = texture2D(Texture_First, TexCoord1 + vec2(  0.0, px.y)).rgb;\n"
-"      vec3 y6 = texture2D(Texture_First, TexCoord1 + vec2(-px.x, px.y)).rgb;\n"
-"      float px1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x1);\n"
-"      float px2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), x2);\n"
-"      float px3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), x3);\n"
-"      float px4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x4);\n"
-"      float px5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), x5);\n"
-"      float px6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), x6);\n"
-"      float py1 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y1);\n"
-"      float py2 = -2.0 * dot(vec3(0.3, 0.59, 0.11), y2);\n"
-"      float py3 = -1.0 * dot(vec3(0.3, 0.59, 0.11), y3);\n"
-"      float py4 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y4);\n"
-"      float py5 =  2.0 * dot(vec3(0.3, 0.59, 0.11), y5);\n"
-"      float py6 =  1.0 * dot(vec3(0.3, 0.59, 0.11), y6);\n"
-"      sobel = 0.25 * abs(px1 + px2 + px3 + px4 + px5 + px6) + 0.25 * abs(py1 + py2 + py3 + py4 + py5 + py6);\n"
-"      gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.987688, -0.156434)) * UserVec1.y;\n"
-"      gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.156434, -0.891007)) * UserVec1.y;\n"
-"      gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.891007, -0.453990)) * UserVec1.y;\n"
-"      gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.707107,  0.707107)) * UserVec1.y;\n"
-"      gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.453990,  0.891007)) * UserVec1.y;\n"
-"      gl_FragColor /= (1.0 + 5.0 * UserVec1.y);\n"
-"      gl_FragColor.rgb = gl_FragColor.rgb * (1.0 + UserVec2.x) + vec3(max(0.0, sobel - UserVec2.z))*UserVec2.y;\n"
-"#endif\n"
-"\n"
-"#ifdef USESATURATION\n"
-"      //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
-"      float y = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
-"      // 'vampire sight' effect, wheres red is compensated\n"
-"      #ifdef SATURATION_REDCOMPENSATE\n"
-"              float rboost = max(0.0, (gl_FragColor.r - max(gl_FragColor.g, gl_FragColor.b))*(1.0 - Saturation));\n"
-"              gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
-"              gl_FragColor.r += rboost;\n"
-"      #else\n"
-"              // normal desaturation\n"
-"              //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n"
-"              gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
-"      #endif\n"
-"#endif\n"
-"\n"
-"#ifdef USEGAMMARAMPS\n"
-"      gl_FragColor.r = texture2D(Texture_GammaRamps, vec2(gl_FragColor.r, 0)).r;\n"
-"      gl_FragColor.g = texture2D(Texture_GammaRamps, vec2(gl_FragColor.g, 0)).g;\n"
-"      gl_FragColor.b = texture2D(Texture_GammaRamps, vec2(gl_FragColor.b, 0)).b;\n"
-"#endif\n"
-"}\n"
-"#endif\n"
-"#else // !MODE_POSTPROCESS\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_GENERIC\n"
-"#ifdef USEDIFFUSE\n"
-"varying mediump vec2 TexCoord1;\n"
-"#endif\n"
-"#ifdef USESPECULAR\n"
-"varying mediump vec2 TexCoord2;\n"
-"#endif\n"
-"#ifdef VERTEX_SHADER\n"
-"void main(void)\n"
-"{\n"
-"      VertexColor = Attrib_Color;\n"
-"#ifdef USEDIFFUSE\n"
-"      TexCoord1 = Attrib_TexCoord0.xy;\n"
-"#endif\n"
-"#ifdef USESPECULAR\n"
-"      TexCoord2 = Attrib_TexCoord1.xy;\n"
-"#endif\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"}\n"
-"#endif\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"#ifdef USEDIFFUSE\n"
-"uniform sampler2D Texture_First;\n"
-"#endif\n"
-"#ifdef USESPECULAR\n"
-"uniform sampler2D Texture_Second;\n"
-"#endif\n"
-"\n"
-"void main(void)\n"
-"{\n"
-"#ifdef USEVIEWTINT\n"
-"      gl_FragColor = VertexColor;\n"
-"#else\n"
-"      gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
-"#endif\n"
-"#ifdef USEDIFFUSE\n"
-"      gl_FragColor *= texture2D(Texture_First, TexCoord1);\n"
-"#endif\n"
-"\n"
-"#ifdef USESPECULAR\n"
-"      vec4 tex2 = texture2D(Texture_Second, TexCoord2);\n"
-"# ifdef USECOLORMAPPING\n"
-"      gl_FragColor *= tex2;\n"
-"# endif\n"
-"# ifdef USEGLOW\n"
-"      gl_FragColor += tex2;\n"
-"# endif\n"
-"# ifdef USEVERTEXTEXTUREBLEND\n"
-"      gl_FragColor = mix(gl_FragColor, tex2, tex2.a);\n"
-"# endif\n"
-"#endif\n"
-"}\n"
-"#endif\n"
-"#else // !MODE_GENERIC\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_BLOOMBLUR\n"
-"varying mediump vec2 TexCoord;\n"
-"#ifdef VERTEX_SHADER\n"
-"void main(void)\n"
-"{\n"
-"      VertexColor = Attrib_Color;\n"
-"      TexCoord = Attrib_TexCoord0.xy;\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"}\n"
-"#endif\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"uniform sampler2D Texture_First;\n"
-"uniform mediump vec4 BloomBlur_Parameters;\n"
-"\n"
-"void main(void)\n"
-"{\n"
-"      int i;\n"
-"      vec2 tc = TexCoord;\n"
-"      vec3 color = texture2D(Texture_First, tc).rgb;\n"
-"      tc += BloomBlur_Parameters.xy;\n"
-"      for (i = 1;i < SAMPLES;i++)\n"
-"      {\n"
-"              color += texture2D(Texture_First, tc).rgb;\n"
-"              tc += BloomBlur_Parameters.xy;\n"
-"      }\n"
-"      gl_FragColor = vec4(color * BloomBlur_Parameters.z + vec3(BloomBlur_Parameters.w), 1);\n"
-"}\n"
-"#endif\n"
-"#else // !MODE_BLOOMBLUR\n"
-"#ifdef MODE_REFRACTION\n"
-"varying mediump vec2 TexCoord;\n"
-"varying highp vec4 ModelViewProjectionPosition;\n"
-"uniform highp mat4 TexMatrix;\n"
-"#ifdef VERTEX_SHADER\n"
-"\n"
-"void main(void)\n"
-"{\n"
-"      TexCoord = vec2(TexMatrix * Attrib_TexCoord0);\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"      ModelViewProjectionPosition = gl_Position;\n"
-"}\n"
-"#endif\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"uniform sampler2D Texture_Normal;\n"
-"uniform sampler2D Texture_Refraction;\n"
-"uniform sampler2D Texture_Reflection;\n"
-"\n"
-"uniform mediump vec4 DistortScaleRefractReflect;\n"
-"uniform mediump vec4 ScreenScaleRefractReflect;\n"
-"uniform mediump vec4 ScreenCenterRefractReflect;\n"
-"uniform lowp vec4 RefractColor;\n"
-"uniform lowp vec4 ReflectColor;\n"
-"uniform mediump float ReflectFactor;\n"
-"uniform mediump float ReflectOffset;\n"
-"\n"
-"void main(void)\n"
-"{\n"
-"      vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
-"      //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
-"      vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
-"      vec2 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
-"      // FIXME temporary hack to detect the case that the reflection\n"
-"      // gets blackened at edges due to leaving the area that contains actual\n"
-"      // content.\n"
-"      // Remove this 'ack once we have a better way to stop this thing from\n"
-"      // 'appening.\n"
-"      float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
-"      ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
-"      gl_FragColor = vec4(texture2D(Texture_Refraction, ScreenTexCoord).rgb, 1.0) * RefractColor;\n"
-"}\n"
-"#endif\n"
-"#else // !MODE_REFRACTION\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_WATER\n"
-"varying mediump vec2 TexCoord;\n"
-"varying highp vec3 EyeVector;\n"
-"varying highp vec4 ModelViewProjectionPosition;\n"
-"#ifdef VERTEX_SHADER\n"
-"uniform highp vec3 EyePosition;\n"
-"uniform highp mat4 TexMatrix;\n"
-"\n"
-"void main(void)\n"
-"{\n"
-"      TexCoord = vec2(TexMatrix * Attrib_TexCoord0);\n"
-"      vec3 EyeVectorModelSpace = EyePosition - Attrib_Position.xyz;\n"
-"      EyeVector.x = dot(EyeVectorModelSpace, Attrib_TexCoord1.xyz);\n"
-"      EyeVector.y = dot(EyeVectorModelSpace, Attrib_TexCoord2.xyz);\n"
-"      EyeVector.z = dot(EyeVectorModelSpace, Attrib_TexCoord3.xyz);\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"      ModelViewProjectionPosition = gl_Position;\n"
-"}\n"
-"#endif\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"uniform sampler2D Texture_Normal;\n"
-"uniform sampler2D Texture_Refraction;\n"
-"uniform sampler2D Texture_Reflection;\n"
-"\n"
-"uniform mediump vec4 DistortScaleRefractReflect;\n"
-"uniform mediump vec4 ScreenScaleRefractReflect;\n"
-"uniform mediump vec4 ScreenCenterRefractReflect;\n"
-"uniform lowp vec4 RefractColor;\n"
-"uniform lowp vec4 ReflectColor;\n"
-"uniform mediump float ReflectFactor;\n"
-"uniform mediump float ReflectOffset;\n"
-"uniform highp float ClientTime;\n"
-"#ifdef USENORMALMAPSCROLLBLEND\n"
-"uniform highp vec2 NormalmapScrollBlend;\n"
-"#endif\n"
-"\n"
-"void main(void)\n"
-"{\n"
-"      vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
-"      //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
-"      vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
-"      //SafeScreenTexCoord = gl_FragCoord.xyxy * vec4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n"
-"      // slight water animation via 2 layer scrolling (todo: tweak)\n"
-"      #ifdef USENORMALMAPSCROLLBLEND\n"
-"              vec3 normal = texture2D(Texture_Normal, (TexCoord + vec2(0.08, 0.08)*ClientTime*NormalmapScrollBlend.x*0.5)*NormalmapScrollBlend.y).rgb - vec3(1.0);\n"
-"              normal += texture2D(Texture_Normal, (TexCoord + vec2(-0.06, -0.09)*ClientTime*NormalmapScrollBlend.x)*NormalmapScrollBlend.y*0.75).rgb;\n"
-"              vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(normal) + vec3(0.15)).xyxy * DistortScaleRefractReflect;\n"
-"      #else\n"
-"              vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
-"      #endif\n"
-"      // FIXME temporary hack to detect the case that the reflection\n"
-"      // gets blackened at edges due to leaving the area that contains actual\n"
-"      // content.\n"
-"      // Remove this 'ack once we have a better way to stop this thing from\n"
-"      // 'appening.\n"
-"      float f  = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.005, 0.01)).rgb) / 0.002);\n"
-"      f       *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.005, -0.01)).rgb) / 0.002);\n"
-"      f       *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.005, 0.01)).rgb) / 0.002);\n"
-"      f       *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.005, -0.01)).rgb) / 0.002);\n"
-"      ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
-"      f  = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.005, 0.005)).rgb) / 0.002);\n"
-"      f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.005, -0.005)).rgb) / 0.002);\n"
-"      f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.005, 0.005)).rgb) / 0.002);\n"
-"      f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.005, -0.005)).rgb) / 0.002);\n"
-"      ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
-"      float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
-"      gl_FragColor = mix(vec4(texture2D(Texture_Refraction, ScreenTexCoord.xy).rgb, 1) * RefractColor, vec4(texture2D(Texture_Reflection, ScreenTexCoord.zw).rgb, 1) * ReflectColor, Fresnel);\n"
-"}\n"
-"#endif\n"
-"#else // !MODE_WATER\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"// common definitions between vertex shader and fragment shader:\n"
-"\n"
-"varying mediump vec2 TexCoord;\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"varying mediump vec2 TexCoord2;\n"
-"#endif\n"
-"#ifdef USELIGHTMAP\n"
-"varying mediump vec2 TexCoordLightmap;\n"
-"#endif\n"
-"\n"
-"#ifdef MODE_LIGHTSOURCE\n"
-"varying mediump vec3 CubeVector;\n"
-"#endif\n"
-"\n"
-"#if (defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)) && defined(USEDIFFUSE)\n"
-"varying mediump vec3 LightVector;\n"
-"#endif\n"
-"\n"
-"#ifdef USEEYEVECTOR\n"
-"varying highp vec3 EyeVector;\n"
-"#endif\n"
-"#ifdef USEFOG\n"
-"varying highp vec4 EyeVectorModelSpaceFogPlaneVertexDist;\n"
-"#endif\n"
-"\n"
-"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n"
-"varying lowp vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
-"varying lowp vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
-"varying lowp vec3 VectorR; // direction of R texcoord (surface normal)\n"
-"#endif\n"
-"\n"
-"#ifdef USEREFLECTION\n"
-"varying highp vec4 ModelViewProjectionPosition;\n"
-"#endif\n"
-"#ifdef MODE_DEFERREDLIGHTSOURCE\n"
-"uniform highp vec3 LightPosition;\n"
-"varying highp vec4 ModelViewPosition;\n"
-"#endif\n"
-"\n"
-"#ifdef MODE_LIGHTSOURCE\n"
-"uniform highp vec3 LightPosition;\n"
-"#endif\n"
-"uniform highp vec3 EyePosition;\n"
-"#ifdef MODE_LIGHTDIRECTION\n"
-"uniform highp vec3 LightDir;\n"
-"#endif\n"
-"uniform highp vec4 FogPlane;\n"
-"\n"
-"#ifdef USESHADOWMAPORTHO\n"
-"varying mediump vec3 ShadowMapTC;\n"
-"#endif\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3), this would require sending a 4 component texcoord1 with W as 1 or -1 according to which side the texcoord2 should be on\n"
-"\n"
-"// fragment shader specific:\n"
-"#ifdef FRAGMENT_SHADER\n"
-"\n"
-"uniform sampler2D Texture_Normal;\n"
-"uniform sampler2D Texture_Color;\n"
-"uniform sampler2D Texture_Gloss;\n"
-"#ifdef USEGLOW\n"
-"uniform sampler2D Texture_Glow;\n"
-"#endif\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"uniform sampler2D Texture_SecondaryNormal;\n"
-"uniform sampler2D Texture_SecondaryColor;\n"
-"uniform sampler2D Texture_SecondaryGloss;\n"
-"#ifdef USEGLOW\n"
-"uniform sampler2D Texture_SecondaryGlow;\n"
-"#endif\n"
-"#endif\n"
-"#ifdef USECOLORMAPPING\n"
-"uniform sampler2D Texture_Pants;\n"
-"uniform sampler2D Texture_Shirt;\n"
-"#endif\n"
-"#ifdef USEFOG\n"
-"#ifdef USEFOGHEIGHTTEXTURE\n"
-"uniform sampler2D Texture_FogHeightTexture;\n"
-"#endif\n"
-"uniform sampler2D Texture_FogMask;\n"
-"#endif\n"
-"#ifdef USELIGHTMAP\n"
-"uniform sampler2D Texture_Lightmap;\n"
-"#endif\n"
-"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
-"uniform sampler2D Texture_Deluxemap;\n"
-"#endif\n"
-"#ifdef USEREFLECTION\n"
-"uniform sampler2D Texture_Reflection;\n"
-"#endif\n"
-"\n"
-"#ifdef MODE_DEFERREDLIGHTSOURCE\n"
-"uniform sampler2D Texture_ScreenDepth;\n"
-"uniform sampler2D Texture_ScreenNormalMap;\n"
-"#endif\n"
-"#ifdef USEDEFERREDLIGHTMAP\n"
-"uniform sampler2D Texture_ScreenDiffuse;\n"
-"uniform sampler2D Texture_ScreenSpecular;\n"
-"#endif\n"
-"\n"
-"uniform lowp vec3 Color_Pants;\n"
-"uniform lowp vec3 Color_Shirt;\n"
-"uniform lowp vec3 FogColor;\n"
-"\n"
-"#ifdef USEFOG\n"
-"uniform highp float FogRangeRecip;\n"
-"uniform highp float FogPlaneViewDist;\n"
-"uniform highp float FogHeightFade;\n"
-"vec3 FogVertex(vec3 surfacecolor)\n"
-"{\n"
-"      vec3 EyeVectorModelSpace = EyeVectorModelSpaceFogPlaneVertexDist.xyz;\n"
-"      float FogPlaneVertexDist = EyeVectorModelSpaceFogPlaneVertexDist.w;\n"
-"      float fogfrac;\n"
-"#ifdef USEFOGHEIGHTTEXTURE\n"
-"      vec4 fogheightpixel = texture2D(Texture_FogHeightTexture, vec2(1,1) + vec2(FogPlaneVertexDist, FogPlaneViewDist) * (-2.0 * FogHeightFade));\n"
-"      fogfrac = fogheightpixel.a;\n"
-"      return mix(fogheightpixel.rgb * FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
-"#else\n"
-"# ifdef USEFOGOUTSIDE\n"
-"      fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
-"# else\n"
-"      fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
-"# endif\n"
-"      return mix(FogColor, surfacecolor, texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)).r);\n"
-"#endif\n"
-"}\n"
-"#endif\n"
-"\n"
-"#ifdef USEOFFSETMAPPING\n"
-"uniform mediump float OffsetMapping_Scale;\n"
-"vec2 OffsetMapping(vec2 TexCoord)\n"
-"{\n"
-"#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
-"      // 14 sample relief mapping: linear search and then binary search\n"
-"      // this basically steps forward a small amount repeatedly until it finds\n"
-"      // itself inside solid, then jitters forward and back using decreasing\n"
-"      // amounts to find the impact\n"
-"      //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
-"      //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
-"      vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
-"      vec3 RT = vec3(TexCoord, 1);\n"
-"      OffsetVector *= 0.1;\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector *  step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
-"      RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z)          - 0.5);\n"
-"      RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5    - 0.25);\n"
-"      RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25   - 0.125);\n"
-"      RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125  - 0.0625);\n"
-"      RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
-"      return RT.xy;\n"
-"#else\n"
-"      // 2 sample offset mapping (only 2 samples because of ATI Radeon 9500-9800/X300 limits)\n"
-"      // this basically moves forward the full distance, and then backs up based\n"
-"      // on height of samples\n"
-"      //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
-"      //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
-"      vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
-"      TexCoord += OffsetVector;\n"
-"      OffsetVector *= 0.5;\n"
-"      TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
-"      TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
-"      return TexCoord;\n"
-"#endif\n"
-"}\n"
-"#endif // USEOFFSETMAPPING\n"
-"\n"
-"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
-"uniform sampler2D Texture_Attenuation;\n"
-"uniform samplerCube Texture_Cube;\n"
-"#endif\n"
-"\n"
-"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
-"\n"
-"#ifdef USESHADOWMAP2D\n"
-"# ifdef USESHADOWSAMPLER\n"
-"uniform sampler2DShadow Texture_ShadowMap2D;\n"
-"# else\n"
-"uniform sampler2D Texture_ShadowMap2D;\n"
-"# endif\n"
-"#endif\n"
-"\n"
-"#ifdef USESHADOWMAPVSDCT\n"
-"uniform samplerCube Texture_CubeProjection;\n"
-"#endif\n"
-"\n"
-"#if defined(USESHADOWMAP2D)\n"
-"uniform mediump vec2 ShadowMap_TextureScale;\n"
-"uniform mediump vec4 ShadowMap_Parameters;\n"
-"#endif\n"
-"\n"
-"#if defined(USESHADOWMAP2D)\n"
-"# ifdef USESHADOWMAPORTHO\n"
-"#  define GetShadowMapTC2D(dir) (min(dir, ShadowMap_Parameters.xyz))\n"
-"# else\n"
-"#  ifdef USESHADOWMAPVSDCT\n"
-"vec3 GetShadowMapTC2D(vec3 dir)\n"
-"{\n"
-"      vec3 adir = abs(dir);\n"
-"      vec2 aparams = ShadowMap_Parameters.xy / max(max(adir.x, adir.y), adir.z);\n"
-"      vec4 proj = textureCube(Texture_CubeProjection, dir);\n"
-"      return vec3(mix(dir.xy, dir.zz, proj.xy) * aparams.x + proj.zw * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
-"}\n"
-"#  else\n"
-"vec3 GetShadowMapTC2D(vec3 dir)\n"
-"{\n"
-"      vec3 adir = abs(dir);\n"
-"      float ma = adir.z;\n"
-"      vec4 proj = vec4(dir, 2.5);\n"
-"      if (adir.x > ma) { ma = adir.x; proj = vec4(dir.zyx, 0.5); }\n"
-"      if (adir.y > ma) { ma = adir.y; proj = vec4(dir.xzy, 1.5); }\n"
-"      vec2 aparams = ShadowMap_Parameters.xy / ma;\n"
-"      return vec3(proj.xy * aparams.x + vec2(proj.z < 0.0 ? 1.5 : 0.5, proj.w) * ShadowMap_Parameters.z, aparams.y + ShadowMap_Parameters.w);\n"
-"}\n"
-"#  endif\n"
-"# endif\n"
-"#endif // defined(USESHADOWMAP2D)\n"
-"\n"
-"# ifdef USESHADOWMAP2D\n"
-"float ShadowMapCompare(vec3 dir)\n"
-"{\n"
-"      vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
-"      float f;\n"
-"\n"
-"#  ifdef USESHADOWSAMPLER\n"
-"#    ifdef USESHADOWMAPPCF\n"
-"#      define texval(x, y) shadow2D(Texture_ShadowMap2D, vec3(center + vec2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r  \n"
-"      vec2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
-"      f = dot(vec4(0.25), vec4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
-"#    else\n"
-"      f = shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
-"#    endif\n"
-"#  else\n"
-"#    ifdef USESHADOWMAPPCF\n"
-"#     if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
-"#      ifdef GL_ARB_texture_gather\n"
-"#        define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec2(x, y))\n"
-"#      else\n"
-"#        define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale)\n"
-"#      endif\n"
-"      vec2 offset = fract(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n"
-"#      if USESHADOWMAPPCF > 1\n"
-"   vec4 group1 = step(shadowmaptc.z, texval(-2.0, -2.0));\n"
-"   vec4 group2 = step(shadowmaptc.z, texval( 0.0, -2.0));\n"
-"   vec4 group3 = step(shadowmaptc.z, texval( 2.0, -2.0));\n"
-"   vec4 group4 = step(shadowmaptc.z, texval(-2.0,  0.0));\n"
-"   vec4 group5 = step(shadowmaptc.z, texval( 0.0,  0.0));\n"
-"   vec4 group6 = step(shadowmaptc.z, texval( 2.0,  0.0));\n"
-"   vec4 group7 = step(shadowmaptc.z, texval(-2.0,  2.0));\n"
-"   vec4 group8 = step(shadowmaptc.z, texval( 0.0,  2.0));\n"
-"   vec4 group9 = step(shadowmaptc.z, texval( 2.0,  2.0));\n"
-"      vec4 locols = vec4(group1.ab, group3.ab);\n"
-"      vec4 hicols = vec4(group7.rg, group9.rg);\n"
-"      locols.yz += group2.ab;\n"
-"      hicols.yz += group8.rg;\n"
-"      vec4 midcols = vec4(group1.rg, group3.rg) + vec4(group7.ab, group9.ab) +\n"
-"                              vec4(group4.rg, group6.rg) + vec4(group4.ab, group6.ab) +\n"
-"                              mix(locols, hicols, offset.y);\n"
-"      vec4 cols = group5 + vec4(group2.rg, group8.ab);\n"
-"      cols.xyz += mix(midcols.xyz, midcols.yzw, offset.x);\n"
-"      f = dot(cols, vec4(1.0/25.0));\n"
-"#      else\n"
-"      vec4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
-"      vec4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
-"      vec4 group3 = step(shadowmaptc.z, texval(-1.0,  1.0));\n"
-"      vec4 group4 = step(shadowmaptc.z, texval( 1.0,  1.0));\n"
-"      vec4 cols = vec4(group1.rg, group2.rg) + vec4(group3.ab, group4.ab) +\n"
-"                              mix(vec4(group1.ab, group2.ab), vec4(group3.rg, group4.rg), offset.y);\n"
-"      f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
-"#      endif\n"
-"#     else\n"
-"#      ifdef GL_EXT_gpu_shader4\n"
-"#        define texval(x, y) texture2DOffset(Texture_ShadowMap2D, center, ivec2(x, y)).r\n"
-"#      else\n"
-"#        define texval(x, y) texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale).r  \n"
-"#      endif\n"
-"#      if USESHADOWMAPPCF > 1\n"
-"      vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
-"      center *= ShadowMap_TextureScale;\n"
-"      vec4 row1 = step(shadowmaptc.z, vec4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
-"      vec4 row2 = step(shadowmaptc.z, vec4(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0), texval( 2.0,  0.0)));\n"
-"      vec4 row3 = step(shadowmaptc.z, vec4(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0), texval( 2.0,  1.0)));\n"
-"      vec4 row4 = step(shadowmaptc.z, vec4(texval(-1.0,  2.0), texval( 0.0,  2.0), texval( 1.0,  2.0), texval( 2.0,  2.0)));\n"
-"      vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
-"      f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
-"#      else\n"
-"      vec2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = fract(shadowmaptc.xy);\n"
-"      vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
-"      vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0,  0.0), texval( 0.0,  0.0), texval( 1.0,  0.0)));\n"
-"      vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0,  1.0), texval( 0.0,  1.0), texval( 1.0,  1.0)));\n"
-"      vec3 cols = row2 + mix(row1, row3, offset.y);\n"
-"      f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
-"#      endif\n"
-"#     endif\n"
-"#    else\n"
-"      f = step(shadowmaptc.z, texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
-"#    endif\n"
-"#  endif\n"
-"#  ifdef USESHADOWMAPORTHO\n"
-"      return mix(ShadowMap_Parameters.w, 1.0, f);\n"
-"#  else\n"
-"      return f;\n"
-"#  endif\n"
-"}\n"
-"# endif\n"
-"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
-"#endif // FRAGMENT_SHADER\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_DEFERREDGEOMETRY\n"
-"#ifdef VERTEX_SHADER\n"
-"uniform highp mat4 TexMatrix;\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"uniform highp mat4 BackgroundTexMatrix;\n"
-"#endif\n"
-"uniform highp mat4 ModelViewMatrix;\n"
-"void main(void)\n"
-"{\n"
-"      TexCoord = vec2(TexMatrix * Attrib_TexCoord0);\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"      VertexColor = Attrib_Color;\n"
-"      TexCoord2 = vec2(BackgroundTexMatrix * Attrib_TexCoord0);\n"
-"#endif\n"
-"\n"
-"      // transform unnormalized eye direction into tangent space\n"
-"#ifdef USEOFFSETMAPPING\n"
-"      vec3 EyeVectorModelSpace = EyePosition - Attrib_Position.xyz;\n"
-"      EyeVector.x = dot(EyeVectorModelSpace, Attrib_TexCoord1.xyz);\n"
-"      EyeVector.y = dot(EyeVectorModelSpace, Attrib_TexCoord2.xyz);\n"
-"      EyeVector.z = dot(EyeVectorModelSpace, Attrib_TexCoord3.xyz);\n"
-"#endif\n"
-"\n"
-"      VectorS = (ModelViewMatrix * vec4(Attrib_TexCoord1.xyz, 0)).xyz;\n"
-"      VectorT = (ModelViewMatrix * vec4(Attrib_TexCoord2.xyz, 0)).xyz;\n"
-"      VectorR = (ModelViewMatrix * vec4(Attrib_TexCoord3.xyz, 0)).xyz;\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"}\n"
-"#endif // VERTEX_SHADER\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"void main(void)\n"
-"{\n"
-"#ifdef USEOFFSETMAPPING\n"
-"      // apply offsetmapping\n"
-"      vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
-"#define TexCoord TexCoordOffset\n"
-"#endif\n"
-"\n"
-"#ifdef USEALPHAKILL\n"
-"      if (texture2D(Texture_Color, TexCoord).a < 0.5)\n"
-"              discard;\n"
-"#endif\n"
-"\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"      float alpha = texture2D(Texture_Color, TexCoord).a;\n"
-"      float terrainblend = clamp(float(VertexColor.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
-"      //float terrainblend = min(float(VertexColor.a) * alpha * 2.0, float(1.0));\n"
-"      //float terrainblend = float(VertexColor.a) * alpha > 0.5;\n"
-"#endif\n"
-"\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"      vec3 surfacenormal = mix(vec3(texture2D(Texture_SecondaryNormal, TexCoord2)), vec3(texture2D(Texture_Normal, TexCoord)), terrainblend) - vec3(0.5, 0.5, 0.5);\n"
-"      float a = mix(texture2D(Texture_SecondaryGloss, TexCoord2).a, texture2D(Texture_Gloss, TexCoord).a, terrainblend);\n"
-"#else\n"
-"      vec3 surfacenormal = vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5, 0.5, 0.5);\n"
-"      float a = texture2D(Texture_Gloss, TexCoord).a;\n"
-"#endif\n"
-"\n"
-"      gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), a);\n"
-"}\n"
-"#endif // FRAGMENT_SHADER\n"
-"#else // !MODE_DEFERREDGEOMETRY\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef MODE_DEFERREDLIGHTSOURCE\n"
-"#ifdef VERTEX_SHADER\n"
-"uniform highp mat4 ModelViewMatrix;\n"
-"void main(void)\n"
-"{\n"
-"      ModelViewPosition = ModelViewMatrix * Attrib_Position;\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"}\n"
-"#endif // VERTEX_SHADER\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"uniform highp mat4 ViewToLight;\n"
-"// ScreenToDepth = vec2(Far / (Far - Near), Far * Near / (Near - Far));\n"
-"uniform highp vec2 ScreenToDepth;\n"
-"uniform myhalf3 DeferredColor_Ambient;\n"
-"uniform myhalf3 DeferredColor_Diffuse;\n"
-"#ifdef USESPECULAR\n"
-"uniform myhalf3 DeferredColor_Specular;\n"
-"uniform myhalf SpecularPower;\n"
-"#endif\n"
-"uniform myhalf2 PixelToScreenTexCoord;\n"
-"void main(void)\n"
-"{\n"
-"      // calculate viewspace pixel position\n"
-"      vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
-"      vec3 position;\n"
-"      position.z = ScreenToDepth.y / (texture2D(Texture_ScreenDepth, ScreenTexCoord).r + ScreenToDepth.x);\n"
-"      position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
-"      // decode viewspace pixel normal\n"
-"      myhalf4 normalmap = texture2D(Texture_ScreenNormalMap, ScreenTexCoord);\n"
-"      myhalf3 surfacenormal = normalize(normalmap.rgb - myhalf3(0.5,0.5,0.5));\n"
-"      // surfacenormal = pixel normal in viewspace\n"
-"      // LightVector = pixel to light in viewspace\n"
-"      // CubeVector = position in lightspace\n"
-"      // eyevector = pixel to view in viewspace\n"
-"      vec3 CubeVector = vec3(ViewToLight * vec4(position,1));\n"
-"      myhalf fade = myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
-"#ifdef USEDIFFUSE\n"
-"      // calculate diffuse shading\n"
-"      myhalf3 lightnormal = myhalf3(normalize(LightPosition - position));\n"
-"      myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
-"#endif\n"
-"#ifdef USESPECULAR\n"
-"      // calculate directional shading\n"
-"      vec3 eyevector = position * -1.0;\n"
-"#  ifdef USEEXACTSPECULARMATH\n"
-"      myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n"
-"#  else\n"
-"      myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(eyevector)));\n"
-"      myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n"
-"#  endif\n"
-"#endif\n"
-"\n"
-"#if defined(USESHADOWMAP2D)\n"
-"      fade *= ShadowMapCompare(CubeVector);\n"
-"#endif\n"
-"\n"
-"#ifdef USEDIFFUSE\n"
-"      gl_FragData[0] = vec4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
-"#else\n"
-"      gl_FragData[0] = vec4(DeferredColor_Ambient * fade, 1.0);\n"
-"#endif\n"
-"#ifdef USESPECULAR\n"
-"      gl_FragData[1] = vec4(DeferredColor_Specular * (specular * fade), 1.0);\n"
-"#else\n"
-"      gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);\n"
-"#endif\n"
-"\n"
-"# ifdef USECUBEFILTER\n"
-"      vec3 cubecolor = textureCube(Texture_Cube, CubeVector).rgb;\n"
-"      gl_FragData[0].rgb *= cubecolor;\n"
-"      gl_FragData[1].rgb *= cubecolor;\n"
-"# endif\n"
-"}\n"
-"#endif // FRAGMENT_SHADER\n"
-"#else // !MODE_DEFERREDLIGHTSOURCE\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef VERTEX_SHADER\n"
-"uniform highp mat4 TexMatrix;\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"uniform highp mat4 BackgroundTexMatrix;\n"
-"#endif\n"
-"#ifdef MODE_LIGHTSOURCE\n"
-"uniform highp mat4 ModelToLight;\n"
-"#endif\n"
-"#ifdef USESHADOWMAPORTHO\n"
-"uniform highp mat4 ShadowMapMatrix;\n"
-"#endif\n"
-"void main(void)\n"
-"{\n"
-"#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
-"      VertexColor = Attrib_Color;\n"
-"#endif\n"
-"      // copy the surface texcoord\n"
-"      TexCoord = vec2(TexMatrix * Attrib_TexCoord0);\n"
-"#ifdef USEVERTEXTEXTUREBLEND\n"
-"      TexCoord2 = vec2(BackgroundTexMatrix * Attrib_TexCoord0);\n"
-"#endif\n"
-"#ifdef USELIGHTMAP\n"
-"      TexCoordLightmap = vec2(Attrib_TexCoord4);\n"
-"#endif\n"
-"\n"
-"#ifdef MODE_LIGHTSOURCE\n"
-"      // transform vertex position into light attenuation/cubemap space\n"
-"      // (-1 to +1 across the light box)\n"
-"      CubeVector = vec3(ModelToLight * Attrib_Position);\n"
-"\n"
-"# ifdef USEDIFFUSE\n"
-"      // transform unnormalized light direction into tangent space\n"
-"      // (we use unnormalized to ensure that it interpolates correctly and then\n"
-"      //  normalize it per pixel)\n"
-"      vec3 lightminusvertex = LightPosition - Attrib_Position.xyz;\n"
-"      LightVector.x = dot(lightminusvertex, Attrib_TexCoord1.xyz);\n"
-"      LightVector.y = dot(lightminusvertex, Attrib_TexCoord2.xyz);\n"
-"      LightVector.z = dot(lightminusvertex, Attrib_TexCoord3.xyz);\n"
-"# endif\n"
-"#endif\n"
-"\n"
-"#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
-"      LightVector.x = dot(LightDir, Attrib_TexCoord1.xyz);\n"
-"      LightVector.y = dot(LightDir, Attrib_TexCoord2.xyz);\n"
-"      LightVector.z = dot(LightDir, Attrib_TexCoord3.xyz);\n"
-"#endif\n"
-"\n"
-"      // transform unnormalized eye direction into tangent space\n"
-"#ifdef USEEYEVECTOR\n"
-"      vec3 EyeVectorModelSpace = EyePosition - Attrib_Position.xyz;\n"
-"      EyeVector.x = dot(EyeVectorModelSpace, Attrib_TexCoord1.xyz);\n"
-"      EyeVector.y = dot(EyeVectorModelSpace, Attrib_TexCoord2.xyz);\n"
-"      EyeVector.z = dot(EyeVectorModelSpace, Attrib_TexCoord3.xyz);\n"
-"#endif\n"
-"\n"
-"#ifdef USEFOG\n"
-"      EyeVectorModelSpaceFogPlaneVertexDist.xyz = EyePosition - Attrib_Position.xyz;\n"
-"      EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, Attrib_Position);\n"
-"#endif\n"
-"\n"
-"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE)\n"
-"      VectorS = Attrib_TexCoord1.xyz;\n"
-"      VectorT = Attrib_TexCoord2.xyz;\n"
-"      VectorR = Attrib_TexCoord3.xyz;\n"
-"#endif\n"
-"\n"
-"      // transform vertex to camera space, using ftransform to match non-VS rendering\n"
-"      gl_Position = ModelViewProjectionMatrix * Attrib_Position;\n"
-"\n"
-"#ifdef USESHADOWMAPORTHO\n"
-"      ShadowMapTC = vec3(ShadowMapMatrix * gl_Position);\n"
-"#endif\n"
-"\n"
-"#ifdef USEREFLECTION\n"
-"      ModelViewProjectionPosition = gl_Position;\n"
-"#endif\n"
-"}\n"
-"#endif // VERTEX_SHADER\n"
-"\n"
-"\n"
-"\n"
-"\n"
-"#ifdef FRAGMENT_SHADER\n"
-"#ifdef USEDEFERREDLIGHTMAP\n"
-"uniform myhalf2 PixelToScreenTexCoord;\n"
-"uniform myhalf3 DeferredMod_Diffuse;\n"
-"uniform myhalf3 DeferredMod_Specular;\n"
-"#endif\n"
-"uniform myhalf3 Color_Ambient;\n"
-"uniform myhalf3 Color_Diffuse;\n"
-"uniform myhalf3 Color_Specular;\n"
-"uniform myhalf SpecularPower;\n"
+"uniform half SpecularPower : register(c36),\n"
 "#ifdef USEGLOW\n"
-"uniform myhalf3 Color_Glow;\n"
+"uniform half3 Color_Glow : register(c6),\n"
 "#endif\n"
-"uniform myhalf Alpha;\n"
+"uniform half Alpha : register(c0),\n"
 "#ifdef USEREFLECTION\n"
-"uniform mediump vec4 DistortScaleRefractReflect;\n"
-"uniform mediump vec4 ScreenScaleRefractReflect;\n"
-"uniform mediump vec4 ScreenCenterRefractReflect;\n"
-"uniform lowp vec4 ReflectColor;\n"
+"uniform float4 DistortScaleRefractReflect : register(c14),\n"
+"uniform float4 ScreenScaleRefractReflect : register(c32),\n"
+"uniform float4 ScreenCenterRefractReflect : register(c31),\n"
+"uniform half4 ReflectColor : register(c26),\n"
 "#endif\n"
 "#ifdef USEREFLECTCUBE\n"
-"uniform highp mat4 ModelToReflectCube;\n"
-"uniform sampler2D Texture_ReflectMask;\n"
-"uniform samplerCube Texture_ReflectCube;\n"
+"uniform float4x4 ModelToReflectCube : register(c48),\n"
+"uniform sampler Texture_ReflectMask : register(s5),\n"
+"uniform samplerCUBE Texture_ReflectCube : register(s6),\n"
 "#endif\n"
 "#ifdef MODE_LIGHTDIRECTION\n"
-"uniform myhalf3 LightColor;\n"
+"uniform half3 LightColor : register(c21),\n"
 "#endif\n"
 "#ifdef MODE_LIGHTSOURCE\n"
-"uniform myhalf3 LightColor;\n"
+"uniform half3 LightColor : register(c21),\n"
 "#endif\n"
-"void main(void)\n"
+"\n"
+"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
+"uniform sampler Texture_Attenuation : register(s9),\n"
+"uniform samplerCUBE Texture_Cube : register(s10),\n"
+"#endif\n"
+"\n"
+"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n"
+"\n"
+"#ifdef USESHADOWMAP2D\n"
+"# ifdef USESHADOWSAMPLER\n"
+"uniform sampler Texture_ShadowMap2D : register(s15),\n"
+"# else\n"
+"uniform sampler Texture_ShadowMap2D : register(s15),\n"
+"# endif\n"
+"#endif\n"
+"\n"
+"#ifdef USESHADOWMAPVSDCT\n"
+"uniform samplerCUBE Texture_CubeProjection : register(s12),\n"
+"#endif\n"
+"\n"
+"#if defined(USESHADOWMAP2D)\n"
+"uniform float2 ShadowMap_TextureScale : register(c35),\n"
+"uniform float4 ShadowMap_Parameters : register(c34),\n"
+"#endif\n"
+"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n"
+"\n"
+"out float4 gl_FragColor : COLOR\n"
+")\n"
 "{\n"
+"      float2 TexCoord = TexCoordBoth.xy;\n"
+"#ifdef USEVERTEXTEXTUREBLEND\n"
+"      float2 TexCoord2 = TexCoordBoth.zw;\n"
+"#endif\n"
 "#ifdef USEOFFSETMAPPING\n"
 "      // apply offsetmapping\n"
-"      vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
+"      float2 TexCoordOffset = OffsetMapping(TexCoord, OffsetMapping_Scale, EyeVector, Texture_Normal);\n"
 "#define TexCoord TexCoordOffset\n"
 "#endif\n"
 "\n"
 "      // combine the diffuse textures (base, pants, shirt)\n"
-"      myhalf4 color = myhalf4(texture2D(Texture_Color, TexCoord));\n"
+"      half4 color = half4(tex2D(Texture_Color, TexCoord));\n"
 "#ifdef USEALPHAKILL\n"
 "      if (color.a < 0.5)\n"
 "              discard;\n"
 "#endif\n"
 "      color.a *= Alpha;\n"
 "#ifdef USECOLORMAPPING\n"
-"      color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
+"      color.rgb += half3(tex2D(Texture_Pants, TexCoord).rgb) * Color_Pants + half3(tex2D(Texture_Shirt, TexCoord).rgb) * Color_Shirt;\n"
 "#endif\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"      myhalf terrainblend = clamp(myhalf(VertexColor.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
-"      //myhalf terrainblend = min(myhalf(VertexColor.a) * color.a * 2.0, myhalf(1.0));\n"
-"      //myhalf terrainblend = myhalf(VertexColor.a) * color.a > 0.5;\n"
-"      color.rgb = mix(myhalf3(texture2D(Texture_SecondaryColor, TexCoord2)), color.rgb, terrainblend);\n"
+"      half terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n"
+"      //half terrainblend = min(half(gl_FrontColor.a) * color.a * 2.0, half(1.0));\n"
+"      //half terrainblend = half(gl_FrontColor.a) * color.a > 0.5;\n"
+"      color.rgb = half3(lerp(tex2D(Texture_SecondaryColor, TexCoord2).rgb, float3(color.rgb), terrainblend));\n"
 "      color.a = 1.0;\n"
-"      //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
+"      //color = half4(lerp(float4(1, 0, 0, 1), color, terrainblend));\n"
 "#endif\n"
 "\n"
 "      // get the surface normal\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"      myhalf3 surfacenormal = normalize(mix(myhalf3(texture2D(Texture_SecondaryNormal, TexCoord2)), myhalf3(texture2D(Texture_Normal, TexCoord)), terrainblend) - myhalf3(0.5, 0.5, 0.5));\n"
+"      half3 surfacenormal = normalize(half3(lerp(tex2D(Texture_SecondaryNormal, TexCoord2).rgb, tex2D(Texture_Normal, TexCoord).rgb, terrainblend)) - half3(0.5, 0.5, 0.5));\n"
 "#else\n"
-"      myhalf3 surfacenormal = normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5, 0.5, 0.5));\n"
+"      half3 surfacenormal = half3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5, 0.5, 0.5)));\n"
 "#endif\n"
 "\n"
 "      // get the material colors\n"
-"      myhalf3 diffusetex = color.rgb;\n"
+"      half3 diffusetex = color.rgb;\n"
 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
 "# ifdef USEVERTEXTEXTUREBLEND\n"
-"      myhalf4 glosstex = mix(myhalf4(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf4(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n"
+"      half4 glosstex = half4(lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord), terrainblend));\n"
 "# else\n"
-"      myhalf4 glosstex = myhalf4(texture2D(Texture_Gloss, TexCoord));\n"
+"      half4 glosstex = half4(tex2D(Texture_Gloss, TexCoord));\n"
 "# endif\n"
 "#endif\n"
 "\n"
 "#ifdef USEREFLECTCUBE\n"
-"      vec3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
-"      vec3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
-"      vec3 ReflectCubeTexCoord = vec3(ModelToReflectCube * vec4(ModelReflectVector, 0));\n"
-"      diffusetex += myhalf3(texture2D(Texture_ReflectMask, TexCoord)) * myhalf3(textureCube(Texture_ReflectCube, ReflectCubeTexCoord));\n"
+"      float3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n"
+"      float3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n"
+"      float3 ReflectCubeTexCoord = mul(ModelToReflectCube, float4(ModelReflectVector, 0)).xyz;\n"
+"      diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord).rgb) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord).rgb);\n"
 "#endif\n"
 "\n"
 "\n"
@@ -4407,15 +3145,15 @@ const char *builtingles2shaderstring =
 "#ifdef MODE_LIGHTSOURCE\n"
 "      // light source\n"
 "#ifdef USEDIFFUSE\n"
-"      myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
-"      myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
+"      half3 lightnormal = half3(normalize(LightVector));\n"
+"      half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
 "      color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
 "#ifdef USESPECULAR\n"
 "#ifdef USEEXACTSPECULARMATH\n"
-"      myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
+"      half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n"
 "#else\n"
-"      myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
-"      myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
+"      half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n"
+"      half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n"
 "#endif\n"
 "      color.rgb += glosstex.rgb * (specular * Color_Specular);\n"
 "#endif\n"
@@ -4423,13 +3161,41 @@ const char *builtingles2shaderstring =
 "      color.rgb = diffusetex * Color_Ambient;\n"
 "#endif\n"
 "      color.rgb *= LightColor;\n"
-"      color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
+"      color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)).r);\n"
 "#if defined(USESHADOWMAP2D)\n"
-"      color.rgb *= ShadowMapCompare(CubeVector);\n"
+"      color.rgb *= half(ShadowMapCompare(CubeVector, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n"
+"#ifdef USESHADOWMAPVSDCT\n"
+", Texture_CubeProjection\n"
+"#endif\n"
+"      ));\n"
+"\n"
 "#endif\n"
 "# ifdef USECUBEFILTER\n"
-"      color.rgb *= myhalf3(textureCube(Texture_Cube, CubeVector));\n"
+"      color.rgb *= half3(texCUBE(Texture_Cube, CubeVector).rgb);\n"
 "# endif\n"
+"\n"
+"#ifdef USESHADOWMAP2D\n"
+"#ifdef USESHADOWMAPVSDCT\n"
+"//    float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters, Texture_CubeProjection);\n"
+"#else\n"
+"//    float3 shadowmaptc = GetShadowMapTC2D(CubeVector, ShadowMap_Parameters);\n"
+"#endif\n"
+"//    color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n"
+"//    color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n"
+"//    color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n"
+"//    color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
+"//    color.rgb = half3(tex2D(Texture_ShadowMap2D, float2(0.1,0.1)).rgb);\n"
+"//    color.rgb = half3(tex2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale).rgb);\n"
+"//    color.rgb = half3(shadowmaptc.xyz * float3(ShadowMap_TextureScale,1.0));\n"
+"//    color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
+"//    color.r = half(shadowmaptc.z - texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
+"//    color.r = half(shadowmaptc.z);\n"
+"//    color.r = half(texDepth2D(Texture_ShadowMap2D, shadowmaptc.xy * ShadowMap_TextureScale));\n"
+"//    color.r = half(shadowmaptc.z);\n"
+"//    color.r = 1;\n"
+"//    color.rgb = abs(CubeVector);\n"
+"#endif\n"
+"//    color.rgb = half3(1,1,1);\n"
 "#endif // MODE_LIGHTSOURCE\n"
 "\n"
 "\n"
@@ -4438,21 +3204,20 @@ const char *builtingles2shaderstring =
 "#ifdef MODE_LIGHTDIRECTION\n"
 "#define SHADING\n"
 "#ifdef USEDIFFUSE\n"
-"      myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
+"      half3 lightnormal = half3(normalize(LightVector));\n"
 "#endif\n"
 "#define lightcolor LightColor\n"
 "#endif // MODE_LIGHTDIRECTION\n"
 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
 "#define SHADING\n"
 "      // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
-"      myhalf3 lightnormal_modelspace = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
-"      myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
+"      half3 lightnormal_modelspace = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
+"      half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n"
 "      // convert modelspace light vector to tangentspace\n"
-"      myhalf3 lightnormal;\n"
-"      lightnormal.x = dot(lightnormal_modelspace, myhalf3(VectorS));\n"
-"      lightnormal.y = dot(lightnormal_modelspace, myhalf3(VectorT));\n"
-"      lightnormal.z = dot(lightnormal_modelspace, myhalf3(VectorR));\n"
-"      lightnormal = normalize(lightnormal); // VectorS/T/R are not always perfectly normalized, and EXACTSPECULARMATH is very picky about this\n"
+"      half3 lightnormal;\n"
+"      lightnormal.x = dot(lightnormal_modelspace, half3(VectorS));\n"
+"      lightnormal.y = dot(lightnormal_modelspace, half3(VectorT));\n"
+"      lightnormal.z = dot(lightnormal_modelspace, half3(VectorR));\n"
 "      // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
 "      // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
 "      // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
@@ -4467,8 +3232,8 @@ const char *builtingles2shaderstring =
 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
 "#define SHADING\n"
 "      // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
-"      myhalf3 lightnormal = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
-"      myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
+"      half3 lightnormal = half3(tex2D(Texture_Deluxemap, TexCoordLightmap).rgb) * 2.0 + half3(-1.0, -1.0, -1.0);\n"
+"      half3 lightcolor = half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb);\n"
 "#endif\n"
 "\n"
 "\n"
@@ -4476,18 +3241,18 @@ const char *builtingles2shaderstring =
 "\n"
 "#ifdef MODE_FAKELIGHT\n"
 "#define SHADING\n"
-"myhalf3 lightnormal = myhalf3(normalize(EyeVector));\n"
-"myhalf3 lightcolor = myhalf3(1.0);\n"
+"half3 lightnormal = half3(normalize(EyeVector));\n"
+"half3 lightcolor = half3(1.0,1.0,1.0);\n"
 "#endif // MODE_FAKELIGHT\n"
 "\n"
 "\n"
 "\n"
 "\n"
 "#ifdef MODE_LIGHTMAP\n"
-"      color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
+"      color.rgb = diffusetex * (Color_Ambient + half3(tex2D(Texture_Lightmap, TexCoordLightmap).rgb) * Color_Diffuse);\n"
 "#endif // MODE_LIGHTMAP\n"
 "#ifdef MODE_VERTEXCOLOR\n"
-"      color.rgb = diffusetex * (Color_Ambient + myhalf3(VertexColor.rgb) * Color_Diffuse);\n"
+"      color.rgb = diffusetex * (Color_Ambient + half3(gl_FrontColor.rgb) * Color_Diffuse);\n"
 "#endif // MODE_VERTEXCOLOR\n"
 "#ifdef MODE_FLATCOLOR\n"
 "      color.rgb = diffusetex * Color_Ambient;\n"
@@ -4498,13 +3263,13 @@ const char *builtingles2shaderstring =
 "\n"
 "#ifdef SHADING\n"
 "# ifdef USEDIFFUSE\n"
-"      myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
+"      half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
 "#  ifdef USESPECULAR\n"
 "#   ifdef USEEXACTSPECULARMATH\n"
-"      myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n"
+"      half specular = half(pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a));\n"
 "#   else\n"
-"      myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
-"      myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n"
+"      half3 specularnormal = half3(normalize(lightnormal + half3(normalize(EyeVector))));\n"
+"      half specular = half(pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a));\n"
 "#   endif\n"
 "      color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n"
 "#  else\n"
@@ -4516,47 +3281,49 @@ const char *builtingles2shaderstring =
 "#endif\n"
 "\n"
 "#ifdef USESHADOWMAPORTHO\n"
-"      color.rgb *= ShadowMapCompare(ShadowMapTC);\n"
+"      color.rgb *= half(ShadowMapCompare(ShadowMapTC, Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale));\n"
 "#endif\n"
 "\n"
 "#ifdef USEDEFERREDLIGHTMAP\n"
-"      vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n"
-"      color.rgb += diffusetex * myhalf3(texture2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n"
-"      color.rgb += glosstex.rgb * myhalf3(texture2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n"
+"      float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n"
+"      color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord).rgb) * DeferredMod_Diffuse;\n"
+"      color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord).rgb) * DeferredMod_Specular;\n"
+"//    color.rgb = half3(tex2D(Texture_ScreenDepth, ScreenTexCoord).rgb);\n"
+"//    color.r = half(texDepth2D(Texture_ScreenDepth, ScreenTexCoord)) * 1.0;\n"
 "#endif\n"
 "\n"
 "#ifdef USEGLOW\n"
 "#ifdef USEVERTEXTEXTUREBLEND\n"
-"      color.rgb += mix(myhalf3(texture2D(Texture_SecondaryGlow, TexCoord2)), myhalf3(texture2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
+"      color.rgb += half3(lerp(tex2D(Texture_SecondaryGlow, TexCoord2).rgb, tex2D(Texture_Glow, TexCoord).rgb, terrainblend)) * Color_Glow;\n"
 "#else\n"
-"      color.rgb += myhalf3(texture2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
+"      color.rgb += half3(tex2D(Texture_Glow, TexCoord).rgb) * Color_Glow;\n"
 "#endif\n"
 "#endif\n"
 "\n"
 "#ifdef USEFOG\n"
-"      color.rgb = FogVertex(color.rgb);\n"
+"      color.rgb = FogVertex(color.rgb, FogColor, EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask, Texture_FogHeightTexture);\n"
 "#endif\n"
 "\n"
 "      // reflection must come last because it already contains exactly the correct fog (the reflection render preserves camera distance from the plane, it only flips the side) and ContrastBoost/SceneBrightness\n"
 "#ifdef USEREFLECTION\n"
-"      vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
-"      //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
-"      vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
-"      vec2 ScreenTexCoord = SafeScreenTexCoord + vec3(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
+"      float4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
+"      //float4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
+"      float2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
+"      float2 ScreenTexCoord = SafeScreenTexCoord + float3(normalize(half3(tex2D(Texture_Normal, TexCoord).rgb) - half3(0.5,0.5,0.5))).xy * DistortScaleRefractReflect.zw;\n"
 "      // FIXME temporary hack to detect the case that the reflection\n"
 "      // gets blackened at edges due to leaving the area that contains actual\n"
 "      // content.\n"
 "      // Remove this 'ack once we have a better way to stop this thing from\n"
 "      // 'appening.\n"
-"      float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
-"      f      *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
-"      ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
-"      color.rgb = mix(color.rgb, myhalf3(texture2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
+"      float f = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, 0.01)).rgb) / 0.05);\n"
+"      f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n"
+"      f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n"
+"      f      *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n"
+"      ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n"
+"      color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord).rgb) * ReflectColor.rgb, ReflectColor.a);\n"
 "#endif\n"
 "\n"
-"      gl_FragColor = vec4(color);\n"
+"      gl_FragColor = float4(color);\n"
 "}\n"
 "#endif // FRAGMENT_SHADER\n"
 "\n"
@@ -4689,26 +3456,6 @@ shadermodeinfo_t hlslshadermodeinfo[SHADERMODE_COUNT] =
        {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
 };
 
-shadermodeinfo_t gles2shadermodeinfo[SHADERMODE_COUNT] =
-{
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_GENERIC\n", " generic"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
-       {"gles2/default.glsl", NULL, NULL                , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_FAKELIGHT\n", " fakelight"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_WATER\n", " water"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
-       {"gles2/default.glsl", NULL, "gles2/default.glsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
-};
-
 struct r_glsl_permutation_s;
 typedef struct r_glsl_permutation_s
 {
@@ -4952,20 +3699,6 @@ static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
                memcpy(shaderstring, glslshaderstring, strlen(glslshaderstring) + 1);
                return shaderstring;
        }
-       if (!strcmp(filename, "gles2/default.glsl"))
-       {
-               if (!glslshaderstring)
-               {
-                       glslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
-                       if (glslshaderstring)
-                               Con_DPrintf("Loading shaders from file %s...\n", filename);
-                       else
-                               glslshaderstring = (char *)builtingles2shaderstring;
-               }
-               shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(glslshaderstring) + 1);
-               memcpy(shaderstring, glslshaderstring, strlen(glslshaderstring) + 1);
-               return shaderstring;
-       }
        shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
        if (shaderstring)
        {
@@ -4980,7 +3713,7 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode
 {
        int i;
        int sampler;
-       shadermodeinfo_t *modeinfo = vid.renderpath == RENDERPATH_GLES2 ? gles2shadermodeinfo + mode : glslshadermodeinfo + mode;
+       shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode;
        char *vertexstring, *geometrystring, *fragmentstring;
        char permutationname[256];
        int vertstrings_count = 0;
@@ -6289,7 +5022,7 @@ void R_SetupShader_SetPermutationSoft(unsigned int mode, unsigned int permutatio
 void R_GLSL_Restart_f(void)
 {
        unsigned int i, limit;
-       if (glslshaderstring && glslshaderstring != builtinshaderstring && glslshaderstring != builtingles2shaderstring)
+       if (glslshaderstring && glslshaderstring != builtinshaderstring)
                Mem_Free(glslshaderstring);
        glslshaderstring = NULL;
        if (cgshaderstring && cgshaderstring != builtincgshaderstring)
@@ -6403,23 +5136,6 @@ void R_GLSL_DumpShader_f(void)
        else
                Con_Printf("failed to write to glsl/default.glsl\n");
 
-       file = FS_OpenRealFile("gles2/default.glsl", "w", false);
-       if (file)
-       {
-               FS_Print(file, "/* The engine may define the following macros:\n");
-               FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
-               for (i = 0;i < SHADERMODE_COUNT;i++)
-                       FS_Print(file, glslshadermodeinfo[i].pretext);
-               for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
-                       FS_Print(file, shaderpermutationinfo[i].pretext);
-               FS_Print(file, "*/\n");
-               FS_Print(file, builtingles2shaderstring);
-               FS_Close(file);
-               Con_Printf("gles2/default.glsl written\n");
-       }
-       else
-               Con_Printf("failed to write to glsl/default.glsl\n");
-
 #ifdef SUPPORTCG
        file = FS_OpenRealFile("cg/default.cg", "w", false);
        if (file)
@@ -6711,6 +5427,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting,
        float *colormod = rsurface.colormod;
        float m16f[16];
        r_waterstate_waterplane_t *waterplane = (r_waterstate_waterplane_t *)surfacewaterplane;
+       if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+               permutation |= SHADERPERMUTATION_ALPHAKILL;
        if (rsurfacepass == RSURFPASS_BACKGROUND)
        {
                // distorted background
@@ -6745,7 +5463,6 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting,
                        GL_BlendFunc(GL_ONE, GL_ZERO);
                        allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
                }
-               GL_AlphaTest(false);
        }
        else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
        {
@@ -6764,13 +5481,10 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting,
                }
                if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
                        permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
-               if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
-                       permutation |= SHADERPERMUTATION_ALPHAKILL;
                // normalmap (deferred prepass), may use alpha test on diffuse
                mode = SHADERMODE_DEFERREDGEOMETRY;
                if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
                        permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
-               GL_AlphaTest(false);
                GL_BlendFunc(GL_ONE, GL_ZERO);
                allow_colormod = R_BlendFuncAllowsColormod(GL_ONE, GL_ZERO);
        }
@@ -6820,7 +5534,6 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting,
                }
                if (rsurface.texture->reflectmasktexture)
                        permutation |= SHADERPERMUTATION_REFLECTCUBE;
-               GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
                GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
                allow_colormod = R_BlendFuncAllowsColormod(GL_SRC_ALPHA, GL_ONE);
        }
@@ -6866,7 +5579,6 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting,
                        permutation |= SHADERPERMUTATION_REFLECTION;
                if (rsurface.texture->reflectmasktexture)
                        permutation |= SHADERPERMUTATION_REFLECTCUBE;
-               GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
                GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
                allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
        }
@@ -6916,7 +5628,6 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting,
                        permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
                if (rsurface.texture->reflectmasktexture)
                        permutation |= SHADERPERMUTATION_REFLECTCUBE;
-               GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
                GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
                allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
        }
@@ -6963,7 +5674,6 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting,
                        permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
                if (rsurface.texture->reflectmasktexture)
                        permutation |= SHADERPERMUTATION_REFLECTCUBE;
-               GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
                GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
                allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
        }
@@ -7046,7 +5756,6 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting,
                        // ordinary vertex coloring (q3bsp)
                        mode = SHADERMODE_VERTEXCOLOR;
                }
-               GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
                GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
                allow_colormod = R_BlendFuncAllowsColormod(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
        }
@@ -8736,6 +7445,7 @@ void gl_main_shutdown(void)
        case RENDERPATH_GL13:
        case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
+       case RENDERPATH_GLES2:
                if (r_maxqueries)
                        qglDeleteQueriesARB(r_maxqueries, r_queries);
                break;
@@ -8750,9 +7460,6 @@ void gl_main_shutdown(void)
                break;
        case RENDERPATH_SOFT:
                break;
-       case RENDERPATH_GLES2:
-               //Con_DPrintf("FIXME GLES2 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
        }
 
        r_numqueries = 0;
@@ -9951,11 +8658,6 @@ void R_EntityMatrix(const matrix4x4_t *matrix)
                case RENDERPATH_D3D11:
                        Con_DPrintf("FIXME D3D11 shader %s:%i\n", __FILE__, __LINE__);
                        break;
-               case RENDERPATH_GL20:
-                       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);
-                       qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
-                       break;
                case RENDERPATH_CGGL:
 #ifdef SUPPORTCG
                        CHECKCGERROR
@@ -9972,6 +8674,7 @@ void R_EntityMatrix(const matrix4x4_t *matrix)
                        DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewProjectionMatrixM1, 1, false, gl_modelviewprojection16f);
                        DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewMatrixM1, 1, false, gl_modelview16f);
                        break;
+               case RENDERPATH_GL20:
                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);
@@ -9992,7 +8695,6 @@ void R_ResetViewRendering2D(void)
        GL_Color(1, 1, 1, 1);
        GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
        GL_BlendFunc(GL_ONE, GL_ZERO);
-       GL_AlphaTest(false);
        GL_ScissorTest(false);
        GL_DepthMask(false);
        GL_DepthRange(0, 1);
@@ -10029,7 +8731,6 @@ void R_ResetViewRendering3D(void)
        GL_Color(1, 1, 1, 1);
        GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
        GL_BlendFunc(GL_ONE, GL_ZERO);
-       GL_AlphaTest(false);
        GL_ScissorTest(true);
        GL_DepthMask(true);
        GL_DepthRange(0, 1);
@@ -10093,10 +8794,10 @@ static void R_Water_StartFrame(void)
        case RENDERPATH_D3D10:
        case RENDERPATH_D3D11:
        case RENDERPATH_SOFT:
+       case RENDERPATH_GLES2:
                break;
        case RENDERPATH_GL13:
        case RENDERPATH_GL11:
-       case RENDERPATH_GLES2:
                return;
        }
 
@@ -10460,10 +9161,10 @@ void R_Bloom_StartFrame(void)
        case RENDERPATH_D3D10:
        case RENDERPATH_D3D11:
        case RENDERPATH_SOFT:
+       case RENDERPATH_GLES2:
                break;
        case RENDERPATH_GL13:
        case RENDERPATH_GL11:
-       case RENDERPATH_GLES2:
                return;
        }
 
@@ -14388,7 +13089,6 @@ static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, const
        r_vertexgeneric_t *batchvertex;
        float c[4];
 
-       GL_AlphaTest(false);
 //     R_Mesh_ResetTextureState();
        R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
 
@@ -14698,7 +13398,6 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const
                                GL_DepthTest(true);
                                GL_BlendFunc(GL_ONE, GL_ZERO);
                                GL_DepthMask(true);
-                               GL_AlphaTest(false);
 //                             R_Mesh_ResetTextureState();
                                R_SetupShader_DepthOrShadow();
                        }
@@ -14757,7 +13456,6 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const
                        R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
        }
        rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
-       GL_AlphaTest(false);
 }
 
 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
@@ -15694,7 +14392,7 @@ void R_DrawDebugModel(void)
                return;
        case RENDERPATH_GLES2:
                //Con_DPrintf("FIXME GLES2 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
+               return;
        }
 
        flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
@@ -15936,7 +14634,6 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep
                return;
        }
        R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
-       GL_AlphaTest(false);
 
        // add to stats if desired
        if (r_speeds.integer && !skysurfaces && !depthonly)
@@ -16076,7 +14773,6 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr
                        if (update[j])
                                R_BuildLightMap(ent, surfaces + j);
        R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
-       GL_AlphaTest(false);
 
        // add to stats if desired
        if (r_speeds.integer && !skysurfaces && !depthonly)

diff --git a/gl_rsurf.c b/gl_rsurf.c
index 1c93ba5f6f8797fa3fdf855edc5a8d2f70940312..4a0586616e5eb8ed30046d85ba06c74010181678 100644 (file)
--- a/gl_rsurf.c
+++ b/gl_rsurf.c
@@ -609,7 +609,6 @@ void R_Q1BSP_DrawDepth(entity_render_t *ent)
        GL_DepthTest(true);
        GL_BlendFunc(GL_ONE, GL_ZERO);
        GL_DepthMask(true);
-       GL_AlphaTest(false);
 //     R_Mesh_ResetTextureState();
        R_SetupShader_DepthOrShadow();
        if (ent == r_refdef.scene.worldentity)

diff --git a/r_shadow.c b/r_shadow.c
index 9f7986a3310e90c39b525f23dafd55ed5ab7db9e..131ca659d469cc7a4d7b64ccea472cc7a952ece1 100644 (file)
--- a/r_shadow.c
+++ b/r_shadow.c
@@ -3244,7 +3244,6 @@ void R_Shadow_SetupEntityLight(const entity_render_t *ent)
 {
        // set up properties for rendering light onto this entity
        RSurf_ActiveModelEntity(ent, true, true, false);
-       GL_AlphaTest(false);
        Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
        Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
        Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
@@ -3258,7 +3257,6 @@ void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned c
 
        // set up properties for rendering light onto this entity
        RSurf_ActiveWorldEntity();
-       GL_AlphaTest(false);
        rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
        Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
        Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
@@ -3794,7 +3792,6 @@ void R_Shadow_DrawPrepass(void)
        entity_render_t *ent;
        float clearcolor[4];
 
-       GL_AlphaTest(false);
        R_Mesh_ResetTextureState();
        GL_DepthMask(true);
        GL_ColorMask(1,1,1,1);
@@ -4467,6 +4464,7 @@ void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
                case RENDERPATH_GL13:
                case RENDERPATH_GL11:
                case RENDERPATH_CGGL:
+               case RENDERPATH_GLES2:
                        CHECKGLERROR
                        // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use GL_DepthFunc instead
                        qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
@@ -4495,9 +4493,6 @@ void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
                case RENDERPATH_SOFT:
                        //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
                        break;
-               case RENDERPATH_GLES2:
-                       //Con_DPrintf("FIXME GLES2 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-                       break;
                }
        }
        rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
@@ -4518,6 +4513,7 @@ void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
                case RENDERPATH_GL13:
                case RENDERPATH_GL11:
                case RENDERPATH_CGGL:
+               case RENDERPATH_GLES2:
                        CHECKGLERROR
                        qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
                        qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
@@ -4535,9 +4531,6 @@ void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
                case RENDERPATH_SOFT:
                        //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
                        break;
-               case RENDERPATH_GLES2:
-                       //Con_DPrintf("FIXME GLES2 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-                       break;
                }
                //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
                if (visiblepixels < 1 || allpixels < 1)
@@ -4644,6 +4637,7 @@ void R_Shadow_DrawCoronas(void)
        case RENDERPATH_GL13:
        case RENDERPATH_GL20:
        case RENDERPATH_CGGL:
+       case RENDERPATH_GLES2:
                usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
                if (usequery)
                {
@@ -4683,10 +4677,6 @@ void R_Shadow_DrawCoronas(void)
                usequery = false;
                //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
                break;
-       case RENDERPATH_GLES2:
-               usequery = false;
-               //Con_DPrintf("FIXME GLES2 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
-               break;
        }
        for (lightindex = 0;lightindex < range;lightindex++)
        {