ALPHA_P_S_2020

/*================================================================================


ALPHA Photography Suite 2020 [ v4 - January 2020 ]



This work is licensed under the Creative Commons
Attribution-ShareAlike 4.0 International License.
To view a copy of this license, visit
http://creativecommons.org/licenses/by-sa/4.0/.



ALPHA Photography Suite 2020 - features:
- Advanced Filmic Tonemapping [ Settings like Linear White Point Value, Exposure, Shoulder & Toe Strength, Linear Angle etc will be at your disposal // "A filmic curve has three parts, a linear section, a shoulder, and a toe. The short version is that a toe gives you crisper blacks, a shoulder gives you a softer transition to your overexposed highlights, and the linear section should look relatively unchanged." ]

- Non-uniform Random Organic Film Grain [ granularity ] Emulation, this analog film grain emulation includes many finetuning settings. [ Film grain or granularity is the random optical texture of processed photographic film due to the presence of small particles of a metallic silver, or dye clouds, developed from silver halide that have received enough photons. While film grain is a function of such particles [ or dye clouds ] it is not the same thing as such. It is an optical effect, the magnitude of which [ amount of grain ] depends on both the film stock and the definition at which it is observed. Digital photography does not exhibit film grain, since there is no film for any grain to exist within. ]

- Automatic adjustments to Film Grain depending on screen luminance [ Screen area whose average brightness triggers  adaption. 1 to 7 // 1 = only the center of the image is used // 7 = the whole image is used ]

- Natural / organic looking film-grain with protection for the high & low levels [ the distribution of the naural-looking grain should be more prominent on the mid-tones and it should became lesser visible approaching white and black, but you can change this approach with the available finetuning settings ]

- Automatic exposure [ so no eye-burning / overexposed skies ]

- 15 presets with B/W Camera Film emulation [ like the beloved Kodak Tri-X ]

- Fast -Hue Brightness Contrast Saturation- control



Some background info:
As an extra this "5 shaders into 1" is faster [ total performance impact hitting around 1 to 2 fps ] than the total of 5 single shaders being used / stacked.

First of all, I'm not a hlsl-code writer nor [ want to ] pretend to be, this "ALPHA Photography Suite 2020" shader is based upon 5 main shaders, a compilation of 5 main existing shaders, which through an extensive time of trial & error is modified & tweaked, layer after layer.

As an huge long-term photolover of classic b/w [ analog ] grainy photography & always in search of the perfect holy grain [ to be honest most times I truly dislike the defaults forced-looking grain in games & disable the defaults distracting grainy awfulness, most UE4-based games have it enabled by default though this can be changed by altering the file Engine.ini and with r.Tonemapper.Quality=3 [ 3 or lower for removing film grain; 5=max ] and r.Tonemapper.GrainQuantization=0.

I've put some serious love into building this suite, I had a great time doing it & hope you like it too & to be useful for your future endeavours for making some excellent screenshots.


[ to see some examples of this shader suite in use: you can always visit https://flickr.com/people/alpha-neo-noir-v2/ ]



This "ALPHA Photography Suite 2020" for Reshade 4.x is based upon these shaders listed below [ tested on the latest Reshade Version 4.5.2 as well which was released on Dec 20th, 2019 ]:
- Simple Grain v1.0.6 by Jacob Maximilian Fober
- Code for grain depending on average screen luminance by brussell
- Eye Adaption v2.3 by brussell
- Monochrome v1.1 by CeeJay.dk
- Reshade port of Uncharted tonemapping by Jace Regenbrecht
- Base code sourced from John Hable's blog at http://filmicworlds.com/blog/filmic-tonemapping-operators/
- Reshade port of Hue Brightness Contrast Saturation control

CREDITS to these excellent code writers:
- Crosire for Reshade [ https://reshade.me/ ]
- Jacob Maximilian Fober for Grain code
- brussell for Eye Adaption
- CeeJay for B/W Camera Film presets
- Jace Regenbrecht for Uncharted tonemapping
- John Hable @ filmicworlds for base code filmic-tonemapping



Modifications & tweaks:
--> Added code from simple Grain v1.0.6 by Jacob Maximilian Fober [ Modified + some error & warning fixes ]
--> Extra code for grain depending on average screen luminance [brussell]
--> Extra options + code added from Eye Adaption v2.3 by brussell
--> Added extra grain options
--> Extra options + code added from Monochrome v1.1 by CeeJay.dk
--> Extra options + code added from Reshade port of Uncharted 2 tonemap by Jace Regenbrecht [ Modified + some error & warning fixes ]
--> Base code sourced from John Hable's blog at http://filmicworlds.com/blog/filmic-tonemapping-operators/
--> Extra options + code added from Reshade port of H.B.C.S - Hue Brightness Contrast Saturation control [ Modified + some error & warning fixes ]
--> Fine-tuned menu options + values



Extra:
Informative reads:
Filmic Tonemapping:
http://filmicworlds.com/blog/filmic-tonemapping-operators/
http://filmicworlds.com/blog/filmic-tonemapping-with-piecewise-power-curves/

Filmic Tonemapping and Color:
http://duikerresearch.com/2015/09/filmic-tonemapping-ea-2006/
https://mynameismjp.wordpress.com/2010/04/30/a-closer-look-at-tone-mapping/

Uncharted HDR Lighting:
https://www.gdcvault.com/play/1012351/Uncharted-2-HDR

Examples of grain [ Grain Library - comparison ]:
https://grubbasoftware.com/filmlibrary.html

Let’s improve grain:
https://discuss.pixls.us/t/lets-improve-grain/2709
https://blog.captureone.com/film-grains-photorealistic-right-way/

The Basics of Photography: G for Grain
https://www.thephoblographer.com/2013/09/11/the-basics-of-photography-g-for-grain/

Kodak T-max vs. Kodak Tri-X (with sample photos):
http://attemptsat35mm.com/kodak-t-max-vs-kodak-tri-x/

What is Panchromatic and Orthochromatic Film?:
https://filmphotographyproject.com/content/howto/2018/07/panchromatic-orthochromatic-film/

Simulating Kodak Tri-X Black & White Film:
https://www.nickbedford.com/blog/2017/7/simulating-kodak-tri-x-black-white-film

A brief history of Kodak:
https://independent-photo.com/news/historic-brands-kodak/

Kodak Tri-X:
https://en.wikipedia.org/wiki/Kodak_Tri-X

Kodak Tri-X: The Best Black-and-White Film Ever Made?:
https://petapixel.com/2016/04/04/kodak-tri-x-best-black-white-film-ever-made/
https://www.1843magazine.com/content/features/bryan-appleyard/tri-x-factor
https://www.thephoblographer.com/2017/02/22/street-photography-kodak-tri-x-film-62-years-going-grain/


================================================================================*/

	  ////////////
	 /// MENU ///
	////////////

