Add Zone height fog support, HeightFog shader option and techniques.

Add GammaCorrection and AutoExposure post processing shaders.
Add near & far clip PS uniforms.
Add 3d texture support and (3d LUT based) ColorCorrection post processing shader.
Add HDR renderpath support, BloomHDR, Blur and Tonemap post processing shaders.

Bin/CoreData/RenderPaths/PrepassHDR.xml

@@ -0,0 +1,21 @@
+<renderpath>
+    <rendertarget name="light" rtsizedivisor="1 1"  format="rgba16f" />
+    <rendertarget name="normal" rtsizedivisor="1 1" format="rgba" />
+    <rendertarget name="depth" rtsizedivisor="1 1"  format="lineardepth" />
+    <command type="clear" color="fog" depth="1.0" stencil="0" />
+    <command type="scenepass" pass="prepass" marktostencil="true" metadata="gbuffer">
+        <output index="0" name="normal" />
+        <output index="1" name="depth" />
+    </command>
+    <command type="clear" color="0 0 0 0" output="light" />
+    <command type="lightvolumes" vs="PrepassLight" ps="PrepassLight" output="light">
+        <texture unit="normal" name="normal" />
+        <texture unit="depth" name="depth" />
+    </command>
+    <command type="scenepass" pass="material" vertexlights="true">
+        <texture unit="light" name="light" />
+    </command>
+    <command type="scenepass" pass="prealpha"/>
+    <command type="scenepass" pass="alpha" usescissor="true" vertexlights="true" sort="backtofront" metadata="alpha" />
+    <command type="scenepass" pass="postalpha" sort="backtofront" />
+</renderpath>

Bin/CoreData/Shaders/GLSL/AutoExposure.frag

@@ -0,0 +1,60 @@
+#include "Uniforms.frag"
+#include "Samplers.frag"
+#include "PostProcess.frag"
+
+uniform float cAutoExposureAdaptRate;
+uniform float cAutoExposureMiddleGrey;
+uniform float cAutoExposureSensitivity;
+uniform vec2 cHDR128InvSize;
+uniform vec2 cLum64InvSize;
+uniform vec2 cLum16InvSize;
+uniform vec2 cLum4InvSize;
+
+varying vec2 vTexCoord;
+varying vec2 vScreenPos;
+
+float GatherAvgLum(sampler2D texSampler, vec2 texCoord, vec2 texelSize)
+{
+    float lumAvg = 0.0;
+    lumAvg += texture2D(texSampler, texCoord + vec2(1.0, -1.0) * texelSize).r;
+    lumAvg += texture2D(texSampler, texCoord + vec2(-1.0, 1.0) * texelSize).r;
+    lumAvg += texture2D(texSampler, texCoord + vec2(1.0, 1.0) * texelSize).r;
+    lumAvg += texture2D(texSampler, texCoord + vec2(1.0, -1.0) * texelSize).r;
+    return lumAvg / 4.0;
+}
+
+void main()
+{
+    #ifdef LUMINANCE64
+    float logLumSum = 1e-5;
+    logLumSum += log(dot(texture2D(sDiffMap, vTexCoord + vec2(-1.0, -1.0) * cHDR128InvSize).rgb, LumWeights));
+    logLumSum += log(dot(texture2D(sDiffMap, vTexCoord + vec2(-1.0, 1.0) * cHDR128InvSize).rgb, LumWeights));
+    logLumSum += log(dot(texture2D(sDiffMap, vTexCoord + vec2(1.0, 1.0) * cHDR128InvSize).rgb, LumWeights));
+    logLumSum += log(dot(texture2D(sDiffMap, vTexCoord + vec2(1.0, -1.0) * cHDR128InvSize).rgb, LumWeights));
+    gl_FragColor.r = logLumSum;
+    #endif
+
+    #ifdef LUMINANCE16
+    gl_FragColor.r = exp(GatherAvgLum(sDiffMap, vTexCoord, cLum64InvSize) / 16.0);
+    #endif
+
+    #ifdef LUMINANCE4
+    gl_FragColor.r = GatherAvgLum(sDiffMap, vTexCoord, cLum16InvSize);
+    #endif
+
+    #ifdef LUMINANCE1
+    gl_FragColor.r = GatherAvgLum(sDiffMap, vTexCoord, cLum4InvSize);
+    #endif
+
+    #ifdef ADAPTLUMINANCE
+    float adaptedLum = texture2D(sDiffMap, vTexCoord).r;
+    float lum = texture2D(sNormalMap, vTexCoord).r;
+    gl_FragColor.r = adaptedLum + (lum - adaptedLum) * (1.0 - exp(-cDeltaTimePS * cAutoExposureAdaptRate));
+    #endif
+
+    #ifdef EXPOSE
+    vec3 color = texture2D(sDiffMap, vScreenPos).rgb;
+    float adaptedLum = max(mix(cAutoExposureMiddleGrey, texture2D(sNormalMap, vTexCoord).r, cAutoExposureSensitivity), 1e-5);
+    gl_FragColor = vec4(color * (cAutoExposureMiddleGrey / adaptedLum), 1.0);
+    #endif
+}

Bin/CoreData/Shaders/GLSL/AutoExposure.vert

@@ -0,0 +1,15 @@
+#include "Uniforms.vert"
+#include "Transform.vert"
+#include "ScreenPos.vert"
+
+varying vec2 vTexCoord;
+varying vec2 vScreenPos;
+
+void main()
+{
+    mat4 modelMatrix = iModelMatrix;
+    vec3 worldPos = GetWorldPos(modelMatrix);
+    gl_Position = GetClipPos(worldPos);
+    vTexCoord = GetQuadTexCoord(gl_Position);
+    vScreenPos = GetScreenPosPreDiv(gl_Position);
+}

Bin/CoreData/Shaders/GLSL/AutoExposure.xml

@@ -0,0 +1,18 @@
+<shaders>
+    <shader type="vs">
+        <variation name="Luminance64" define="LUMINANCE64" />
+        <variation name="Luminance16" define="LUMINANCE16" />
+        <variation name="Luminance4" define="LUMINANCE4" />
+        <variation name="Luminance1" define="LUMINANCE1" />
+        <variation name="AdaptLuminance" define="ADAPTLUMINANCE" />
+        <variation name="Expose" define="EXPOSE" />
+    </shader>
+    <shader type="ps">
+        <variation name="Luminance64" define="LUMINANCE64" />
+        <variation name="Luminance16" define="LUMINANCE16" />
+        <variation name="Luminance4" define="LUMINANCE4" />
+        <variation name="Luminance1" define="LUMINANCE1" />
+        <variation name="AdaptLuminance" define="ADAPTLUMINANCE" />
+        <variation name="Expose" define="EXPOSE" />
+    </shader>
+</shaders>

Bin/CoreData/Shaders/GLSL/BloomHDR.frag

@@ -0,0 +1,60 @@
+#include "Uniforms.frag"
+#include "Samplers.frag"
+#include "PostProcess.frag"
+
+uniform float cBloomHDRThreshold;
+uniform float cBloomHDRBlurSigma;
+uniform float cBloomHDRBlurRadius;
+uniform vec2 cBloomHDRBlurDir;
+uniform vec2 cBloomHDRMix;
+uniform vec2 cBright2InvSize;
+uniform vec2 cBright4InvSize;
+uniform vec2 cBright8InvSize;
+uniform vec2 cBright16InvSize;
+
+varying vec2 vTexCoord;
+varying vec2 vScreenPos;
+
+const int BlurKernelSize = 5;
+
+void main()
+{
+    #ifdef BRIGHT
+    vec3 color = texture2D(sDiffMap, vScreenPos).rgb;
+    gl_FragColor = vec4(max(color - cBloomHDRThreshold, 0.0), 1.0);
+    #endif
+
+    #ifdef BLUR16
+    gl_FragColor = GaussianBlur(BlurKernelSize, cBloomHDRBlurDir, cBright16InvSize * cBloomHDRBlurRadius, cBloomHDRBlurSigma, sDiffMap, vScreenPos);
+    #endif
+
+    #ifdef BLUR8
+    gl_FragColor = GaussianBlur(BlurKernelSize, cBloomHDRBlurDir, cBright8InvSize * cBloomHDRBlurRadius, cBloomHDRBlurSigma, sDiffMap, vScreenPos);
+    #endif
+
+    #ifdef BLUR4
+    gl_FragColor = GaussianBlur(BlurKernelSize, cBloomHDRBlurDir, cBright4InvSize * cBloomHDRBlurRadius, cBloomHDRBlurSigma, sDiffMap, vScreenPos);
+    #endif
+
+    #ifdef BLUR2
+    gl_FragColor = GaussianBlur(BlurKernelSize, cBloomHDRBlurDir, cBright2InvSize * cBloomHDRBlurRadius, cBloomHDRBlurSigma, sDiffMap, vScreenPos);
+    #endif
+
+    #ifdef COMBINE16
+    gl_FragColor = texture2D(sDiffMap, vScreenPos) + texture2D(sNormalMap, vTexCoord);
+    #endif
+
+    #ifdef COMBINE8
+    gl_FragColor = texture2D(sDiffMap, vScreenPos) + texture2D(sNormalMap, vTexCoord);
+    #endif
+
+    #ifdef COMBINE4
+    gl_FragColor = texture2D(sDiffMap, vScreenPos) + texture2D(sNormalMap, vTexCoord);
+    #endif
+
+    #ifdef COMBINE2
+    vec3 color = texture2D(sDiffMap, vScreenPos).rgb * cBloomHDRMix.x;
+    vec3 bloom = texture2D(sNormalMap, vTexCoord).rgb * cBloomHDRMix.y;
+    gl_FragColor = vec4(color + bloom, 1.0);
+    #endif
+}

Bin/CoreData/Shaders/GLSL/BloomHDR.vert

@@ -0,0 +1,15 @@
+#include "Uniforms.vert"
+#include "Transform.vert"
+#include "ScreenPos.vert"
+
+varying vec2 vTexCoord;
+varying vec2 vScreenPos;
+
+void main()
+{
+    mat4 modelMatrix = iModelMatrix;
+    vec3 worldPos = GetWorldPos(modelMatrix);
+    gl_Position = GetClipPos(worldPos);
+    vTexCoord = GetQuadTexCoord(gl_Position);
+    vScreenPos = GetScreenPosPreDiv(gl_Position);
+}

Bin/CoreData/Shaders/GLSL/BloomHDR.xml

@@ -0,0 +1,24 @@
+<shaders>
+    <shader type="vs">
+        <variation name="Bright" define="BRIGHT" />
+        <variation name="Blur2" define="BLUR2" />
+        <variation name="Blur4" define="BLUR4" />
+        <variation name="Blur8" define="BLUR8" />
+        <variation name="Blur16" define="BLUR16" />
+        <variation name="Combine2" define="COMBINE2" />
+        <variation name="Combine4" define="COMBINE4" />
+        <variation name="Combine8" define="COMBINE8" />
+        <variation name="Combine16" define="COMBINE16" />
+    </shader>
+    <shader type="ps">
+        <variation name="Bright" define="BRIGHT" />
+        <variation name="Blur2" define="BLUR2" />
+        <variation name="Blur4" define="BLUR4" />
+        <variation name="Blur8" define="BLUR8" />
+        <variation name="Blur16" define="BLUR16" />
+        <variation name="Combine2" define="COMBINE2" />
+        <variation name="Combine4" define="COMBINE4" />
+        <variation name="Combine8" define="COMBINE8" />
+        <variation name="Combine16" define="COMBINE16" />
+    </shader>
+</shaders>

