cameraEffects_fp.glsl

/*
===========================================================================
Copyright (C) 2009-2010 Robert Beckebans <trebor_7@users.sourceforge.net>

This file is part of XreaL source code.

XreaL source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

XreaL source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with XreaL source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

/* cameraEffects_fp.glsl */

#define CAMERAEFFECTS_GLSL

uniform sampler2D u_CurrentMap;

#if defined(r_colorGrading)
uniform sampler3D u_ColorMap3D;
#endif

uniform vec4      u_ColorModulate;
uniform float     u_GlobalLightFactor; // 1 / tr.identityLight
uniform float     u_InverseGamma;
uniform bool u_SRGB;

void convertToSRGB(inout vec3 color) {
	#if defined(r_accurateSRGB)
		float threshold = 0.0031308f;

		bvec3 cutoff = lessThan(color, vec3(threshold));
		vec3 low = vec3(12.92f) * color;
		vec3 high = vec3(1.055f) * pow(color, vec3(1.0f / 2.4f)) - vec3(0.055f);

		#if __VERSION__ > 120
			color = mix(high, low, cutoff);
		#else
			color = mix(high, low, vec3(cutoff));
		#endif
	#else
		float inverse = 0.4545454f; // 1 / 2.2
		color = pow(color, vec3(inverse));
	#endif
}

uniform float u_Exposure;

// Tone mapping is not available when high-precision float framebuffer isn't enabled or supported.
#if defined(r_highPrecisionRendering) && defined(HAVE_ARB_texture_float)
/* x: contrast
y: highlightsCompressionSpeed
z: shoulderClip
w: highlightsCompression */
uniform bool u_Tonemap;
uniform vec4 u_TonemapParms;

vec3 TonemapLottes( vec3 color ) {
  // Lottes 2016, "Advanced Techniques and Optimization of HDR Color Pipelines"
  return pow( color, vec3( u_TonemapParms[0] ) )
         / ( pow( color, vec3( u_TonemapParms[0] * u_TonemapParms[1] ) ) * u_TonemapParms[2] + u_TonemapParms[3] );
}
#endif

DECLARE_OUTPUT(vec4)

void main()
{
	#insert material_fp

	// calculate the screen texcoord in the 0.0 to 1.0 range
	vec2 st = gl_FragCoord.st / r_FBufSize;

	vec4 color = texture2D(u_CurrentMap, st);
	color *= u_GlobalLightFactor;

	color.rgb *= u_Exposure;

#if defined(r_highPrecisionRendering) && defined(HAVE_ARB_texture_float)
	if( u_Tonemap ) {
		#if defined(r_toneMappingLowLightRestorationSteps)
			vec3 mapped = TonemapLottes( color.rgb );

			/* The threshold is the color channel value under which we blend
			the tone mapped color with the original color to restore low
			light in dark shadows clipped by the tone mapper.

			The threshold is in sRGB space for convenience. For example,
			a threshold of 5 would make sure we start restoring low light
			when the sRGB-converted tone mapped color goes below #050505,
			a threshold of 10 would do the same for #0A0A0A and 16 would
			target #101010.

			We need to convert the threshold back to linear because we're
			still operating in linear space at this point.

			We don't exactly restore up to the threshold, we blend half
			the tone-mapped color with half the color, to avoid producing
			color artifacts that would happen by bumping the RGB channels
			directly. Each step does the half blend again, so we can say
			that the restoration _tends to the threshold_ with each step.

			Each step is done with a small bias to lower the threshold a bit
			every step to not not always use the exact same frontier between
			the area having light restored and the area being kept unmodified,
			then smoothly blending the restoratiin with a gradient.

			Since we blend with half the colors, a threshold smaller than 2
			would do nothing. */
			float threshold;

			if ( u_SRGB )
			{
				threshold = pow( float( r_toneMappingLowLightRestorationThreshold ) / 255.0f, 2.2f );
			}
			else
			{
				threshold = float( r_toneMappingLowLightRestorationThreshold ) / 255.0f;
			}

			#if defined(r_showToneMappingLowLightRestoration)
				color.rgb = vec3(1.0f, 0.0f, 0.0f);
			#endif

			bvec3 colorCutoff = lessThan( color.rgb, vec3( threshold ) );

			for ( int i = 0; i < r_toneMappingLowLightRestorationSteps; i++ )
			{
				float t = threshold - ( i * ( threshold / 10.0f ) );

				bvec3 mappedCutoff = lessThan( mapped, vec3(t) );

				bvec3 cutoff = bvec3(ivec3(mappedCutoff) * ivec3(colorCutoff));

				#if __VERSION__ > 120
					vec3 interpolation = vec3(0.5f) * vec3(cutoff);
				#else
					vec3 interpolation = 0.5f * cutoff;
				#endif

				mapped = mix( mapped, color.rgb, interpolation );
			}

			color.rgb = mapped;
		#else
			color.rgb = TonemapLottes( color.rgb );
		#endif
	}
#endif

	#if defined(r_lowLightDithering)
	{
		float threshold;

		if ( u_SRGB )
		{
			threshold = pow( float( r_lowLightDitheringThreshold ) / 255.0f, 2.2f );
		}
		else
		{
			threshold = float( r_lowLightDitheringThreshold ) / 255.0f;
		}

		float sum = ( color.r + color.g + color.b );

		if ( sum != 0.0f && sum < ( 3.0f * threshold ) )
		{
			const float bayer[ 16 ] = {
				 0.0f,  8.0f,  2.0f, 10.0f,
				12.0f,  4.0f, 14.0f,  6.0f,
				 3.0f, 11.0f,  1.0f,  9.0f,
				15.0f,  7.0f, 13.0f,  5.0f
			};

			float dither = bayer[
					int( mod( gl_FragCoord.x, 4.0f ) ) +
					int( mod( gl_FragCoord.y, 4.0f ) ) * 4
				] / 16.0f;

			color.rgb += vec3( ( ( dither - 0.5f ) / 255.0f ) * r_lowLightDitheringAmplitudeFactor );

			#if defined(r_showLowLightDithering)
				color.rgb = vec3(1.0f, 0.0f, 0.0f);
			#endif
		}
	}
	#endif

	color.rgb = clamp( color.rgb, vec3( 0.0f ), vec3( 1.0f ) );

	if ( u_SRGB )
	{
		convertToSRGB( color.rgb );
	}

#if defined(r_colorGrading)
	// apply color grading
	vec3 colCoord = color.rgb * 15.0 / 16.0 + 0.5 / 16.0;
	colCoord.z *= 0.25;
	color.rgb = u_ColorModulate.x * texture3D(u_ColorMap3D, colCoord).rgb;
	color.rgb += u_ColorModulate.y * texture3D(u_ColorMap3D, colCoord + vec3(0.0, 0.0, 0.25)).rgb;
	color.rgb += u_ColorModulate.z * texture3D(u_ColorMap3D, colCoord + vec3(0.0, 0.0, 0.50)).rgb;
	color.rgb += u_ColorModulate.w * texture3D(u_ColorMap3D, colCoord + vec3(0.0, 0.0, 0.75)).rgb;
#endif

	color.xyz = pow(color.xyz, vec3(u_InverseGamma));

	outputColor = color;
}