#include "ReShadeUI.fxh"

uniform float Intensity < __UNIFORM_SLIDER_FLOAT1
	ui_label = "Noise Intensity";
	ui_category = "Classic fine grain settings:";
	ui_min = 0.000; ui_max = 30.000; ui_step = 0.001;
> = 7.000;

uniform int Framerate < __UNIFORM_SLIDER_INT1
	ui_label = "Noise Framerate";
	ui_category = "Classic fine grain settings:";
	ui_tooltip = "Zero will match in-game framerate";
	#if __RESHADE__ < 40000
		ui_step = 1;
	#endif
	ui_min = 0; ui_max = 120;
> = 0;

uniform int Coefficient < __UNIFORM_RADIO_INT1
	ui_category = "Classic fine grain settings:";
	ui_tooltip = "For digital video signal (HDMI, DVI, Display Port) use BT.709,\n"
	"for analog (like VGA, S-Video) use BT.601";
	#if __RESHADE__ < 40000
		ui_label = "YUV coefficients";
		ui_items = "BT.709 (digital signal)\0BT.601 (analog signal))\0";
	#else
		ui_items = "BT.709 - digital\0BT.601 - analog\0";
	#endif
> = 0;

uniform float fAdp_TriggerRadius <
    ui_label = "Adaption Trigger Radius";
    ui_tooltip = "For grain depending on average screen luminance. /Screen area whose average brightness triggers adaption.\n"
                 "1 = only the center of the image is used\n"
                 "7 = the whole image is used";
    ui_category = "Advanced settings / fine-tuning grain:";
    ui_type = "slider";
    ui_min = 1.0;
    ui_max = 7.0;
    ui_step = 0.1;
> = 7.0;

uniform float Grain_Layer_Intensity <
    ui_label = "Grain Layer Intensity";
    ui_tooltip = "Grain Layer Intensity";
    ui_category = "Advanced settings / fine-tuning grain:";
    ui_type = "slider";
    ui_min = 0.000;
    ui_max = 0.300;
    ui_step = 0.001;
> = 0.040;

