"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n",
-"// written by Forest 'LordHavoc' Hale\n",
+"// written by Ashley Rose Hale (LadyHavoc)\n",
"// shadowmapping enhancements by Lee 'eihrul' Salzman\n",
"\n",
+"#if defined(USESKELETAL) || defined(USEOCCLUDE)\n",
+"# ifdef GL_ARB_uniform_buffer_object\n",
+"# extension GL_ARB_uniform_buffer_object : enable\n",
+"# endif\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 USECELSHADING\n",
"# define SHADEDIFFUSE myhalf diffuse = cast_myhalf(min(max(float(dot(surfacenormal, lightnormal)) * 2.0, 0.0), 1.0));\n",
"# ifdef USEEXACTSPECULARMATH\n",
"# endif\n",
"#endif\n",
"\n",
-"#ifdef GLSL130\n",
+"#if (defined(GLSL120) || defined(GLSL130) || defined(GLSL140) || defined(GLES)) && defined(VERTEX_SHADER)\n",
+"\n",
+"invariant gl_Position; // fix for lighting polygons not matching base surface\n",
+"# endif\n",
+"#if defined(GLSL130) || defined(GLSL140)\n",
"precision highp float;\n",
"# ifdef VERTEX_SHADER\n",
"# define dp_varying out\n",
"dp_attribute vec4 Attrib_TexCoord4; // lightmap texcoords\n",
"#ifdef USESKELETAL\n",
"//uniform mat4 Skeletal_Transform[128];\n",
-"uniform vec4 Skeletal_Transform12[768];\n",
+"// this is used with glBindBufferRange to bind a uniform block to the name\n",
+"// Skeletal_Transform12_UniformBlock, the Skeletal_Transform12 variable is\n",
+"// directly accessible without a namespace.\n",
+"// explanation: http://www.opengl.org/wiki/Interface_Block_%28GLSL%29#Syntax\n",
+"uniform Skeletal_Transform12_UniformBlock\n",
+"{\n",
+" vec4 Skeletal_Transform12[768];\n",
+"};\n",
"dp_attribute vec4 Attrib_SkeletalIndex;\n",
"dp_attribute vec4 Attrib_SkeletalWeight;\n",
"#endif\n",
"#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE) || defined(MODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP)\n",
"# define USELIGHTMAP\n",
"#endif\n",
-"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(MODE_FAKELIGHT) || defined(USEFOG)\n",
+"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE) || defined(USEFOG)\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",
"\n",
"#ifdef VERTEX_SHADER\n",
"#ifdef USETRIPPY\n",
-"// LordHavoc: based on shader code linked at: http://www.youtube.com/watch?v=JpksyojwqzE\n",
+"// LadyHavoc: based on shader code linked at: http://www.youtube.com/watch?v=JpksyojwqzE\n",
"// tweaked scale\n",
"uniform highp float ClientTime;\n",
"vec4 TrippyVertex(vec4 position)\n",
"uniform mediump vec4 UserVec2;\n",
"// uniform mediump vec4 UserVec3;\n",
"// uniform mediump vec4 UserVec4;\n",
+"uniform mediump float ColorFringe;\n",
"// uniform highp float ClientTime;\n",
"uniform mediump vec2 PixelSize;\n",
-"void main(void)\n",
+"\n",
+"#ifdef USEFXAA\n",
+"// graphitemaster: based off the white paper by Timothy Lottes\n",
+"// http://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf\n",
+"vec4 fxaa(vec4 inColor, float maxspan)\n",
"{\n",
-" dp_FragColor = dp_texture2D(Texture_First, TexCoord1);\n",
-"#ifdef USEBLOOM\n",
-" dp_FragColor += max(vec4(0,0,0,0), dp_texture2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n",
+" vec4 ret = inColor; // preserve old\n",
+" float mulreduct = 1.0/maxspan;\n",
+" float minreduct = (1.0 / 128.0);\n",
+"\n",
+" // directions\n",
+" vec3 NW = dp_texture2D(Texture_First, TexCoord1 + (vec2(-1.0, -1.0) * PixelSize)).xyz;\n",
+" vec3 NE = dp_texture2D(Texture_First, TexCoord1 + (vec2(+1.0, -1.0) * PixelSize)).xyz;\n",
+" vec3 SW = dp_texture2D(Texture_First, TexCoord1 + (vec2(-1.0, +1.0) * PixelSize)).xyz;\n",
+" vec3 SE = dp_texture2D(Texture_First, TexCoord1 + (vec2(+1.0, +1.0) * PixelSize)).xyz;\n",
+" vec3 M = dp_texture2D(Texture_First, TexCoord1).xyz;\n",
+"\n",
+" // luminance directions\n",
+" vec3 luma = vec3(0.299, 0.587, 0.114);\n",
+" float lNW = dot(NW, luma);\n",
+" float lNE = dot(NE, luma);\n",
+" float lSW = dot(SW, luma);\n",
+" float lSE = dot(SE, luma);\n",
+" float lM = dot(M, luma);\n",
+" float lMin = min(lM, min(min(lNW, lNE), min(lSW, lSE)));\n",
+" float lMax = max(lM, max(max(lNW, lNE), max(lSW, lSE)));\n",
+"\n",
+" // direction and reciprocal\n",
+" vec2 dir = vec2(-((lNW + lNE) - (lSW + lSE)), ((lNW + lSW) - (lNE + lSE)));\n",
+" float rcp = 1.0/(min(abs(dir.x), abs(dir.y)) + max((lNW + lNE + lSW + lSE) * (0.25 * mulreduct), minreduct));\n",
+"\n",
+" // span\n",
+" dir = min(vec2(maxspan, maxspan), max(vec2(-maxspan, -maxspan), dir * rcp)) * PixelSize;\n",
+"\n",
+" vec3 rA = (1.0/2.0) * (\n",
+" dp_texture2D(Texture_First, TexCoord1 + dir * (1.0/3.0 - 0.5)).xyz +\n",
+" dp_texture2D(Texture_First, TexCoord1 + dir * (2.0/3.0 - 0.5)).xyz);\n",
+" vec3 rB = rA * (1.0/2.0) + (1.0/4.0) * (\n",
+" dp_texture2D(Texture_First, TexCoord1 + dir * (0.0/3.0 - 0.5)).xyz +\n",
+" dp_texture2D(Texture_First, TexCoord1 + dir * (3.0/3.0 - 0.5)).xyz);\n",
+" float lB = dot(rB, luma);\n",
+"\n",
+" ret.xyz = ((lB < lMin) || (lB > lMax)) ? rA : rB;\n",
+" ret.a = 1.0;\n",
+" return ret;\n",
+"}\n",
"#endif\n",
-"#ifdef USEVIEWTINT\n",
-" dp_FragColor = mix(dp_FragColor, ViewTintColor, ViewTintColor.a);\n",
+"\n",
+"void main(void)\n",
+"{\n",
+" float fringe = ColorFringe;//.0033f;\n",
+" float amount = distance(TexCoord1, vec2(.5f,.5f));\n",
+" vec2 offset = vec2(amount*fringe,amount*fringe);\n",
+" dp_FragColor.xy = texture(Texture_First, TexCoord1-offset).xy;\n",
+" dp_FragColor.z = texture(Texture_First, TexCoord1+offset).z;\n",
+"\n",
+"#ifdef USEFXAA\n",
+" dp_FragColor = fxaa(dp_FragColor, 8.0); // 8.0 can be changed for larger span\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",
+"#if defined(USERVEC1) || defined(USERVEC2)\n",
" float sobel = 1.0;\n",
" // vec2 ts = textureSize(Texture_First, 0);\n",
" // vec2 px = vec2(1/ts.x, 1/ts.y);\n",
" dp_FragColor /= (1.0 + 5.0 * UserVec1.y);\n",
" dp_FragColor.rgb = dp_FragColor.rgb * (1.0 + UserVec2.x) + vec3(max(0.0, sobel - UserVec2.z))*UserVec2.y;\n",
"#endif\n",
+"#endif\n",
+"\n",
+"#ifdef USEBLOOM\n",
+" dp_FragColor += max(vec4(0,0,0,0), dp_texture2D(Texture_Second, TexCoord2) - BloomColorSubtract);\n",
+"#endif\n",
+"\n",
+"#ifdef USEVIEWTINT\n",
+" dp_FragColor = mix(dp_FragColor, ViewTintColor, ViewTintColor.a);\n",
+"#endif\n",
"\n",
"#ifdef USESATURATION\n",
" //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n",
"dp_varying highp vec4 EyeVectorFogDepth;\n",
"#endif\n",
"\n",
-"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE) || defined(USEBOUNCEGRIDDIRECTIONAL)\n",
+"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE) || defined(USEBOUNCEGRIDDIRECTIONAL) || defined(MODE_LIGHTGRID)\n",
"dp_varying highp vec4 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n",
"dp_varying highp vec4 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n",
"dp_varying highp vec4 VectorR; // direction of R texcoord (surface normal)\n",
"dp_varying highp vec3 ShadowMapTC;\n",
"#endif\n",
"\n",
+"#ifdef MODE_LIGHTGRID\n",
+"dp_varying highp vec3 LightGridTC;\n",
+"#endif\n",
"#ifdef USEBOUNCEGRID\n",
"dp_varying highp vec3 BounceGridTexCoord;\n",
"#endif\n",
"uniform highp float FogHeightFade;\n",
"vec3 FogVertex(vec4 surfacecolor)\n",
"{\n",
-"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE) || defined(USEBOUNCEGRIDDIRECTIONAL)\n",
+"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE) || defined(USEBOUNCEGRIDDIRECTIONAL) || defined(MODE_LIGHTGRID)\n",
" vec3 EyeVectorModelSpace = vec3(VectorS.w, VectorT.w, VectorR.w);\n",
"#endif\n",
" float FogPlaneVertexDist = EyeVectorFogDepth.w;\n",
"#endif\n",
"\n",
"#if defined(USESHADOWMAP2D)\n",
-"uniform mediump vec2 ShadowMap_TextureScale;\n",
+"uniform mediump vec4 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",
+"# define GetShadowMapTC2D(dir) (max(vec3(0.0, 0.0, 0.0), min(dir, ShadowMap_Parameters.xyz)))\n",
"# else\n",
"# ifdef USESHADOWMAPVSDCT\n",
"vec3 GetShadowMapTC2D(vec3 dir)\n",
"# ifdef USESHADOWMAP2D\n",
"float ShadowMapCompare(vec3 dir)\n",
"{\n",
-" vec3 shadowmaptc = GetShadowMapTC2D(dir);\n",
+" vec3 shadowmaptc = GetShadowMapTC2D(dir) + vec3(ShadowMap_TextureScale.zw, 0.0f);\n",
" float f;\n",
"\n",
"# ifdef USEDEPTHRGB\n",
"# ifdef USESHADOWMAPPCF\n",
-"# define texval(x, y) decodedepthmacro(dp_texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale))\n",
+"# define texval(x, y) decodedepthmacro(dp_texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale.xy))\n",
"# if USESHADOWMAPPCF > 1\n",
" vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n",
-" center *= ShadowMap_TextureScale;\n",
+" center *= ShadowMap_TextureScale.xy;\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 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",
+" vec2 center = shadowmaptc.xy*ShadowMap_TextureScale.xy, 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",
" f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n",
"# endif\n",
"# else\n",
-" f = step(shadowmaptc.z, decodedepthmacro(dp_texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale)));\n",
+" f = step(shadowmaptc.z, decodedepthmacro(dp_texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale.xy)));\n",
"# endif\n",
"# else\n",
"# ifdef USESHADOWSAMPLER\n",
" vec2 offset = fract(shadowmaptc.xy - 0.5);\n",
" vec4 size = vec4(offset + 1.0, 2.0 - offset);\n",
"# if USESHADOWMAPPCF > 1\n",
-" vec2 center = (shadowmaptc.xy - offset + 0.5)*ShadowMap_TextureScale;\n",
+" vec2 center = (shadowmaptc.xy - offset + 0.5)*ShadowMap_TextureScale.xy;\n",
" vec4 weight = (vec4(-1.5, -1.5, 2.0, 2.0) + (shadowmaptc.xy - 0.5*offset).xyxy)*ShadowMap_TextureScale.xyxy;\n",
" f = (1.0/25.0)*dot(size.zxzx*size.wwyy, vec4(texval(weight.xy), texval(weight.zy), texval(weight.xw), texval(weight.zw))) +\n",
" (2.0/25.0)*dot(size, vec4(texval(vec2(weight.z, center.y)), texval(vec2(center.x, weight.w)), texval(vec2(weight.x, center.y)), texval(vec2(center.x, weight.y)))) +\n",
" f = (1.0/9.0)*dot(size.zxzx*size.wwyy, vec4(texval(weight.zw), texval(weight.xw), texval(weight.zy), texval(weight.xy)));\n",
"# endif \n",
"# else\n",
-" f = dp_shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z));\n",
+" f = dp_shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale.xy, shadowmaptc.z));\n",
"# endif\n",
"# else\n",
"# ifdef USESHADOWMAPPCF\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",
+"# define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale.xy)\n",
"# endif\n",
-" vec2 offset = fract(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale;\n",
+" vec2 offset = fract(shadowmaptc.xy - 0.5), center = (shadowmaptc.xy - offset)*ShadowMap_TextureScale.xy;\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",
"# ifdef GL_EXT_gpu_shader4\n",
"# define texval(x, y) dp_textureOffset(Texture_ShadowMap2D, center, x, y).r\n",
"# else\n",
-"# define texval(x, y) dp_texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale).r \n",
+"# define texval(x, y) dp_texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale.xy).r \n",
"# endif\n",
"# if USESHADOWMAPPCF > 1\n",
" vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n",
-" center *= ShadowMap_TextureScale;\n",
+" center *= ShadowMap_TextureScale.xy;\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 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",
+" vec2 center = shadowmaptc.xy*ShadowMap_TextureScale.xy, 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",
"# endif\n",
"# endif\n",
"# else\n",
-" f = step(shadowmaptc.z, dp_texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n",
+" f = step(shadowmaptc.z, dp_texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale.xy).r);\n",
"# endif\n",
"# endif\n",
"# endif\n",
"#ifdef USESHADOWMAPORTHO\n",
"uniform highp mat4 ShadowMapMatrix;\n",
"#endif\n",
+"#ifdef MODE_LIGHTGRID\n",
+"uniform highp mat4 LightGridMatrix;\n",
+"#endif\n",
"#ifdef USEBOUNCEGRID\n",
"uniform highp mat4 BounceGridMatrix;\n",
"#endif\n",
" TexCoord2 = vec2(BackgroundTexMatrix * Attrib_TexCoord0);\n",
"#endif\n",
"\n",
+"#ifdef MODE_LIGHTGRID\n",
+" LightGridTC = vec3(LightGridMatrix * Attrib_Position);\n",
+"#endif\n",
"#ifdef USEBOUNCEGRID\n",
" BounceGridTexCoord = vec3(BounceGridMatrix * Attrib_Position);\n",
"#ifdef USEBOUNCEGRIDDIRECTIONAL\n",
"#endif\n",
"\n",
"\n",
-"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE) || defined(USEBOUNCEGRIDDIRECTIONAL)\n",
+"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE) || defined(USEBOUNCEGRIDDIRECTIONAL) || defined(MODE_LIGHTGRID)\n",
"# ifdef USEFOG\n",
" VectorS = vec4(Attrib_TexCoord1.xyz, EyePosition.x - Attrib_Position.x);\n",
" VectorT = vec4(Attrib_TexCoord2.xyz, EyePosition.y - Attrib_Position.y);\n",
"uniform sampler2D Texture_ReflectMask;\n",
"uniform samplerCube Texture_ReflectCube;\n",
"#endif\n",
-"#ifdef MODE_LIGHTDIRECTION\n",
-"uniform myhalf3 LightColor;\n",
-"#endif\n",
-"#ifdef MODE_LIGHTSOURCE\n",
-"uniform myhalf3 LightColor;\n",
+"#ifdef MODE_LIGHTGRID\n",
+"uniform sampler3D Texture_LightGrid;\n",
+"uniform mat3 LightGridNormalMatrix;\n",
"#endif\n",
"#ifdef USEBOUNCEGRID\n",
"uniform sampler3D Texture_BounceGrid;\n",
"#ifdef USENORMALMAPSCROLLBLEND\n",
"uniform highp vec2 NormalmapScrollBlend;\n",
"#endif\n",
+"#ifdef USEOCCLUDE\n",
+"uniform occludeQuery {\n",
+" uint visiblepixels;\n",
+" uint allpixels;\n",
+"};\n",
+"#endif\n",
"void main(void)\n",
"{\n",
"#ifdef USEOFFSETMAPPING\n",
"#else\n",
" color.rgb = diffusetex * Color_Ambient;\n",
"#endif\n",
-" color.rgb *= LightColor;\n",
" color.rgb *= cast_myhalf(dp_texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n",
"#if defined(USESHADOWMAP2D)\n",
" color.rgb *= ShadowMapCompare(CubeVector);\n",
"\n",
"\n",
"\n",
+"#ifdef MODE_LIGHTGRID\n",
+" // clamp the LightGrid TC Z coordinate to the first of the 3 layers, to\n",
+" // prevent repeat-artifacts for lightgrids smaller than the visible scene\n",
+" // (which is often the case - the lightgrid bounds is defined by the level\n",
+" // designer and usually matches the playable area, not the scenery around\n",
+" // it), we can rely on GL_CLAMP_TO_EDGE for this in all other directions.\n",
+" vec3 LGTC = vec3(LightGridTC.xy, min(LightGridTC.z, 0.333333));\n",
+" myhalf3 ambientcolor = cast_myhalf3(dp_texture2D(Texture_LightGrid, LGTC));\n",
+" myhalf3 lightcolor = cast_myhalf3(dp_texture2D(Texture_LightGrid, LGTC + vec3(0, 0, 0.333333)));\n",
+" myhalf3 lightnormal_worldspace = cast_myhalf3(dp_texture2D(Texture_LightGrid, LGTC + vec3(0, 0, 0.6666667))) * 2.0 + cast_myhalf3(-1.0, -1.0, -1.0);\n",
+" myhalf3 lightnormal_modelspace = cast_myhalf3(lightnormal_worldspace * LightGridNormalMatrix);\n",
+" // convert modelspace light vector to tangentspace\n",
+" myhalf3 lightnormal;\n",
+" lightnormal.x = dot(lightnormal_modelspace, cast_myhalf3(VectorS));\n",
+" lightnormal.y = dot(lightnormal_modelspace, cast_myhalf3(VectorT));\n",
+" lightnormal.z = dot(lightnormal_modelspace, cast_myhalf3(VectorR));\n",
+" lightnormal = normalize(lightnormal); // VectorS/T/R are not always perfectly normalized, and EXACTSPECULARMATH is very picky about this\n",
+" // now we have the light parameters, so do the shading...\n",
+"SHADEDIFFUSE\n",
+" color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * (ambientcolor + diffuse * lightcolor));\n",
+"#ifdef USESPECULAR\n",
+"SHADESPECULAR(SpecularPower * glosstex.a)\n",
+" color.rgb += glosstex.rgb * (specular * Color_Specular * lightcolor);\n",
+"#endif\n",
+"#endif\n",
+"\n",
+"\n",
+"\n",
"#ifdef MODE_LIGHTDIRECTION\n",
" #define SHADING\n",
" #ifdef USEDIFFUSE\n",
" myhalf3 lightnormal = cast_myhalf3(normalize(LightVector));\n",
" #endif\n",
-" #define lightcolor LightColor\n",
+" #define lightcolor 1\n",
"#endif // MODE_LIGHTDIRECTION\n",
"#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n",
" #define SHADING\n",
" myhalf3 lightcolor = cast_myhalf3(VertexColor.rgb);\n",
" #endif\n",
"#endif\n",
-"#ifdef MODE_FAKELIGHT\n",
-" #define SHADING\n",
-" myhalf3 lightnormal = cast_myhalf3(normalize(EyeVectorFogDepth.xyz));\n",
-" myhalf3 lightcolor = cast_myhalf3(1.0);\n",
-"#endif // MODE_FAKELIGHT\n",
"\n",
"\n",
"\n",
" ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n",
" color.rgb = mix(color.rgb, cast_myhalf3(dp_texture2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n",
"#endif\n",
+"#ifdef USEOCCLUDE\n",
+" color.rgb *= clamp(float(visiblepixels) / float(allpixels), 0.0, 1.0);\n",
+"#endif\n",
"\n",
" dp_FragColor = vec4(color);\n",
"}\n",