forked from Mirrorlandia_minetest/minetest
e73c5d4585
This only works when shaders are enabled. The centroid varying avoids that the textures (which repeat themselves out of bounds) are sampled out of bounds in MSAA. If MSAA (called FSAA in minetest) is disabled, the centroid keyword does nothing.
96 lines
2.8 KiB
GLSL
96 lines
2.8 KiB
GLSL
uniform sampler2D baseTexture;
|
|
|
|
uniform vec4 skyBgColor;
|
|
uniform float fogDistance;
|
|
uniform vec3 eyePosition;
|
|
|
|
// The cameraOffset is the current center of the visible world.
|
|
uniform vec3 cameraOffset;
|
|
uniform float animationTimer;
|
|
|
|
varying vec3 vPosition;
|
|
// World position in the visible world (i.e. relative to the cameraOffset.)
|
|
// This can be used for many shader effects without loss of precision.
|
|
// If the absolute position is required it can be calculated with
|
|
// cameraOffset + worldPosition (for large coordinates the limits of float
|
|
// precision must be considered).
|
|
varying vec3 worldPosition;
|
|
varying lowp vec4 varColor;
|
|
centroid varying mediump vec2 varTexCoord;
|
|
varying vec3 eyeVec;
|
|
|
|
const float fogStart = FOG_START;
|
|
const float fogShadingParameter = 1.0 / ( 1.0 - fogStart);
|
|
|
|
#ifdef ENABLE_TONE_MAPPING
|
|
|
|
/* Hable's UC2 Tone mapping parameters
|
|
A = 0.22;
|
|
B = 0.30;
|
|
C = 0.10;
|
|
D = 0.20;
|
|
E = 0.01;
|
|
F = 0.30;
|
|
W = 11.2;
|
|
equation used: ((x * (A * x + C * B) + D * E) / (x * (A * x + B) + D * F)) - E / F
|
|
*/
|
|
|
|
vec3 uncharted2Tonemap(vec3 x)
|
|
{
|
|
return ((x * (0.22 * x + 0.03) + 0.002) / (x * (0.22 * x + 0.3) + 0.06)) - 0.03333;
|
|
}
|
|
|
|
vec4 applyToneMapping(vec4 color)
|
|
{
|
|
color = vec4(pow(color.rgb, vec3(2.2)), color.a);
|
|
const float gamma = 1.6;
|
|
const float exposureBias = 5.5;
|
|
color.rgb = uncharted2Tonemap(exposureBias * color.rgb);
|
|
// Precalculated white_scale from
|
|
//vec3 whiteScale = 1.0 / uncharted2Tonemap(vec3(W));
|
|
vec3 whiteScale = vec3(1.036015346);
|
|
color.rgb *= whiteScale;
|
|
return vec4(pow(color.rgb, vec3(1.0 / gamma)), color.a);
|
|
}
|
|
#endif
|
|
|
|
void main(void)
|
|
{
|
|
vec3 color;
|
|
vec2 uv = varTexCoord.st;
|
|
|
|
vec4 base = texture2D(baseTexture, uv).rgba;
|
|
#ifdef USE_DISCARD
|
|
// If alpha is zero, we can just discard the pixel. This fixes transparency
|
|
// on GPUs like GC7000L, where GL_ALPHA_TEST is not implemented in mesa,
|
|
// and also on GLES 2, where GL_ALPHA_TEST is missing entirely.
|
|
if (base.a == 0.0) {
|
|
discard;
|
|
}
|
|
#endif
|
|
|
|
color = base.rgb;
|
|
|
|
vec4 col = vec4(color.rgb * varColor.rgb, 1.0);
|
|
|
|
#ifdef ENABLE_TONE_MAPPING
|
|
col = applyToneMapping(col);
|
|
#endif
|
|
|
|
// Due to a bug in some (older ?) graphics stacks (possibly in the glsl compiler ?),
|
|
// the fog will only be rendered correctly if the last operation before the
|
|
// clamp() is an addition. Else, the clamp() seems to be ignored.
|
|
// E.g. the following won't work:
|
|
// float clarity = clamp(fogShadingParameter
|
|
// * (fogDistance - length(eyeVec)) / fogDistance), 0.0, 1.0);
|
|
// As additions usually come for free following a multiplication, the new formula
|
|
// should be more efficient as well.
|
|
// Note: clarity = (1 - fogginess)
|
|
float clarity = clamp(fogShadingParameter
|
|
- fogShadingParameter * length(eyeVec) / fogDistance, 0.0, 1.0);
|
|
col = mix(skyBgColor, col, clarity);
|
|
col = vec4(col.rgb, base.a);
|
|
|
|
gl_FragColor = col;
|
|
}
|