uniform float Grain_UpperLevel_Intensity <
    ui_label = "Grain Upper Level Intensity";
    ui_tooltip = "Grain Upper Level Intensity in lighter areas like skies etc";
    ui_category = "Advanced settings / fine-tuning grain:";
    ui_type = "slider";
    ui_min = 0.000;
    ui_max = 1.300;
    ui_step = 0.001;
> = 0.50;

uniform float Grain_LowerLevel_Intensity <
    ui_label = "Grain Lower Level Intensity";
    ui_tooltip = "Grain Lower Level Intensity in darker areas like shadows etc";
    ui_category = "Advanced settings / fine-tuning grain:";
    ui_type = "slider";
    ui_min = -3.000;
    ui_max = 3.000;
    ui_step = 0.001;
> = 0.605;

uniform int Monochrome_preset <
	ui_type = "combo";
	ui_label = "B/W Camera Film Preset";
	ui_tooltip = "Choose a preset";
	ui_category = "Monochrome conversion settings:";
	ui_items = "Custom\0"
	"Monitor or modern TV\0"
	"Equal weight\0"
	"Agfa 200X\0"
	"Agfapan 25\0"
	"Agfapan 100\0"
	"Agfapan 400\0"
	"Ilford Delta 100\0"
	"Ilford Delta 400\0"
	"Ilford Delta 400 Pro & 3200\0"
	"Ilford FP4\0"
	"Ilford HP5\0"
	"Ilford Pan F\0"
	"Ilford SFX\0"
	"Ilford XP2 Super\0"
	"Kodak Tmax 100\0"
	"Kodak Tmax 400\0"
	"Kodak Tri-X\0";
> = 0;

uniform float3 Monochrome_conversion_values <
	ui_type = "color";
	ui_category = "Monochrome conversion settings:";
	ui_label = "Custom Conversion Values";
> = float3(0.21, 0.72, 0.07);

/*
uniform bool Normalize <
	ui_label = "Normalize";
	ui_category = "Monochrome conversion settings:";
	ui_tooltip = "Normalize the coefficients?";
> = false;
*/

uniform float Monochrome_color_saturation <
	ui_label = "Saturation";
	ui_category = "Monochrome conversion settings:";
	ui_type = "slider";
	ui_min = 0.0; ui_max = 1.0;
> = 0.0;

uniform bool U2_Lum <
	ui_label = "Use Luminance";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_tooltip = "Calculate tone based off each pixel's luminance value vs the RGB value.";
> = false;

uniform float U2_A <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = 0.00; ui_max = 1.00;
	ui_step = 0.001;
	ui_label = "Shoulder Strength";
> = 0.22;

uniform float U2_B <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = 0.00; ui_max = 1.00;
	ui_step = 0.001;
	ui_label = "Linear Strength";
> = 0.30;

uniform float U2_C <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = 0.00; ui_max = 1.00;
	ui_step = 0.001;
	ui_label = "Linear Angle";
> = 0.10;

uniform float U2_D <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = 0.00; ui_max = 1.00;
	ui_step = 0.001;
	ui_label = "Toe Strength";
> = 0.20;

uniform float U2_E <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = 0.00; ui_max = 1.00;
	ui_step = 0.001;
	ui_label = "Toe Numerator";
> = 0.01;

uniform float U2_F <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = 0.00; ui_max = 1.00;
	ui_step = 0.001;
	ui_label = "Toe Denominator";
> = 0.22;

uniform float U2_W <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = 0.00; ui_max = 20.00;
	ui_step = 0.10;
	ui_label = "Linear White Point Value";
> = 11.20;

uniform float U2_Exp <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = -10.00; ui_max = 20.00;
	ui_step = 0.001;
	ui_label = "Exposure";
> = 1.00;

uniform float U2_Gamma <
	ui_type = "slider";
	ui_category = "Advanced filmic-tonemapping settings:";
	ui_min = 1.00; ui_max = 3.00;
	ui_step = 0.1;
	ui_label = "Gamma Value";
	ui_tooltip = "Most monitors/images use a value of 2.2. Setting this to 1 disables the inital color space conversion from gamma to linear.";
> = 2.20;

uniform float Hue <
	ui_type = "slider";
	ui_category = "H.B.C.S - Hue Brightness Contrast Saturation control:";
	ui_min = -180.0; ui_max = 180.0;
	ui_step = 0.005;
	ui_tooltip = "Hue";
> = 0.00;
uniform float Brightness <
	ui_type = "slider";
	ui_category = "H.B.C.S - Hue Brightness Contrast Saturation control:";
	ui_min = -1.0; ui_max = 1.0;
	ui_tooltip = "Brightness";