Bin/CoreData/Shaders/GLSL/Blur.frag

@@ -0,0 +1,30 @@
+#include "Uniforms.frag"
+#include "Samplers.frag"
+#include "PostProcess.frag"
+
+uniform vec2 cBlurDir;
+uniform float cBlurRadius;
+uniform float cBlurSigma;
+uniform vec2 cBlurHInvSize;
+
+varying vec2 vTexCoord;
+varying vec2 vScreenPos;
+
+void main()
+{
+    #ifdef BLUR3
+        gl_FragColor = GaussianBlur(3, cBlurDir, cBlurHInvSize * cBlurRadius, cBlurSigma, sDiffMap, vTexCoord);
+    #endif
+
+    #ifdef BLUR5
+        gl_FragColor = GaussianBlur(5, cBlurDir, cBlurHInvSize * cBlurRadius, cBlurSigma, sDiffMap, vTexCoord);
+    #endif
+
+    #ifdef BLUR7
+        gl_FragColor = GaussianBlur(7, cBlurDir, cBlurHInvSize * cBlurRadius, cBlurSigma, sDiffMap, vTexCoord);
+    #endif
+
+    #ifdef BLUR9
+        gl_FragColor = GaussianBlur(9, cBlurDir, cBlurHInvSize * cBlurRadius, cBlurSigma, sDiffMap, vTexCoord);
+    #endif
+}

Bin/CoreData/Shaders/GLSL/Blur.vert

@@ -0,0 +1,15 @@
+#include "Uniforms.vert"
+#include "Transform.vert"
+#include "ScreenPos.vert"
+
+varying vec2 vTexCoord;
+varying vec2 vScreenPos;
+
+void main()
+{
+    mat4 modelMatrix = iModelMatrix;
+    vec3 worldPos = GetWorldPos(modelMatrix);
+    gl_Position = GetClipPos(worldPos);
+    vTexCoord = GetQuadTexCoord(gl_Position);
+    vScreenPos = GetScreenPosPreDiv(gl_Position);
+}

Bin/CoreData/Shaders/GLSL/Blur.xml

@@ -0,0 +1,9 @@
+<shaders>
+    <shader type="vs" />
+    <shader type="ps">
+    	<variation name="Blur3" define="BLUR3" />
+        <variation name="Blur5" define="BLUR5" />
+        <variation name="Blur7" define="BLUR7" />
+        <variation name="Blur9" define="BLUR9" />
+    </shader>
+</shaders>

Bin/CoreData/Shaders/GLSL/ColorCorrection.frag

@@ -0,0 +1,11 @@
+#include "Uniforms.frag"
+#include "Samplers.frag"
+#include "PostProcess.frag"
+
+varying vec2 vScreenPos;
+
+void main()
+{
+    vec3 color = texture2D(sDiffMap, vScreenPos).rgb;
+    gl_FragColor = vec4(ColorCorrection(color, sVolumeMap), 1.0);
+}

Bin/CoreData/Shaders/GLSL/ColorCorrection.vert

@@ -0,0 +1,13 @@
+#include "Uniforms.vert"
+#include "Transform.vert"
+#include "ScreenPos.vert"
+
+varying vec2 vScreenPos;
+
+void main()
+{
+    mat4 modelMatrix = iModelMatrix;
+    vec3 worldPos = GetWorldPos(modelMatrix);
+    gl_Position = GetClipPos(worldPos);
+    vScreenPos = GetScreenPosPreDiv(gl_Position);
+}

Bin/CoreData/Shaders/GLSL/ColorCorrection.xml

@@ -0,0 +1,3 @@
+<shaders>
+    <shader />
+</shaders>

Bin/CoreData/Shaders/GLSL/Fog.frag

@@ -1,14 +1,22 @@
-vec3 GetFog(vec3 color, float depth)
+vec3 GetFog(vec3 color, float fogFactor)
 {
-    return mix(cFogColor, color, clamp((cFogParams.x - depth) * cFogParams.y, 0.0, 1.0));
+    return mix(cFogColor, color, fogFactor);
 }
 
-vec3 GetLitFog(vec3 color, float depth)
+vec3 GetLitFog(vec3 color, float fogFactor)
 {
-    return color * clamp((cFogParams.x - depth) * cFogParams.y, 0.0, 1.0);
+    return color * fogFactor;
 }
 
 float GetFogFactor(float depth)
 {
     return clamp((cFogParams.x - depth) * cFogParams.y, 0.0, 1.0);
 }
+
+float GetHeightFogFactor(float depth, float height)
+{
+    float fogFactor = GetFogFactor(depth);
+    float heightFogFactor = (height - cFogParams.z) * cFogParams.w;
+    heightFogFactor = 1.0 - clamp(exp(-(heightFogFactor * heightFogFactor)), 0.0, 1.0);
+	return min(heightFogFactor, fogFactor);
+}

Bin/CoreData/Shaders/GLSL/GammaCorrection.frag

@@ -0,0 +1,13 @@
+#include "Uniforms.frag"
+#include "Samplers.frag"
+#include "PostProcess.frag"
+
+uniform float cGamma;
+
+varying vec2 vScreenPos;
+
+void main()
+{
+    vec3 color = texture2D(sDiffMap, vScreenPos).rgb;
+    gl_FragColor = vec4(ToInverseGamma(color), 1.0);
+}

Bin/CoreData/Shaders/GLSL/GammaCorrection.vert

@@ -0,0 +1,13 @@
+#include "Uniforms.vert"
+#include "Transform.vert"
+#include "ScreenPos.vert"
+
+varying vec2 vScreenPos;
+
+void main()
+{
+    mat4 modelMatrix = iModelMatrix;
+    vec3 worldPos = GetWorldPos(modelMatrix);
+    gl_Position = GetClipPos(worldPos);
+    vScreenPos = GetScreenPosPreDiv(gl_Position);
+}

Bin/CoreData/Shaders/GLSL/GammaCorrection.xml

@@ -0,0 +1,3 @@
+<shaders>
+    <shader />
+</shaders>

Bin/CoreData/Shaders/GLSL/LitParticle.frag

@@ -4,6 +4,9 @@
 #include "Fog.frag"
 
 varying vec2 vTexCoord;
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 #ifdef VERTEXCOLOR
     varying vec4 vColor;
 #endif
@@ -54,16 +57,29 @@ void main()
         #endif
     
         finalColor = diff * lightColor * diffColor.rgb;