> = 0.0;
uniform float Contrast <
	ui_type = "slider";
	ui_category = "H.B.C.S - Hue Brightness Contrast Saturation control:";
	ui_min = -1.0; ui_max = 1.0;
	ui_tooltip = "Contrast";
> = 0.0;
uniform float Saturation <
	ui_type = "slider";
	ui_category = "H.B.C.S - Hue Brightness Contrast Saturation control:";
	ui_min = 0.0; ui_max = 2.0;
	ui_tooltip = "Saturation";
> = 1.0;


	  //////////////
	 /// SHADER ///
	//////////////

uniform float Timer < source = "timer"; >;
uniform int FrameCount < source = "framecount"; >;

// RGB to YUV709 luma
static const float3 Luma709 = float3(0.2126, 0.7152, 0.0722);
// RGB to YUV601 luma
static const float3 Luma601 = float3(0.299, 0.587, 0.114);

// Overlay blending mode
float Overlay(float LayerA, float LayerB)
{
	float MinA = min(LayerA, 0.5);
	float MinB = min(LayerB, 0.5);
	float MaxA = max(LayerA, 0.5);
	float MaxB = max(LayerB, 0.5);
	return 2 * (MinA * MinB + MaxA + MaxB - MaxA * MaxB) - 1.5;
}

// Noise generator
float SimpleNoise(float p)
{ return frac(sin(dot(p, float2(12.9898, 78.233))) * 43758.5453); }

#include "ReShade.fxh"

// Shader pass
texture2D texLuminance { Width = 256; Height = 256; Format = R8; MipLevels = 7; };
sampler SamplerLuminance { Texture = texLuminance; };