+
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(vLightVec.w, vWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(vLightVec.w);
+        #endif
         
         #ifdef AMBIENT
             finalColor += cAmbientColor * diffColor.rgb;
-            gl_FragColor = vec4(GetFog(finalColor, vLightVec.w), diffColor.a);
+            gl_FragColor = vec4(GetFog(finalColor, fogFactor), diffColor.a);
         #else
-            gl_FragColor = vec4(GetLitFog(finalColor, vLightVec.w), diffColor.a);
+            gl_FragColor = vec4(GetLitFog(finalColor, fogFactor), diffColor.a);
         #endif
     #else
         // Ambient & per-vertex lighting
         vec3 finalColor = vVertexLight.rgb * diffColor.rgb;
-        gl_FragColor = vec4(GetFog(finalColor, vVertexLight.a), diffColor.a);
+        
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(vVertexLight.a, vWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(vVertexLight.a);
+        #endif
+
+        gl_FragColor = vec4(GetFog(finalColor, fogFactor), diffColor.a);
     #endif
 }

Bin/CoreData/Shaders/GLSL/LitParticle.vert

@@ -3,6 +3,9 @@
 #include "Lighting.vert"
 
 varying vec2 vTexCoord;
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 #ifdef VERTEXCOLOR
     varying vec4 vColor;
 #endif
@@ -24,6 +27,10 @@ void main()
     vec3 worldPos = GetWorldPos(modelMatrix);
     gl_Position = GetClipPos(worldPos);
     vTexCoord = GetTexCoord(iTexCoord);
+    
+    #ifdef HEIGHTFOG
+        vWorldPos = worldPos;
+    #endif
 
     #ifdef VERTEXCOLOR
         vColor = iColor;

Bin/CoreData/Shaders/GLSL/LitParticle.xml

@@ -1,6 +1,7 @@
 <shaders>
     <shader type="vs">
         <option name="VCol" define="VERTEXCOLOR" />
+        <option name="HeightFog" define="HEIGHTFOG" />
         <variation name="" define="AMBIENT" />
         <variation name="1VL" define="NUMVERTEXLIGHTS=1" />
         <variation name="2VL" define="NUMVERTEXLIGHTS=2" />
@@ -28,6 +29,7 @@
         <option name="Diff" define="DIFFMAP" />
         <option name="AlphaMask" define="ALPHAMASK" require="DIFFMAP" />
         <option name="VCol" define="VERTEXCOLOR" />
+        <option name="HeightFog" define="HEIGHTFOG" />
         <variation name="" define="AMBIENT" />
         <variation name="Dir">
             <define name="DIRLIGHT" />

Bin/CoreData/Shaders/GLSL/LitSolid.frag

@@ -4,6 +4,9 @@
 #include "Fog.frag"
 
 varying vec2 vTexCoord;
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 #ifdef PERPIXEL
     varying vec4 vLightVec;
     #ifdef SPECULAR
@@ -92,12 +95,18 @@ void main()
             finalColor = diff * lightColor * diffColor.rgb;
         #endif
 
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(vLightVec.w, vWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(vLightVec.w);
+        #endif
+
         #ifdef AMBIENT
             finalColor += cAmbientColor * diffColor.rgb;
             finalColor += cMatEmissiveColor;
-            gl_FragColor = vec4(GetFog(finalColor, vLightVec.w), diffColor.a);
+            gl_FragColor = vec4(GetFog(finalColor, fogFactor), diffColor.a);
         #else
-            gl_FragColor = vec4(GetLitFog(finalColor, vLightVec.w), diffColor.a);
+            gl_FragColor = vec4(GetLitFog(finalColor, fogFactor), diffColor.a);
         #endif
     #elif defined(PREPASS)
         // Fill light pre-pass G-Buffer
@@ -143,8 +152,14 @@ void main()
             finalColor += cMatEmissiveColor;
         #endif
 
-        gl_FragData[0] = vec4(GetFog(finalColor, vVertexLight.a), 1.0);
-        gl_FragData[1] = GetFogFactor(vVertexLight.a) * vec4(diffColor.rgb, specIntensity);
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(vVertexLight.a, vWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(vVertexLight.a);
+        #endif
+
+        gl_FragData[0] = vec4(GetFog(finalColor, fogFactor), 1.0);
+        gl_FragData[1] = fogFactor * vec4(diffColor.rgb, specIntensity);
         gl_FragData[2] = vec4(normal * 0.5 + 0.5, specPower);
         gl_FragData[3] = vec4(EncodeDepth(vVertexLight.a), 0.0);
 
@@ -185,6 +200,12 @@ void main()
             finalColor += cMatEmissiveColor;
         #endif
 
-        gl_FragColor = vec4(GetFog(finalColor, vVertexLight.a), diffColor.a);
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(vVertexLight.a, vWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(vVertexLight.a);
+        #endif
+
+        gl_FragColor = vec4(GetFog(finalColor, fogFactor), diffColor.a);
     #endif
 }

Bin/CoreData/Shaders/GLSL/LitSolid.vert

@@ -4,6 +4,9 @@
 #include "Lighting.vert"
 
 varying vec2 vTexCoord;
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 #ifdef PERPIXEL
     varying vec4 vLightVec;
     #ifdef SPECULAR
@@ -43,6 +46,10 @@ void main()
     vec3 worldPos = GetWorldPos(modelMatrix);
     gl_Position = GetClipPos(worldPos);
     vTexCoord = GetTexCoord(iTexCoord);
+    
+    #ifdef HEIGHTFOG
+        vWorldPos = worldPos;
+    #endif
 
     #if defined(PERPIXEL) && defined(NORMALMAP)
         vec3 vNormal;

Bin/CoreData/Shaders/GLSL/LitSolid.xml

@@ -4,6 +4,7 @@
         <option name="EnvCube" define="ENVCUBEMAP" />
         <option name="LightMap" define="LIGHTMAP" exclude="AO" />
         <option name="AO" define="AO" exclude="LightMap" />
+        <option name="HeightFog" define="HEIGHTFOG" />
         <variation name="" define="AMBIENT" />
         <variation name="1VL" define="NUMVERTEXLIGHTS=1" />
         <variation name="2VL" define="NUMVERTEXLIGHTS=2" />
@@ -40,6 +41,7 @@
         <variation name="Emissive" define="EMISSIVEMAP" />
         <option name="AlphaMask" define="ALPHAMASK" require="DIFFMAP" />
         <option name="Ambient" define="AMBIENT" require="PERPIXEL" />
+        <option name="HeightFog" define="HEIGHTFOG" />
         <variation name="" define="AMBIENT" />
         <variation name="Dir">
             <exclude name="EnvCube" />

Bin/CoreData/Shaders/GLSL/PostProcess.frag

@@ -0,0 +1,86 @@
+
+const float PI = 3.14159265;
+
+vec2 Noise(vec2 coord)
+{
+    float noiseX = clamp(fract(sin(dot(coord, vec2(12.9898, 78.233))) * 43758.5453), 0.0, 1.0);
+    float noiseY = clamp(fract(sin(dot(coord, vec2(12.9898, 78.233) * 2.0)) * 43758.5453), 0.0, 1.0);
+    return vec2(noiseX, noiseY);
+}
+
+// Adapted: http://callumhay.blogspot.com/2010/09/gaussian-blur-shader-glsl.html
+vec4 GaussianBlur(int blurKernelSize, vec2 blurDir, vec2 blurRadius, float sigma, sampler2D texSampler, vec2 texCoord)
+{
+    const int blurKernelSizeHalfSize = blurKernelSize / 2;
+
+    // Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
+    vec3 gaussCoeff;
+    gaussCoeff.x = 1.0 / (sqrt(2.0 * PI) * sigma);
+    gaussCoeff.y = exp(-0.5 / (sigma * sigma));
+    gaussCoeff.z = gaussCoeff.y * gaussCoeff.y;
+
+    vec2 blurVec = blurRadius * blurDir;
+    vec4 avgValue = vec4(0.0);
+    float gaussCoeffSum = 0.0;
+
+    avgValue += texture2D(texSampler, texCoord) * gaussCoeff.x;
+    gaussCoeffSum += gaussCoeff.x;
+    gaussCoeff.xy *= gaussCoeff.yz;
+
+    for (int i = 1; i <= blurKernelSizeHalfSize; i++)
+    {
+        avgValue += texture2D(texSampler, texCoord - i * blurVec) * gaussCoeff.x;
+        avgValue += texture2D(texSampler, texCoord + i * blurVec) * gaussCoeff.x;
+
+        gaussCoeffSum += 2.0 * gaussCoeff.x;
+        gaussCoeff.xy *= gaussCoeff.yz;
+    }
+
+    return avgValue / gaussCoeffSum;
+}
+
+const vec3 LumWeights = vec3(0.2126, 0.7152, 0.0722);
+
+vec3 ReinhardEq3Tonemap(vec3 x)
+{
+    return x / (1.0 + x);
+}
+
+vec3 ReinhardEq4Tonemap(vec3 x, float white)
+{
+    return x * (1.0 + x / white) / (1.0 + x);
+}
+
+// Unchared2 tone mapping (See http://filmicgames.com)
+const float A = 0.15;
+const float B = 0.50;
+const float C = 0.10;
+const float D = 0.20;
+const float E = 0.02;
+const float F = 0.30;
+
+vec3 Uncharted2Tonemap(vec3 x)
+{
+   return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;
+}
+
+vec3 ColorCorrection(vec3 color, sampler3D lut)
+{
+    float lutSize = 16.0;
+    float scale = (lutSize - 1.0) / lutSize;
+    float offset = 1.0 / (2.0 * lutSize);
+    return texture3D(lut, clamp(color, 0.0, 1.0) * scale + offset).rgb;
+}
+
+const float Gamma = 2.2;
+const float InverseGamma = 1.0 / 2.2;
+
+vec3 ToGamma(vec3 color)
+{
+    return vec3(pow(color.r, Gamma), pow(color.g, Gamma), pow(color.b, Gamma));
+}
+
+vec3 ToInverseGamma(vec3 color)
+{
+    return vec3(pow(color.r, InverseGamma), pow(color.g, InverseGamma), pow(color.b, InverseGamma));
+}

Bin/CoreData/Shaders/GLSL/Samplers.frag

@@ -8,6 +8,7 @@ uniform samplerCube sEnvCubeMap;
 uniform sampler2D sLightRampMap;
 uniform sampler2D sLightSpotMap;
 uniform samplerCube sLightCubeMap;
+uniform sampler3D sVolumeMap;
 #ifndef GL_ES
 uniform sampler2D sAlbedoBuffer;
 uniform sampler2D sNormalBuffer;

Bin/CoreData/Shaders/GLSL/TerrainBlend.frag

@@ -4,6 +4,9 @@
 #include "Fog.frag"
 
 varying vec2 vTexCoord;
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 #ifdef PERPIXEL
     varying vec4 vLightVec;
     #ifdef SPECULAR
@@ -75,11 +78,17 @@ void main()
             finalColor = diff * lightColor * diffColor.rgb;
         #endif
 
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(vLightVec.w, vWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(vLightVec.w);
+        #endif
+
         #ifdef AMBIENT
             finalColor += cAmbientColor * diffColor.rgb;
-            gl_FragColor = vec4(GetFog(finalColor, vLightVec.w), diffColor.a);
+            gl_FragColor = vec4(GetFog(finalColor, fogFactor), diffColor.a);
         #else
-            gl_FragColor = vec4(GetLitFog(finalColor, vLightVec.w), diffColor.a);
+            gl_FragColor = vec4(GetLitFog(finalColor, fogFactor), diffColor.a);
         #endif
     #elif defined(PREPASS)
         // Fill light pre-pass G-Buffer
@@ -96,8 +105,14 @@ void main()
         float specIntensity = specColor.g;
         float specPower = cMatSpecColor.a / 255.0;
 
-        gl_FragData[0] = vec4(GetFog(vVertexLight.rgb * diffColor.rgb, vVertexLight.a), 1.0);
-        gl_FragData[1] = GetFogFactor(vVertexLight.a) * vec4(diffColor.rgb, specIntensity);
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(vVertexLight.a, vWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(vVertexLight.a);
+        #endif
+
+        gl_FragData[0] = vec4(GetFog(vVertexLight.rgb * diffColor.rgb, fogFactor), 1.0);
+        gl_FragData[1] = fogFactor * vec4(diffColor.rgb, specIntensity);
         gl_FragData[2] = vec4(normal * 0.5 + 0.5, specPower);
         gl_FragData[3] = vec4(EncodeDepth(vVertexLight.a), 0.0);
     #else
@@ -113,6 +128,12 @@ void main()
             finalColor += lightInput.rgb * diffColor.rgb + lightSpecColor * specColor;
         #endif
 
-        gl_FragColor = vec4(GetFog(finalColor, vVertexLight.a), diffColor.a);
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(vVertexLight.a, vWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(vVertexLight.a);
+        #endif
+
+        gl_FragColor = vec4(GetFog(finalColor, fogFactor), diffColor.a);
     #endif
 }

Bin/CoreData/Shaders/GLSL/TerrainBlend.vert

@@ -4,6 +4,9 @@
 #include "Lighting.vert"
 
 varying vec2 vTexCoord;
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 #ifdef PERPIXEL
     varying vec4 vLightVec;
     #ifdef SPECULAR
@@ -33,6 +36,10 @@ void main()
     vTexCoord = GetTexCoord(iTexCoord);
     vNormal = GetWorldNormal(modelMatrix);
 
+    #ifdef HEIGHTFOG
+        vWorldPos = worldPos;
+    #endif
+
     #ifdef PERPIXEL
         // Per-pixel forward lighting
         vec4 projWorldPos = vec4(worldPos, 1.0);

Bin/CoreData/Shaders/GLSL/TerrainBlend.xml

@@ -1,5 +1,6 @@
 <shaders>
     <shader type="vs">
+        <option name="HeightFog" define="HEIGHTFOG" />
         <variation name="" define="AMBIENT" />
         <variation name="1VL" define="NUMVERTEXLIGHTS=1" />
         <variation name="2VL" define="NUMVERTEXLIGHTS=2" />
@@ -24,6 +25,7 @@
     </shader>
     <shader type="ps">
         <option name="Ambient" define="AMBIENT" require="PERPIXEL" />
+        <option name="HeightFog" define="HEIGHTFOG" />
         <variation name="" define="AMBIENT" />
         <variation name="Dir">
             <define name="DIRLIGHT" />

Bin/CoreData/Shaders/GLSL/Tonemap.frag

@@ -0,0 +1,27 @@
+#include "Uniforms.frag"
+#include "Samplers.frag"
+#include "PostProcess.frag"
+
+uniform float cTonemapExposureBias;
+uniform float cTonemapMaxWhite;
+
+varying vec2 vScreenPos;
+
+void main()
+{
+    #ifdef REINHARDEQ3
+    vec3 color = ReinhardEq3Tonemap(max(texture2D(sDiffMap, vScreenPos).rgb * cTonemapExposureBias, 0.0));
+    gl_FragColor = vec4(color, 1.0);
+    #endif
+
+    #ifdef REINHARDEQ4
+    vec3 color = ReinhardEq4Tonemap(max(texture2D(sDiffMap, vScreenPos).rgb * cTonemapExposureBias, 0.0), cTonemapMaxWhite);
+    gl_FragColor = vec4(color, 1.0);
+    #endif
+
+    #ifdef UNCHARTED2
+    vec3 color = Uncharted2Tonemap(max(texture2D(sDiffMap, vScreenPos).rgb * cTonemapExposureBias, 0.0)) / 
+        Uncharted2Tonemap(vec3(cTonemapMaxWhite, cTonemapMaxWhite, cTonemapMaxWhite));
+    gl_FragColor = vec4(color, 1.0);
+    #endif
+}

Bin/CoreData/Shaders/GLSL/Tonemap.vert

@@ -0,0 +1,13 @@
+#include "Uniforms.vert"
+#include "Transform.vert"
+#include "ScreenPos.vert"
+
+varying vec2 vScreenPos;
+
+void main()
+{
+    mat4 modelMatrix = iModelMatrix;
+    vec3 worldPos = GetWorldPos(modelMatrix);
+    gl_Position = GetClipPos(worldPos);
+    vScreenPos = GetScreenPosPreDiv(gl_Position);
+}

Bin/CoreData/Shaders/GLSL/Tonemap.xml

@@ -0,0 +1,8 @@
+<shaders>
+    <shader type="vs" />
+    <shader type="ps">
+        <variation name="ReinhardEq3" define="REINHARDEQ3" />
+        <variation name="ReinhardEq4" define="REINHARDEQ4" />
+        <variation name="Uncharted2" define="UNCHARTED2" />
+    </shader>
+</shaders>

Bin/CoreData/Shaders/GLSL/Uniforms.frag

@@ -3,8 +3,9 @@
 #endif
 
 uniform vec3 cAmbientColor;
+uniform float cDeltaTimePS;
 uniform float cElapsedTimePS;
-uniform vec2 cFogParams;
+uniform vec4 cFogParams;
 uniform vec3 cFogColor;
 uniform vec2 cGBufferInvSize;
 uniform vec4 cLightColor;
@@ -14,6 +15,8 @@ uniform vec4 cMatDiffColor;
 uniform vec3 cMatEmissiveColor;
 uniform vec3 cMatEnvMapColor;
 uniform vec4 cMatSpecColor;
+uniform float cNearClipPS;
+uniform float cFarClipPS;
 uniform vec4 cShadowCubeAdjust;
 uniform vec4 cShadowDepthFade;
 uniform vec2 cShadowIntensity;

Bin/CoreData/Shaders/GLSL/Uniforms.vert

@@ -3,8 +3,11 @@ uniform vec3 cAmbientEndColor;
 uniform mat3 cBillboardRot;
 uniform vec3 cCameraPos;
 uniform mat3 cCameraRot;
+uniform float cNearClip;
+uniform float cFarClip;
 uniform vec4 cDepthMode;
 uniform vec3 cFrustumSize;
+uniform float cDeltaTime;
 uniform float cElapsedTime;
 uniform vec4 cGBufferOffsets;
 uniform vec3 cLightDir;

Bin/CoreData/Shaders/GLSL/Unlit.frag

@@ -6,6 +6,9 @@ varying vec2 vTexCoord;
 #ifdef VERTEXCOLOR
     varying vec4 vColor;
 #endif
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 varying float vDepth;
 
 void main()
@@ -24,6 +27,12 @@ void main()
         diffColor *= vColor;
     #endif
 
-    gl_FragColor = vec4(GetFog(diffColor.rgb, vDepth), diffColor.a);
+    #ifdef HEIGHTFOG
+        float fogFactor = GetHeightFogFactor(vDepth, vWorldPos.y);
+    #else
+        float fogFactor = GetFogFactor(vDepth);
+    #endif
+
+    gl_FragColor = vec4(GetFog(diffColor.rgb, fogFactor), diffColor.a);
 }
 

Bin/CoreData/Shaders/GLSL/Unlit.vert

@@ -5,6 +5,9 @@ varying vec2 vTexCoord;
 #ifdef VERTEXCOLOR
     varying vec4 vColor;
 #endif
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 varying float vDepth;
 
 void main()
@@ -15,6 +18,10 @@ void main()
     vTexCoord = GetTexCoord(iTexCoord);
     vDepth = GetDepth(gl_Position);
 
+    #ifdef HEIGHTFOG
+        vWorldPos = worldPos;
+    #endif
+
     #ifdef VERTEXCOLOR
         vColor = iColor;
     #endif

Bin/CoreData/Shaders/GLSL/Unlit.xml

@@ -1,6 +1,7 @@
 <shaders>
     <shader type="vs">
         <option name="VCol" define="VERTEXCOLOR" />
+        <option name="HeightFog" define="HEIGHTFOG" />
         <variation name="" />
         <variation name="Skinned" define="SKINNED" />
         <variation name="Instanced" define="INSTANCED" />
@@ -10,5 +11,6 @@
         <option name="Diff" define="DIFFMAP" />
         <option name="VCol" define="VERTEXCOLOR" />
         <option name="AlphaMask" define="ALPHAMASK" require="DIFFMAP" />
+        <option name="HeightFog" define="HEIGHTFOG" />
     </shader>
 </shaders>

Bin/CoreData/Shaders/GLSL/Vegetation.vert

@@ -9,6 +9,9 @@ uniform float cWindPeriod;
 uniform vec2 cWindWorldSpacing;
 
 varying vec2 vTexCoord;
+#ifdef HEIGHTFOG
+    varying vec3 vWorldPos;
+#endif
 #ifdef PERPIXEL
     varying vec4 vLightVec;
     #ifdef SPECULAR
@@ -50,6 +53,10 @@ void main()
     gl_Position = GetClipPos(worldPos);
     vTexCoord = GetTexCoord(iTexCoord);
 
+    #ifdef HEIGHTFOG
+        vWorldPos = worldPos;
+    #endif
+
     #if defined(PERPIXEL) && defined(NORMALMAP)
         vec3 vNormal;
         vec3 vTangent;

Bin/CoreData/Shaders/GLSL/Vegetation.xml

@@ -1,6 +1,7 @@
 <shaders>
     <shader type="vs">
         <option name="Normal" define="NORMALMAP" />
+        <option name="HeightFog" define="HEIGHTFOG" />
         <variation name="" define="AMBIENT" />
         <variation name="1VL" define="NUMVERTEXLIGHTS=1" />
         <variation name="2VL" define="NUMVERTEXLIGHTS=2" />

Bin/CoreData/Shaders/HLSL/AutoExposure.hlsl

@@ -0,0 +1,95 @@
+#include "Uniforms.hlsl"
+#include "Transform.hlsl"
+#include "Samplers.hlsl"
+#include "ScreenPos.hlsl"
+#include "PostProcess.hlsl"
+
+uniform float cAutoExposureAdaptRate;
+uniform float cAutoExposureMiddleGrey;
+uniform float cAutoExposureSensitivity;
+uniform float2 cHDR128Offsets;
+uniform float2 cLum64Offsets;
+uniform float2 cLum16Offsets;
+uniform float2 cLum4Offsets;
+uniform float2 cHDR128InvSize;
+uniform float2 cLum64InvSize;
+uniform float2 cLum16InvSize;
+uniform float2 cLum4InvSize;
+
+float GatherAvgLum(sampler2D texSampler, float2 texCoord, float2 texelSize)
+{
+    float lumAvg = 0.0;
+    lumAvg += tex2D(texSampler, texCoord + float2(0.0, 0.0) * texelSize).r;
+    lumAvg += tex2D(texSampler, texCoord + float2(0.0, 2.0) * texelSize).r;
+    lumAvg += tex2D(texSampler, texCoord + float2(2.0, 2.0) * texelSize).r;
+    lumAvg += tex2D(texSampler, texCoord + float2(2.0, 0.0) * texelSize).r;
+    return lumAvg / 4.0;
+}
+
+void VS(float4 iPos : POSITION,
+    out float4 oPos : POSITION,
+    out float2 oTexCoord : TEXCOORD0,
+    out float2 oScreenPos : TEXCOORD1)
+{
+    float4x3 modelMatrix = iModelMatrix;
+    float3 worldPos = GetWorldPos(modelMatrix);
+    oPos = GetClipPos(worldPos);
+
+    oTexCoord = GetQuadTexCoord(oPos);
+
+    #ifdef LUMINANCE64
+    oTexCoord = GetQuadTexCoord(oPos) + cHDR128Offsets;
+    #endif
+
+    #ifdef LUMINANCE16
+    oTexCoord = GetQuadTexCoord(oPos) + cLum64Offsets;
+    #endif
+
+    #ifdef LUMINANCE4
+    oTexCoord = GetQuadTexCoord(oPos) + cLum16Offsets;
+    #endif
+
+    #ifdef LUMINANCE1
+    oTexCoord = GetQuadTexCoord(oPos) + cLum4Offsets;
+    #endif
+
+    oScreenPos = GetScreenPosPreDiv(oPos);
+}
+
+void PS(float2 iTexCoord : TEXCOORD0,
+    float2 iScreenPos : TEXCOORD1,
+    out float4 oColor : COLOR0)
+{
+    #ifdef LUMINANCE64
+    float logLumSum = 1e-5;
+    logLumSum += log(dot(tex2D(sDiffMap, iTexCoord + float2(0.0, 0.0) * cHDR128InvSize).rgb, LumWeights));
+    logLumSum += log(dot(tex2D(sDiffMap, iTexCoord + float2(0.0, 2.0) * cHDR128InvSize).rgb, LumWeights));
+    logLumSum += log(dot(tex2D(sDiffMap, iTexCoord + float2(2.0, 2.0) * cHDR128InvSize).rgb, LumWeights));
+    logLumSum += log(dot(tex2D(sDiffMap, iTexCoord + float2(2.0, 0.0) * cHDR128InvSize).rgb, LumWeights));
+    oColor = logLumSum;
+    #endif
+
+    #ifdef LUMINANCE16
+    oColor = exp(GatherAvgLum(sDiffMap, iTexCoord, cLum64InvSize) / 16.0);
+    #endif
+
+    #ifdef LUMINANCE4
+    oColor = GatherAvgLum(sDiffMap, iTexCoord, cLum16InvSize);
+    #endif
+
+    #ifdef LUMINANCE1
+    oColor = GatherAvgLum(sDiffMap, iTexCoord, cLum4InvSize);
+    #endif
+
+    #ifdef ADAPTLUMINANCE
+    float adaptedLum = tex2D(sDiffMap, iTexCoord).r;
+    float lum = tex2D(sNormalMap, iTexCoord).r;
+    oColor = adaptedLum + (lum - adaptedLum) * (1.0 - exp(-cDeltaTimePS * cAutoExposureAdaptRate));
+    #endif
+
+    #ifdef EXPOSE
+    float3 color = tex2D(sDiffMap, iScreenPos).rgb;
+    float adaptedLum = max(lerp(cAutoExposureMiddleGrey, tex2D(sNormalMap, iTexCoord).r, cAutoExposureSensitivity), 1e-5);
+    oColor = float4(color * (cAutoExposureMiddleGrey / adaptedLum), 1.0);
+    #endif
+}

Bin/CoreData/Shaders/HLSL/AutoExposure.xml

@@ -0,0 +1,18 @@
+<shaders>
+    <shader type="vs">
+        <variation name="Luminance64" define="LUMINANCE64" />
+        <variation name="Luminance16" define="LUMINANCE16" />
+        <variation name="Luminance4" define="LUMINANCE4" />
+        <variation name="Luminance1" define="LUMINANCE1" />
+        <variation name="AdaptLuminance" define="ADAPTLUMINANCE" />
+        <variation name="Expose" define="EXPOSE" />
+    </shader>
+    <shader type="ps">
+        <variation name="Luminance64" define="LUMINANCE64" />
+        <variation name="Luminance16" define="LUMINANCE16" />
+        <variation name="Luminance4" define="LUMINANCE4" />
+        <variation name="Luminance1" define="LUMINANCE1" />
+        <variation name="AdaptLuminance" define="ADAPTLUMINANCE" />
+        <variation name="Expose" define="EXPOSE" />
+    </shader>
+</shaders>

Bin/CoreData/Shaders/HLSL/BloomHDR.hlsl

@@ -0,0 +1,111 @@
+#include "Uniforms.hlsl"
+#include "Transform.hlsl"
+#include "Samplers.hlsl"
+#include "ScreenPos.hlsl"
+#include "PostProcess.hlsl"
+
+uniform float cBloomHDRThreshold;
+uniform float2 cBloomHDRBlurDir;
+uniform float cBloomHDRBlurRadius;
+uniform float cBloomHDRBlurSigma;
+uniform float2 cBloomHDRMix;
+uniform float2 cBright2Offsets;
+uniform float2 cBright4Offsets;
+uniform float2 cBright8Offsets;
+uniform float2 cBright16Offsets;
+uniform float2 cBright2InvSize;
+uniform float2 cBright4InvSize;
+uniform float2 cBright8InvSize;
+uniform float2 cBright16InvSize;
+
+static const int BlurKernelSize = 5;
+
+void VS(float4 iPos : POSITION,
+    out float4 oPos : POSITION,
+    out float2 oTexCoord : TEXCOORD0,
+    out float2 oScreenPos : TEXCOORD1)
+{
+    float4x3 modelMatrix = iModelMatrix;
+    float3 worldPos = GetWorldPos(modelMatrix);
+    oPos = GetClipPos(worldPos);
+
+    oTexCoord = GetQuadTexCoord(oPos);
+
+    #ifdef BLUR2
+    oTexCoord = GetQuadTexCoord(oPos) + cBright2Offsets;
+    #endif
+
+    #ifdef BLUR4
+    oTexCoord = GetQuadTexCoord(oPos) + cBright4Offsets;
+    #endif
+
+    #ifdef BLUR8
+    oTexCoord = GetQuadTexCoord(oPos) + cBright8Offsets;
+    #endif
+
+    #ifdef BLUR16
+    oTexCoord = GetQuadTexCoord(oPos) + cBright16Offsets;
+    #endif
+
+    #ifdef COMBINE2
+    oTexCoord = GetQuadTexCoord(oPos) + cBright2Offsets;
+    #endif
+
+    #ifdef COMBINE4
+    oTexCoord = GetQuadTexCoord(oPos) + cBright4Offsets;
+    #endif
+
+    #ifdef COMBINE8
+    oTexCoord = GetQuadTexCoord(oPos) + cBright8Offsets;
+    #endif
+
+    #ifdef COMBINE16
+    oTexCoord = GetQuadTexCoord(oPos) + cBright16Offsets;
+    #endif
+
+    oScreenPos = GetScreenPosPreDiv(oPos);
+}
+
+void PS(float2 iTexCoord : TEXCOORD0,
+    float2 iScreenPos : TEXCOORD1,
+    out float4 oColor : COLOR0)
+{
+    #ifdef BRIGHT
+    float3 color = tex2D(sDiffMap, iScreenPos).rgb;
+    oColor = float4(max(color - cBloomHDRThreshold, 0.0), 1.0);
+    #endif
+
+    #ifdef BLUR16
+    oColor = GaussianBlur(BlurKernelSize, cBloomHDRBlurDir, cBright16InvSize * cBloomHDRBlurRadius, cBloomHDRBlurSigma, sDiffMap, iTexCoord);
+    #endif
+
+    #ifdef BLUR8
+    oColor = GaussianBlur(BlurKernelSize, cBloomHDRBlurDir, cBright8InvSize * cBloomHDRBlurRadius, cBloomHDRBlurSigma, sDiffMap, iTexCoord);
+    #endif
+
+    #ifdef BLUR4
+    oColor = GaussianBlur(BlurKernelSize, cBloomHDRBlurDir, cBright4InvSize * cBloomHDRBlurRadius, cBloomHDRBlurSigma, sDiffMap, iTexCoord);
+    #endif
+
+    #ifdef BLUR2
+    oColor = GaussianBlur(BlurKernelSize, cBloomHDRBlurDir, cBright2InvSize * cBloomHDRBlurRadius, cBloomHDRBlurSigma, sDiffMap, iTexCoord);
+    #endif
+
+    #ifdef COMBINE16
+    oColor = tex2D(sDiffMap, iScreenPos) + tex2D(sNormalMap, iTexCoord);
+    #endif
+
+    #ifdef COMBINE8
+    oColor = tex2D(sDiffMap, iScreenPos) + tex2D(sNormalMap, iTexCoord);
+    #endif
+
+    #ifdef COMBINE4
+    oColor = tex2D(sDiffMap, iScreenPos) + tex2D(sNormalMap, iTexCoord);
+    #endif
+
+    #ifdef COMBINE2
+    float3 color = tex2D(sDiffMap, iScreenPos).rgb * cBloomHDRMix.x;
+    float3 bloom = tex2D(sNormalMap, iTexCoord).rgb * cBloomHDRMix.y;
+    oColor = float4(color + bloom, 1.0);
+    #endif
+}

Bin/CoreData/Shaders/HLSL/BloomHDR.xml

@@ -0,0 +1,24 @@
+<shaders>
+    <shader type="vs">
+        <variation name="Bright" define="BRIGHT" />
+        <variation name="Blur2" define="BLUR2" />
+        <variation name="Blur4" define="BLUR4" />
+        <variation name="Blur8" define="BLUR8" />
+        <variation name="Blur16" define="BLUR16" />
+        <variation name="Combine2" define="COMBINE2" />
+        <variation name="Combine4" define="COMBINE4" />
+        <variation name="Combine8" define="COMBINE8" />
+        <variation name="Combine16" define="COMBINE16" />
+    </shader>
+    <shader type="ps">
+        <variation name="Bright" define="BRIGHT" />
+        <variation name="Blur2" define="BLUR2" />
+        <variation name="Blur4" define="BLUR4" />
+        <variation name="Blur8" define="BLUR8" />
+        <variation name="Blur16" define="BLUR16" />
+        <variation name="Combine2" define="COMBINE2" />
+        <variation name="Combine4" define="COMBINE4" />
+        <variation name="Combine8" define="COMBINE8" />
+        <variation name="Combine16" define="COMBINE16" />
+    </shader>
+</shaders>

Bin/CoreData/Shaders/HLSL/Blur.hlsl

@@ -0,0 +1,44 @@
+#include "Uniforms.hlsl"
+#include "Transform.hlsl"
+#include "Samplers.hlsl"
+#include "ScreenPos.hlsl"
+#include "PostProcess.hlsl"
+
+uniform float2 cBlurDir;
+uniform float cBlurRadius;
+uniform float cBlurSigma;
+uniform float2 cBlurHOffsets;
+uniform float2 cBlurHInvSize;
+
+void VS(float4 iPos : POSITION,
+    out float4 oPos : POSITION,
+    out float2 oTexCoord : TEXCOORD0,
+    out float2 oScreenPos : TEXCOORD1)
+{
+    float4x3 modelMatrix = iModelMatrix;
+    float3 worldPos = GetWorldPos(modelMatrix);
+    oPos = GetClipPos(worldPos);
+    oTexCoord = GetQuadTexCoord(oPos) + cBlurHOffsets;
+    oScreenPos = GetScreenPosPreDiv(oPos);
+}
+
+void PS(float2 iTexCoord : TEXCOORD0,
+    float2 iScreenPos : TEXCOORD1,
+    out float4 oColor : COLOR0)
+{
+    #ifdef BLUR3
+        oColor = GaussianBlur(3, cBlurDir, cBlurHInvSize * cBlurRadius, cBlurSigma, sDiffMap, iTexCoord);
+    #endif
+
+    #ifdef BLUR5
+        oColor = GaussianBlur(5, cBlurDir, cBlurHInvSize * cBlurRadius, cBlurSigma, sDiffMap, iTexCoord);
+    #endif
+
+    #ifdef BLUR7
+        oColor = GaussianBlur(7, cBlurDir, cBlurHInvSize * cBlurRadius, cBlurSigma, sDiffMap, iTexCoord);
+    #endif
+
+    #ifdef BLUR9
+        oColor = GaussianBlur(9, cBlurDir, cBlurHInvSize * cBlurRadius, cBlurSigma, sDiffMap, iTexCoord);
+    #endif
+}

Bin/CoreData/Shaders/HLSL/Blur.xml

@@ -0,0 +1,9 @@
+<shaders>
+    <shader type="vs" />
+    <shader type="ps">
+    	<variation name="Blur3" define="BLUR3" />
+        <variation name="Blur5" define="BLUR5" />
+        <variation name="Blur7" define="BLUR7" />
+        <variation name="Blur9" define="BLUR9" />
+    </shader>
+</shaders>

Bin/CoreData/Shaders/HLSL/ColorCorrection.hlsl

@@ -0,0 +1,22 @@
+#include "Uniforms.hlsl"
+#include "Transform.hlsl"
+#include "Samplers.hlsl"
+#include "ScreenPos.hlsl"
+#include "PostProcess.hlsl"
+
+void VS(float4 iPos : POSITION,
+    out float4 oPos : POSITION,
+    out float2 oScreenPos : TEXCOORD0)
+{
+    float4x3 modelMatrix = iModelMatrix;
+    float3 worldPos = GetWorldPos(modelMatrix);
+    oPos = GetClipPos(worldPos);
+    oScreenPos = GetScreenPosPreDiv(oPos);
+}
+
+void PS(float2 iScreenPos : TEXCOORD0,
+    out float4 oColor : COLOR0)
+{
+    float3 color = tex2D(sDiffMap, iScreenPos).rgb;
+    oColor = float4(ColorCorrection(color, sVolumeMap), 1.0);
+}

Bin/CoreData/Shaders/HLSL/ColorCorrection.xml

@@ -0,0 +1,3 @@
+<shaders>
+    <shader />
+</shaders>

Bin/CoreData/Shaders/HLSL/Fog.hlsl

@@ -1,14 +1,22 @@
-float3 GetFog(float3 color, float depth)
+float3 GetFog(float3 color, float fogFactor)
 {
-    return lerp(cFogColor, color, saturate((cFogParams.x - depth) * cFogParams.y));
+    return lerp(cFogColor, color, fogFactor);
 }
 
-float3 GetLitFog(float3 color, float depth)
+float3 GetLitFog(float3 color, float fogFactor)
 {
-    return color * saturate((cFogParams.x - depth) * cFogParams.y);
+    return color * fogFactor;
 }
 
 float GetFogFactor(float depth)
 {
     return saturate((cFogParams.x - depth) * cFogParams.y);
 }
+
+float GetHeightFogFactor(float depth, float height)
+{
+    float fogFactor = GetFogFactor(depth);
+    float heightFogFactor = (height - cFogParams.z) * cFogParams.w;
+    heightFogFactor = 1.0 - saturate(exp(-(heightFogFactor * heightFogFactor)));
+	return min(heightFogFactor, fogFactor);
+}

Bin/CoreData/Shaders/HLSL/GammaCorrection.hlsl

@@ -0,0 +1,22 @@
+#include "Uniforms.hlsl"
+#include "Transform.hlsl"
+#include "Samplers.hlsl"
+#include "ScreenPos.hlsl"
+#include "PostProcess.hlsl"
+
+void VS(float4 iPos : POSITION,
+    out float4 oPos : POSITION,
+    out float2 oScreenPos : TEXCOORD0)
+{
+    float4x3 modelMatrix = iModelMatrix;
+    float3 worldPos = GetWorldPos(modelMatrix);
+    oPos = GetClipPos(worldPos);
+    oScreenPos = GetScreenPosPreDiv(oPos);
+}
+
+void PS(float2 iScreenPos : TEXCOORD0,
+    out float4 oColor : COLOR0)
+{
+    float3 color = tex2D(sDiffMap, iScreenPos).rgb;
+    oColor = float4(ToInverseGamma(color), 1.0);
+}

Bin/CoreData/Shaders/HLSL/GammaCorrection.xml

@@ -0,0 +1,3 @@
+<shaders>
+    <shader />
+</shaders>

Bin/CoreData/Shaders/HLSL/LitParticle.hlsl

@@ -21,6 +21,9 @@ void VS(float4 iPos : POSITION,
         float2 iSize : TEXCOORD1,
     #endif
     out float2 oTexCoord : TEXCOORD0,
+    #ifdef HEIGHTFOG
+        out float3 oWorldPos : TEXCOORD8,
+    #endif
     #if PERPIXEL
         out float4 oLightVec : TEXCOORD1,
         #ifdef SPOTLIGHT
@@ -42,6 +45,10 @@ void VS(float4 iPos : POSITION,
     oPos = GetClipPos(worldPos);
     oTexCoord = GetTexCoord(iTexCoord);
 
+    #ifdef HEIGHTFOG
+        oWorldPos = worldPos;
+    #endif
+
     #ifdef VERTEXCOLOR
         oColor = iColor;
     #endif
@@ -76,6 +83,9 @@ void VS(float4 iPos : POSITION,
 }
 
 void PS(float2 iTexCoord : TEXCOORD0,
+    #ifdef HEIGHTFOG
+        float3 iWorldPos : TEXCOORD8,
+    #endif
     #ifdef PERPIXEL
         float4 iLightVec : TEXCOORD1,
         #ifdef SPOTLIGHT
@@ -123,12 +133,25 @@ void PS(float2 iTexCoord : TEXCOORD0,
         #else
             lightColor = cLightColor.rgb;
         #endif
+
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iLightVec.w, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iLightVec.w);
+        #endif
     
         finalColor = diff * lightColor * diffColor.rgb;
-        oColor = float4(GetLitFog(finalColor, iLightVec.w), diffColor.a);
+        oColor = float4(GetLitFog(finalColor, fogFactor), diffColor.a);
     #else
         // Ambient & per-vertex lighting
         float3 finalColor = iVertexLight.rgb * diffColor.rgb;
-        oColor = float4(GetFog(finalColor, iVertexLight.a), diffColor.a);
+        
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iVertexLight.a, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iVertexLight.a);
+        #endif
+
+        oColor = float4(GetFog(finalColor, fogFactor), diffColor.a);
     #endif
 }

Bin/CoreData/Shaders/HLSL/LitParticle.xml

@@ -1,6 +1,7 @@
 <shaders>
     <shader type="vs">
         <option name="VCol" define="VERTEXCOLOR" />
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
         <variation name="" define="AMBIENT" />
         <variation name="1VL" define="NUMVERTEXLIGHTS=1" />
         <variation name="2VL" define="NUMVERTEXLIGHTS=2" />
@@ -28,6 +29,7 @@
         <option name="Diff" define="DIFFMAP" />
         <option name="AlphaMask" define="ALPHAMASK" require="DIFFMAP" />
         <option name="VCol" define="VERTEXCOLOR" />
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
         <variation name="" define="AMBIENT" />
         <variation name="Dir">
             <define name="DIRLIGHT" />

Bin/CoreData/Shaders/HLSL/LitSolid.hlsl

@@ -30,6 +30,9 @@ void VS(float4 iPos : POSITION,
         float2 iSize : TEXCOORD1,
     #endif
     out float2 oTexCoord : TEXCOORD0,
+    #ifdef HEIGHTFOG
+        out float3 oWorldPos : TEXCOORD8,
+    #endif
     #ifdef PERPIXEL
         out float4 oLightVec : TEXCOORD1,
         #ifndef NORMALMAP
@@ -69,6 +72,10 @@ void VS(float4 iPos : POSITION,
     oPos = GetClipPos(worldPos);
     oTexCoord = GetTexCoord(iTexCoord);
 
+    #ifdef HEIGHTFOG
+        oWorldPos = worldPos;
+    #endif
+
     #if defined(PERPIXEL) && defined(NORMALMAP)
         float3 oNormal;
         float3 oTangent;
@@ -139,6 +146,9 @@ void VS(float4 iPos : POSITION,
 }
 
 void PS(float2 iTexCoord : TEXCOORD0,
+    #ifdef HEIGHTFOG
+        float3 iWorldPos : TEXCOORD8,
+    #endif
     #ifdef PERPIXEL
         float4 iLightVec : TEXCOORD1,
         #ifndef NORMALMAP
@@ -233,13 +243,19 @@ void PS(float2 iTexCoord : TEXCOORD0,
         #else
             finalColor = diff * lightColor * diffColor.rgb;
         #endif
+
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iLightVec.w, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iLightVec.w);
+        #endif
     
         #ifdef AMBIENT
             finalColor += cAmbientColor * diffColor.rgb;
             finalColor += cMatEmissiveColor;
-            oColor = float4(GetFog(finalColor, iLightVec.w), diffColor.a);
+            oColor = float4(GetFog(finalColor, fogFactor), diffColor.a);
         #else
-            oColor = float4(GetLitFog(finalColor, iLightVec.w), diffColor.a);
+            oColor = float4(GetLitFog(finalColor, fogFactor), diffColor.a);
         #endif
     #elif defined(PREPASS)
         // Fill light pre-pass G-Buffer
@@ -288,8 +304,14 @@ void PS(float2 iTexCoord : TEXCOORD0,
             finalColor += cMatEmissiveColor;
         #endif
 
-        oColor = float4(GetFog(finalColor, iVertexLight.a), 1.0);
-        oAlbedo = GetFogFactor(iVertexLight.a) * float4(diffColor.rgb, specIntensity);
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iVertexLight.a, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iVertexLight.a);
+        #endif
+
+        oColor = float4(GetFog(finalColor, fogFactor), 1.0);
+        oAlbedo = fogFactor * float4(diffColor.rgb, specIntensity);
         oNormal = float4(normal * 0.5 + 0.5, specPower);
         oDepth = iVertexLight.a;
     #else
@@ -328,6 +350,12 @@ void PS(float2 iTexCoord : TEXCOORD0,
             finalColor += cMatEmissiveColor;
         #endif
 
-        oColor = float4(GetFog(finalColor, iVertexLight.a), diffColor.a);
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iVertexLight.a, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iVertexLight.a);
+        #endif
+
+        oColor = float4(GetFog(finalColor, fogFactor), diffColor.a);
     #endif
 }

Bin/CoreData/Shaders/HLSL/LitSolid.xml

@@ -4,6 +4,7 @@
         <option name="EnvCube" define="ENVCUBEMAP" />
         <option name="LightMap" define="LIGHTMAP" exclude="AO" />
         <option name="AO" define="AO" exclude="LightMap" />
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
         <variation name="" define="AMBIENT" />
         <variation name="1VL" define="NUMVERTEXLIGHTS=1" />
         <variation name="2VL" define="NUMVERTEXLIGHTS=2" />
@@ -40,6 +41,7 @@
         <variation name="Emissive" define="EMISSIVEMAP" />
         <option name="AlphaMask" define="ALPHAMASK" require="DIFFMAP" />
         <option name="Ambient" define="AMBIENT" require="PERPIXEL" />
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
         <variation name="" define="AMBIENT" />
         <variation name="Dir">
             <exclude name="EnvCube" />

Bin/CoreData/Shaders/HLSL/PostProcess.hlsl

@@ -0,0 +1,86 @@
+
+static const float PI = 3.14159265;
+
+float2 Noise(float2 coord)
+{
+    float noiseX = clamp(frac(sin(dot(coord, float2(12.9898, 78.233))) * 43758.5453), 0.0, 1.0);
+    float noiseY = clamp(frac(sin(dot(coord, float2(12.9898, 78.233) * 2.0)) * 43758.5453), 0.0, 1.0);
+    return float2(noiseX, noiseY);
+}
+
+// Adapted: http://callumhay.blogspot.com/2010/09/gaussian-blur-shader-glsl.html
+float4 GaussianBlur(int blurKernelSize, float2 blurDir, float2 blurRadius, float sigma, sampler2D texSampler, float2 texCoord)
+{
+    const int blurKernelHalfSize = blurKernelSize / 2;
+
+    // Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
+    float3 gaussCoeff;
+    gaussCoeff.x = 1.0 / (sqrt(2.0 * PI) * sigma);
+    gaussCoeff.y = exp(-0.5 / (sigma * sigma));
+    gaussCoeff.z = gaussCoeff.y * gaussCoeff.y;
+
+    float2 blurVec = blurRadius * blurDir;
+    float4 avgValue = float4(0.0, 0.0, 0.0, 0.0);
+    float gaussCoeffSum = 0.0;
+
+    avgValue += tex2D(texSampler, texCoord) * gaussCoeff.x;
+    gaussCoeffSum += gaussCoeff.x;
+    gaussCoeff.xy *= gaussCoeff.yz;
+
+    for (int i = 1; i <= blurKernelHalfSize; i++)
+    {
+        avgValue += tex2D(texSampler, texCoord - i * blurVec) * gaussCoeff.x;
+        avgValue += tex2D(texSampler, texCoord + i * blurVec) * gaussCoeff.x;
+
+        gaussCoeffSum += 2.0 * gaussCoeff.x;
+        gaussCoeff.xy *= gaussCoeff.yz;
+    }
+
+    return avgValue / gaussCoeffSum;
+}
+
+static const float3 LumWeights = float3(0.2126, 0.7152, 0.0722);
+
+float3 ReinhardEq3Tonemap(float3 x)
+{
+    return x / (x + 1.0);
+}
+
+float3 ReinhardEq4Tonemap(float3 x, float white)
+{
+    return x * (1.0 + x / white) / (1.0 + x);
+}
+
+// Unchared2 tone mapping (See http://filmicgames.com)
+static const float A = 0.15;
+static const float B = 0.50;
+static const float C = 0.10;
+static const float D = 0.20;
+static const float E = 0.02;
+static const float F = 0.30;
+
+float3 Uncharted2Tonemap(float3 x)
+{
+   return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;
+}
+
+float3 ColorCorrection(float3 color, sampler3D lut)
+{
+    float lutSize = 16.0;
+    float scale = (lutSize - 1.0) / lutSize;
+    float offset = 1.0 / (2.0 * lutSize);
+    return tex3D(lut, clamp(color, 0.0, 1.0) * scale + offset).rgb;
+}
+
+static const float Gamma = 2.2;
+static const float InverseGamma = 1.0 / 2.2;
+
+float3 ToGamma(float3 color)
+{
+    return float3(pow(color, Gamma));
+}
+
+float3 ToInverseGamma(float3 color)
+{
+    return float3(pow(color, InverseGamma));
+}

Bin/CoreData/Shaders/HLSL/Samplers.hlsl

@@ -15,6 +15,7 @@ samplerCUBE sFaceSelectCubeMap : register(S8);
 samplerCUBE sIndirectionCubeMap : register(S9);
 sampler2D sDepthBuffer : register(S10);
 sampler2D sLightBuffer : register(S11);
+sampler3D sVolumeMap : register(S12);
 
 float4 Sample(sampler2D map, float2 texCoord)
 {

Bin/CoreData/Shaders/HLSL/TerrainBlend.hlsl

@@ -26,6 +26,9 @@ void VS(float4 iPos : POSITION,
         float2 iSize : TEXCOORD1,
     #endif
     out float2 oTexCoord : TEXCOORD0,
+    #ifdef HEIGHTFOG
+        out float3 oWorldPos : TEXCOORD8,
+    #endif
     out float3 oNormal : TEXCOORD2,
     #ifdef PERPIXEL
         out float4 oLightVec : TEXCOORD1,
@@ -56,6 +59,10 @@ void VS(float4 iPos : POSITION,
     oTexCoord = GetTexCoord(iTexCoord);
     oNormal = GetWorldNormal(modelMatrix);
 
+    #ifdef HEIGHTFOG
+        oWorldPos = worldPos;
+    #endif
+
     #ifdef PERPIXEL
         // Per-pixel forward lighting
         float4 projWorldPos = float4(worldPos, 1.0);
@@ -97,6 +104,9 @@ void VS(float4 iPos : POSITION,
 }
 
 void PS(float2 iTexCoord : TEXCOORD0,
+    #ifdef HEIGHTFOG
+        float3 iWorldPos : TEXCOORD8,
+    #endif
     #ifdef PERPIXEL
         float4 iLightVec : TEXCOORD1,
         float3 iNormal : TEXCOORD2,
@@ -167,12 +177,18 @@ void PS(float2 iTexCoord : TEXCOORD0,
         #else
             finalColor = diff * lightColor * diffColor.rgb;
         #endif
+
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iLightVec.w, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iLightVec.w);
+        #endif
     
         #ifdef AMBIENT
             finalColor += cAmbientColor * diffColor.rgb;
-            oColor = float4(GetFog(finalColor, iLightVec.w), diffColor.a);
+            oColor = float4(GetFog(finalColor, fogFactor), diffColor.a);
         #else
-            oColor = float4(GetLitFog(finalColor, iLightVec.w), diffColor.a);
+            oColor = float4(GetLitFog(finalColor, fogFactor), diffColor.a);
         #endif
     #elif defined(PREPASS)
         // Fill light pre-pass G-Buffer
@@ -194,8 +210,14 @@ void PS(float2 iTexCoord : TEXCOORD0,
         float specIntensity = specColor.g;
         float specPower = cMatSpecColor.a / 255.0;
 
-        oColor = float4(GetFog(iVertexLight.rgb * diffColor.rgb, iVertexLight.a), 1.0);
-        oAlbedo = GetFogFactor(iVertexLight.a) * float4(diffColor.rgb, specIntensity);
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iVertexLight.a, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iVertexLight.a);
+        #endif
+
+        oColor = float4(GetFog(iVertexLight.rgb * diffColor.rgb, fogFactor), 1.0);
+        oAlbedo = fogFactor * float4(diffColor.rgb, specIntensity);
         oNormal = float4(normal * 0.5 + 0.5, specPower);
         oDepth = iVertexLight.a;
     #else
@@ -211,6 +233,12 @@ void PS(float2 iTexCoord : TEXCOORD0,
             finalColor += lightInput.rgb * diffColor.rgb + lightSpecColor * specColor;
         #endif
 
-        oColor = float4(GetFog(finalColor, iVertexLight.a), diffColor.a);
+        #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iVertexLight.a, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iVertexLight.a);
+        #endif
+
+        oColor = float4(GetFog(finalColor, fogFactor), diffColor.a);
     #endif
 }

Bin/CoreData/Shaders/HLSL/TerrainBlend.xml

@@ -1,5 +1,6 @@
 <shaders>
     <shader type="vs">
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
         <variation name="" define="AMBIENT" />
         <variation name="1VL" define="NUMVERTEXLIGHTS=1" />
         <variation name="2VL" define="NUMVERTEXLIGHTS=2" />
@@ -24,6 +25,7 @@
     </shader>
     <shader type="ps">
         <option name="Ambient" define="AMBIENT" require="PERPIXEL" />
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
         <variation name="" define="AMBIENT" />
         <variation name="Dir">
             <define name="DIRLIGHT" />

Bin/CoreData/Shaders/HLSL/Tonemap.hlsl

@@ -0,0 +1,38 @@
+#include "Uniforms.hlsl"
+#include "Transform.hlsl"
+#include "Samplers.hlsl"
+#include "ScreenPos.hlsl"
+#include "PostProcess.hlsl"
+
+uniform float cTonemapExposureBias;
+uniform float cTonemapMaxWhite;
+
+void VS(float4 iPos : POSITION,
+    out float4 oPos : POSITION,
+    out float2 oScreenPos : TEXCOORD0)
+{
+    float4x3 modelMatrix = iModelMatrix;
+    float3 worldPos = GetWorldPos(modelMatrix);
+    oPos = GetClipPos(worldPos);
+    oScreenPos = GetScreenPosPreDiv(oPos);
+}
+
+void PS(float2 iScreenPos : TEXCOORD0,
+    out float4 oColor : COLOR0)
+{
+    #ifdef REINHARDEQ3
+    float3 color = ReinhardEq3Tonemap(max(tex2D(sDiffMap, iScreenPos).rgb * cTonemapExposureBias, 0.0));
+    oColor = float4(color, 1.0);
+    #endif
+
+    #ifdef REINHARDEQ4
+    float3 color = ReinhardEq4Tonemap(max(tex2D(sDiffMap, iScreenPos).rgb * cTonemapExposureBias, 0.0), cTonemapMaxWhite);
+    oColor = float4(color, 1.0);
+    #endif
+
+    #ifdef UNCHARTED2
+    float3 color = Uncharted2Tonemap(max(tex2D(sDiffMap, iScreenPos).rgb * cTonemapExposureBias, 0.0)) / 
+        Uncharted2Tonemap(float3(cTonemapMaxWhite, cTonemapMaxWhite, cTonemapMaxWhite));
+    oColor = float4(color, 1.0);
+    #endif
+}

Bin/CoreData/Shaders/HLSL/Tonemap.xml

@@ -0,0 +1,8 @@
+<shaders>
+    <shader type="vs" />
+    <shader type="ps">
+        <variation name="ReinhardEq3" define="REINHARDEQ3" />
+        <variation name="ReinhardEq4" define="REINHARDEQ4" />
+        <variation name="Uncharted2" define="UNCHARTED2" />
+    </shader>
+</shaders>

Bin/CoreData/Shaders/HLSL/Uniforms.hlsl

@@ -4,7 +4,10 @@ uniform float3 cAmbientEndColor;
 uniform float3x3 cBillboardRot;
 uniform float3 cCameraPos;
 uniform float3x3 cCameraRot;
+uniform float cNearClip;
+uniform float cFarClip;
 uniform float4 cDepthMode;
+uniform float cDeltaTime;
 uniform float cElapsedTime;
 uniform float3 cFrustumSize;
 uniform float4 cGBufferOffsets;
@@ -25,8 +28,9 @@ uniform float4x4 cLightMatrices[4];
 
 // Pixel shader uniforms
 uniform float3 cAmbientColor;
+uniform float cDeltaTimePS;
 uniform float cElapsedTimePS;
-uniform float2 cFogParams;
+uniform float4 cFogParams;
 uniform float3 cFogColor;
 uniform float2 cGBufferInvSize;
 uniform float4 cLightColor;
@@ -36,6 +40,8 @@ uniform float4 cMatDiffColor;
 uniform float3 cMatEmissiveColor;
 uniform float3 cMatEnvMapColor;
 uniform float4 cMatSpecColor;
+uniform float cNearClipPS;
+uniform float cFarClipPS;
 uniform float4 cShadowCubeAdjust;
 uniform float4 cShadowDepthFade;
 uniform float2 cShadowIntensity;

Bin/CoreData/Shaders/HLSL/Unlit.hlsl

@@ -20,6 +20,9 @@ void VS(float4 iPos : POSITION,
     #endif
     out float2 oTexCoord : TEXCOORD0,
     out float oDepth : TEXCOORD1,
+    #ifdef HEIGHTFOG
+        out float3 oWorldPos : TEXCOORD8,
+    #endif
     #ifdef VERTEXCOLOR
         out float4 oColor : COLOR0,
     #endif
@@ -31,6 +34,10 @@ void VS(float4 iPos : POSITION,
     oTexCoord = GetTexCoord(iTexCoord);
     oDepth = GetDepth(oPos);
 
+    #ifdef HEIGHTFOG
+        oWorldPos = worldPos;
+    #endif
+
     #ifdef VERTEXCOLOR
         oColor = iColor;
     #endif
@@ -38,6 +45,9 @@ void VS(float4 iPos : POSITION,
 
 void PS(float2 iTexCoord : TEXCOORD0,
     float iDepth : TEXCOORD1,
+    #ifdef HEIGHTFOG
+        float3 iWorldPos : TEXCOORD8,
+    #endif
     #ifdef VERTEXCOLOR
         float4 iColor : COLOR0,
     #endif
@@ -57,5 +67,11 @@ void PS(float2 iTexCoord : TEXCOORD0,
         diffColor *= iColor;
     #endif
 
-    oColor = float4(GetFog(diffColor.rgb, iDepth), diffColor.a);
+    #ifdef HEIGHTFOG
+            float fogFactor = GetHeightFogFactor(iDepth, iWorldPos.y);
+        #else
+            float fogFactor = GetFogFactor(iDepth);
+        #endif
+
+    oColor = float4(GetFog(diffColor.rgb, fogFactor), diffColor.a);
 }

Bin/CoreData/Shaders/HLSL/Unlit.xml

@@ -1,6 +1,7 @@
 <shaders>
     <shader type="vs">
         <option name="VCol" define="VERTEXCOLOR" />
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
         <variation name="" />
         <variation name="Skinned" define="SKINNED" />
         <variation name="Instanced" define="INSTANCED" require="SM3" />
@@ -10,5 +11,6 @@
         <option name="Diff" define="DIFFMAP" />
         <option name="VCol" define="VERTEXCOLOR" />
         <option name="AlphaMask" define="ALPHAMASK" require="DIFFMAP" />
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
     </shader>
 </shaders>

Bin/CoreData/Shaders/HLSL/Vegetation.hlsl

@@ -56,6 +56,9 @@ void VS(float4 iPos : POSITION,
         #endif
         out float4 oScreenPos : TEXCOORD5,
     #endif
+    #ifdef HEIGHTFOG
+        out float3 oWorldPos : TEXCOORD8,
+    #endif
     out float4 oPos : POSITION)
 {
     float4x3 modelMatrix = iModelMatrix;
@@ -70,6 +73,10 @@ void VS(float4 iPos : POSITION,
     oPos = GetClipPos(worldPos);
     oTexCoord = GetTexCoord(iTexCoord);
 
+    #ifdef HEIGHTFOG
+        oWorldPos = worldPos;
+    #endif
+
     #if defined(PERPIXEL) && defined(NORMALMAP)
         float3 oNormal;
         float3 oTangent;

Bin/CoreData/Shaders/HLSL/Vegetation.xml

@@ -1,6 +1,7 @@
 <shaders>
     <shader type="vs">
         <option name="Normal" define="NORMALMAP" />
+        <option name="HeightFog" define="HEIGHTFOG" require="SM3" />
         <variation name="" define="AMBIENT" />
         <variation name="1VL" define="NUMVERTEXLIGHTS=1" />
         <variation name="2VL" define="NUMVERTEXLIGHTS=2" />

Bin/CoreData/Techniques/DiffAddHeightFog.xml

@@ -0,0 +1,3 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="Unlit_HeightFog" ps="Unlit_DiffHeightFog" depthwrite="false" blend="add" />
+</technique>

Bin/CoreData/Techniques/DiffAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffAlphaMaskHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFog" alphamask="true" />
+    <pass name="litbase" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskAmbientHeightFog" alphamask="true" />
+    <pass name="light" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFog"  depthtest="equal" depthwrite="false" blend="add" alphamask="true" />
+    <pass name="prepass" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFogPrepass" alphamask="true" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFogMaterial" depthtest="equal" depthwrite="false" alphamask="true" />
+    <pass name="deferred" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFogDeferred" alphamask="true" />
+    <pass name="depth" vs="Depth" ps="Depth_AlphaMask" alphamask="true" />
+    <pass name="shadow" vs="Shadow" ps="Shadow_AlphaMask" alphamask="true" />
+</technique>

Bin/CoreData/Techniques/DiffEnvCubeAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_EnvCubeHeightFog" ps="LitSolid_DiffEnvCubeHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffEnvCubeHeightFog.xml

@@ -0,0 +1,9 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_EnvCubeHeightFog" ps="LitSolid_DiffEnvCubeHeightFog" />
+    <pass name="light" vs="LitSolid_HeightFog" ps="LitSolid_Diff" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_EnvCubeHeightFog" ps="LitSolid_DiffEnvCubeHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_EnvCubeHeightFog" ps="LitSolid_DiffEnvCubeHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" />
+    <pass name="litbase" vs="LitSolid_HeightFog" ps="LitSolid_DiffAmbientHeightFog" />
+    <pass name="light" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffLightMapAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_LightMapHeightFog" ps="LitSolid_DiffLightMapHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffLightMapHeightFog.xml

@@ -0,0 +1,9 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_LightMapHeightFog" ps="LitSolid_DiffLightMapHeightFog" />
+    <pass name="light" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_LightMapHeightFog" ps="LitSolid_DiffLightMapHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_LightMapHeightFog" ps="LitSolid_DiffLightMapHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffLitParticleAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitParticle_HeightFog" ps="LitParticle_DiffHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitParticle_HeightFog" ps="LitParticle_DiffHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalAlphaMaskHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFog" alphamask="true" />
+    <pass name="litbase" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalAlphaMaskAmbientHeightFog" alphamask="true" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalAlphaMask" depthtest="equal" depthwrite="false" blend="add" alphamask="true" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalAlphaMaskHeightFogPrepass" alphamask="true" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFogMaterial" depthtest="equal" depthwrite="false" alphamask="true" />
+    <pass name="deferred" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalAlphaMaskHeightFogDeferred" alphamask="true" />
+    <pass name="depth" vs="Depth" ps="Depth_AlphaMask" alphamask="true" />
+    <pass name="shadow" vs="Shadow" ps="Shadow_AlphaMask" alphamask="true" />
+</technique>

Bin/CoreData/Techniques/DiffNormalEnvCubeAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_NormalEnvCubeHeightFog" ps="LitSolid_DiffNormalEnvCubeHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalEnvCubeHeightFog.xml

@@ -0,0 +1,9 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_NormalEnvCubeHeightFog" ps="LitSolid_DiffNormalEnvCubeHeightFog" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_NormalEnvCubeHeightFog" ps="LitSolid_DiffNormalEnvCubeHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_NormalEnvCubeHeightFog" ps="LitSolid_DiffNormalEnvCubeHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true">
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" />
+    <pass name="litbase" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalAmbientHeightFog" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalPackedAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_v" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalPackedAlphaMaskHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFog" alphamask="true" />
+    <pass name="litbase" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedAlphaMaskAmbientHeightFog" alphamask="true" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedAlphaMaskHeightFog" depthtest="equal" depthwrite="false" blend="add" alphamask="true" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedAlphaMaskHeightFogPrepass" alphamask="true" />
+    <pass name="material" vs="LitSolid" ps="LitSolid_DiffAlphaMaskMaterial" depthtest="equal" depthwrite="false" alphamask="true" />
+    <pass name="deferred" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedAlphaMaskHeightFogDeferred" alphamask="true" />
+    <pass name="depth" vs="Depth" ps="Depth_AlphaMask" alphamask="true" />
+    <pass name="shadow" vs="Shadow" ps="Shadow_AlphaMask" alphamask="true" />
+</technique>

Bin/CoreData/Techniques/DiffNormalPackedEnvCubeAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_NormalEnvCubeHeightFog" ps="LitSolid_DiffNormalPackedEnvCubeHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalPackedEnvCubeHeightFog.xml

@@ -0,0 +1,9 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_NormalEnvCubeHeightFog" ps="LitSolid_DiffNormalPackedEnvCubeHeightFog" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_NormalEnvCubeHeightFog" ps="LitSolid_DiffNormalPackedEnvCubeHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_NormalEnvCubeHeightFog" ps="LitSolid_DiffNormalPackedEnvCubeHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalPackedHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" />
+    <pass name="litbase" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedAmbientHeightFog" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalPackedSpecAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalPackedSpecAlphaMaskHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFog" alphamask="true" />
+    <pass name="litbase" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapAlphaMaskAmbientHeightFog" alphamask="true" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapAlphaMaskHeightFog" depthtest="equal" depthwrite="false" blend="add" alphamask="true" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapAlphaMaskHeightFogPrepass" alphamask="true" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapAlphaMaskHeightFogMaterial" depthtest="equal" depthwrite="false" alphamask="true" />
+    <pass name="deferred" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapAlphaMaskHeightFogDeferred" alphamask="true" />
+    <pass name="depth" vs="Depth" ps="Depth_AlphaMask" alphamask="true" />
+    <pass name="shadow" vs="Shadow" ps="Shadow_AlphaMask" alphamask="true" />
+</technique>

Bin/CoreData/Techniques/DiffNormalPackedSpecHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" />
+    <pass name="litbase" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapAmbientHeightFog" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalPackedSpecMapHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalSpecAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffNormalSpecAlphaMaskHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFog" alphamask="true" />
+    <pass name="litbase" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapAlphaMaskAmbientHeightFog" alphamask="true" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapAlphaMask" depthtest="equal" depthwrite="false" blend="add" alphamask="true" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapAlphaMaskHeightFogPrepass" alphamask="true" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapAlphaMaskHeightFogMaterial" depthtest="equal" depthwrite="false" alphamask="true" />
+    <pass name="deferred" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapAlphaMaskHeightFogDeferred" alphamask="true" />
+    <pass name="depth" vs="Depth" ps="Depth_AlphaMask" alphamask="true" />
+    <pass name="shadow" vs="Shadow" ps="Shadow_AlphaMask" alphamask="true" />
+</technique>

Bin/CoreData/Techniques/DiffNormalSpecHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolidHeightFog" ps="LitSolid_DiffHeightFog" />
+    <pass name="litbase" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapAmbientHeightFog" />
+    <pass name="light" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_NormalHeightFog" ps="LitSolid_DiffNormalSpecMapHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffSpecAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapHeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffSpecAlphaMaskHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffAlphaMaskHeightFog" alphamask="true" />
+    <pass name="litbase" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapAlphaMaskAmbientHeightFog" alphamask="true" />
+    <pass name="light" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapAlphaMaskHeightFog"  depthtest="equal" depthwrite="false" blend="add" alphamask="true" />
+    <pass name="prepass" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapAlphaMaskHeightFogPrepass" alphamask="true" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapAlphaMaskHeightFogMaterial" depthtest="equal" depthwrite="false" alphamask="true" />
+    <pass name="deferred" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapAlphaMaskHeightFogDeferred" alphamask="true" />
+    <pass name="depth" vs="Depth" ps="Depth_AlphaMask" alphamask="true" />
+    <pass name="shadow" vs="Shadow" ps="Shadow_AlphaMask" alphamask="true" />
+</technique>

Bin/CoreData/Techniques/DiffSpecHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_DiffHeightFog" />
+    <pass name="litbase" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapAmbientHeightFog" />
+    <pass name="light" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapHeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapHeightFogPrepass" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_HeightFog" ps="LitSolid_DiffSpecMapHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/DiffUnlitAlphaHeightFog.xml

@@ -0,0 +1,3 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="Unli_HeightFog" ps="Unlit_DiffHeightFog" depthwrite="false" blend="alpha" />
+</technique>

Bin/CoreData/Techniques/DiffUnlitHeightFog.xml

@@ -0,0 +1,3 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="Unlit_HeightFog" ps="Unlit_DiffHeightFog" />
+</technique>

Bin/CoreData/Techniques/NoTextureAddHeightFog.xml

@@ -0,0 +1,3 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="Unlit_HeightFog" ps="Unlit_HeightFog" depthwrite="false" blend="add" />
+</technique>

Bin/CoreData/Techniques/NoTextureAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_HeightFog" ps="LitSolid_HeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_HeightFog" ps="LitSolid_HeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/NoTextureEnvCubeAlphaHeightFog.xml

@@ -0,0 +1,5 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="LitSolid_EnvCubeHeightFog" ps="LitSolid_EnvCubeHeightFog" depthwrite="false" blend="alpha" />
+    <pass name="litalpha" vs="LitSolid_HeightFog" ps="LitSolid_HeightFog" depthwrite="false" blend="addalpha" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/NoTextureEnvCubeHeightFog.xml

@@ -0,0 +1,9 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_EnvCubeHeightFog" ps="LitSolid_EnvCubeHeightFog" />
+    <pass name="light" vs="LitSolid_HeightFog" ps="LitSolid_HeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_HeightFog" ps="LitSolid_HeightFogPrepass" />
+    <pass name="material" vs="LitSolid_EnvCubeHeightFog" ps="LitSolid_EnvCubeHeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_EnvCubeHeightFog" ps="LitSolid_EnvCubeHeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/NoTextureHeightFog.xml

@@ -0,0 +1,10 @@
+<technique sm3="true" >
+    <pass name="base" vs="LitSolid_HeightFog" ps="LitSolid_HeightFog" />
+    <pass name="litbase" vs="LitSolid_HeightFog" ps="LitSolid_AmbientHeightFog" />
+    <pass name="light" vs="LitSolid_HeightFog" ps="LitSolid_HeightFog" depthtest="equal" depthwrite="false" blend="add" />
+    <pass name="prepass" vs="LitSolid_HeightFog" ps="LitSolid_HeightFogPrepass" />
+    <pass name="material" vs="LitSolid_HeightFog" ps="LitSolid_HeightFogMaterial" depthtest="equal" depthwrite="false" />
+    <pass name="deferred" vs="LitSolid_HeightFog" ps="LitSolid_HeightFogDeferred" />
+    <pass name="depth" vs="Depth" ps="Depth" />
+    <pass name="shadow" vs="Shadow" ps="Shadow" />
+</technique>

Bin/CoreData/Techniques/NoTextureUnlitAlphaHeightFog.xml

@@ -0,0 +1,3 @@
+<technique sm3="true" >
+    <pass name="alpha" vs="Unlit_HeightFog" ps="Unlit_HeightFog" depthwrite="false" blend="alpha" />
+</technique>