float PS_Luminance(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target
{
   return dot(tex2D(ReShade::BackBuffer, texcoord.xy).xyz, 0.333);
}
void SimpleGrainPS(float4 vois : SV_Position, float2 TexCoord : TEXCOORD, out float3 Image : SV_Target)
{
	// Choose luma coefficient, if False BT.709 luma, else BT.601 luma
	float3 LumaCoefficient = bool(Coefficient) ? Luma601 : Luma709;

	// Sample image
	Image = tex2D(ReShade::BackBuffer, TexCoord).rgb;
	// Mask out bright pixels  gamma: (sqrt(5)+1)/2
	const float GoldenAB = sqrt(5.0) * Grain_UpperLevel_Intensity + Grain_UpperLevel_Intensity;
	float Mask = pow(abs(1.0 - dot(Image.rgb, LumaCoefficient)), GoldenAB);
	// Calculate seed change
	float Seed = Framerate == 0 ? FrameCount : floor(Timer * 0.001 * Framerate);
	// Protect from enormous numbers
	Seed = frac(Seed * 0.0001) * 10000;
	// Generate noise *  (sqrt(5) + 1) / 4  (to remain brightness)
	const float GoldenABh = sqrt(5.0) * 0.525 - Grain_LowerLevel_Intensity;
	float Noise = saturate(SimpleNoise(Seed * TexCoord.x * TexCoord.y) * GoldenABh);
	Noise = lerp(0.5, Noise, Intensity * Grain_Layer_Intensity * Mask);
	float avglum = tex2Dlod(SamplerLuminance, float4(0.5.xx, 0, fAdp_TriggerRadius)).x;
	Noise *= (1-avglum);
	// Blend noise with image
	Image.rgb = float3(
		Overlay(Image.r, Noise),
		Overlay(Image.g, Noise),
		Overlay(Image.b, Noise)
	);
}

float3 MonochromePass(float4 vpos : SV_Position, float2 texcoord : TexCoord) : SV_Target
{
	const float3 color = tex2D(ReShade::BackBuffer, texcoord).rgb;

	float3 Coefficients = float3(0.21, 0.72, 0.07);

	const float3 Coefficients_array[18] =
	{
		Monochrome_conversion_values, //Custom
		float3(0.21, 0.72, 0.07), //sRGB monitor
		float3(0.3333333, 0.3333334, 0.3333333), //Equal weight
		float3(0.18, 0.41, 0.41), //Agfa 200X
		float3(0.25, 0.39, 0.36), //Agfapan 25
		float3(0.21, 0.40, 0.39), //Agfapan 100
		float3(0.20, 0.41, 0.39), //Agfapan 400
		float3(0.21, 0.42, 0.37), //Ilford Delta 100
		float3(0.22, 0.42, 0.36), //Ilford Delta 400
		float3(0.31, 0.36, 0.33), //Ilford Delta 400 Pro & 3200
		float3(0.28, 0.41, 0.31), //Ilford FP4
		float3(0.23, 0.37, 0.40), //Ilford HP5
		float3(0.33, 0.36, 0.31), //Ilford Pan F
		float3(0.36, 0.31, 0.33), //Ilford SFX
		float3(0.21, 0.42, 0.37), //Ilford XP2 Super
		float3(0.24, 0.37, 0.39), //Kodak Tmax 100
		float3(0.27, 0.36, 0.37), //Kodak Tmax 400
		float3(0.25, 0.35, 0.40) //Kodak Tri-X
	};

	Coefficients = Coefficients_array[Monochrome_preset];

	// Calculate monochrome
	const float3 grey = dot(Coefficients, color);

	// Adjust the remaining saturation & return the result
	return saturate(lerp(grey, color, Monochrome_color_saturation));
}

float3 Uncharted2Tonemap(float3 x)
{
	return ((x*(U2_A*x+U2_C*U2_B)+U2_D*U2_E)/(x*(U2_A*x+U2_B)+U2_D*U2_F))-U2_E/U2_F;
}

float3 Uncharted_Tonemap_Main(float4 pos : SV_Position, float2 texcoord : TexCoord ) : COLOR
{
	float3 texColor = tex2D(ReShade::BackBuffer, texcoord ).rgb;

	// Do inital de-gamma of the game image to ensure we're operating in the correct colour range.
	if( U2_Gamma > 1.00 )
		texColor = pow(abs(texColor),U2_Gamma);

	texColor *= U2_Exp;  // Exposure Adjustment

	float ExposureBias = 2.0f;
	float3 curr;

	// Do tonemapping on RGB or Luminance
	if(!U2_Lum)
		curr = Uncharted2Tonemap(ExposureBias*texColor);
	else
	{
		float lum = 0.2126f * texColor[0] + 0.7152 * texColor[1] + 0.0722 * texColor[2];
		float3 newLum = Uncharted2Tonemap(ExposureBias*lum);
		float3 lumScale = newLum / lum;
		curr = texColor*lumScale;
	}

	float3 whiteScale = 1.0f/Uncharted2Tonemap(U2_W);
	float3 color = curr*whiteScale;

	// Do the post-tonemapping gamma correction
	if( U2_Gamma > 1.00 )
		color = pow(abs(color),1/U2_Gamma);

	return color;
}

float3x3 QuaternionToMatrix(float4 quat)
{
	float3 cross = quat.yzx * quat.zxy;
	float3 square= quat.xyz * quat.xyz;
	float3 wimag = quat.w * quat.xyz;

	square = square.xyz + square.yzx;

	float3 diag = 0.5 - square;
	float3 a = (cross + wimag);
	float3 b = (cross - wimag);

	return float3x3(
	2.0 * float3(diag.x, b.z, a.y),
	2.0 * float3(a.z, diag.y, b.x),
	2.0 * float3(b.y, a.x, diag.z));
}

float4 PS_ColorShift(float4 position : SV_Position, float2 texcoord : TexCoord) : SV_Target
{
	float4 outputColor = tex2D(ReShade::BackBuffer, texcoord);
	float3 intensity;
	float3 root3 = float3(0.57735, 0.57735, 0.57735);
	float half_angle = 0.5 * radians(Hue);
	float4 rot_quat = float4( (root3 * sin(half_angle)), cos(half_angle));
	float3x3 rot_Matrix = QuaternionToMatrix(rot_quat);
	outputColor.rgb = mul(rot_Matrix, outputColor.rgb);
	outputColor.rgb = (outputColor.rgb - 0.5) *(Contrast + 1.0) + 0.5;
	outputColor.rgb = outputColor.rgb + Brightness;
	float3 lumCoeff = float3(0.2125, 0.7154, 0.0721);
	intensity = float(dot(outputColor.rgb, lumCoeff));
	outputColor.rgb = lerp(intensity, outputColor.rgb, Saturation);

	return outputColor;
}

	  //////////////
	 /// OUTPUT ///
	//////////////

technique ALPHA_Photography_Suite_2020_V4 < ui_label = "ALPHA Photography Suite 2020 V4"; >
{
	pass{VertexShader = PostProcessVS;PixelShader = PS_Luminance;RenderTarget = texLuminance;}
	pass{VertexShader = PostProcessVS;PixelShader = SimpleGrainPS;}
	pass{VertexShader = PostProcessVS;PixelShader = MonochromePass;}
	pass{VertexShader = PostProcessVS;PixelShader = Uncharted_Tonemap_Main;}
	pass{VertexShader = PostProcessVS;PixelShader = PS_ColorShift;}
}