//Pre-Precessing Shader HLSL Code
//Note: LUT color conversion only supports the SDR color space

//#ifndef UNITY_COLOR_INCLUDED
// The color conversions I used are in here... but so is alot more
//#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
//#endif

//Expose for testing, hide for Global Control
//_PreProcessLUT ("LUT Texture", 2D) = "black" {}
//_PreProcessNoiseTex ("Noise Texture", 2D) = "black" {}
//_PreProcessColor ("LUT Tint", Color) = (0,0,0,0)
//_PreProcessLUTStrength ("LUT Strength", Float) = 0

sampler2D _PreProcessLUT;
sampler2D _PreProcessNoise;
half4 _PreProcessColor;
half _PreProcessLUTStrength;
half _PreProcessDesaturation;
half _PreProcessNoiseAmount; // 0.3 

// Fast color conversions, I tested all of the versions, these two were the best compromise.
// More information: http://chilliant.blogspot.com/2012/08/srgb-approximations-for-hlsl.html?m=1
half3 FastLUTSRGBToLinear(half3 c)
{
    //return pow(c, 2.233333333); // Darker in the low end
    return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
}

half3 FastLUTLinearToSRGB(half3 c)
{
    // The "pow" may have been causing an issue on Quest?
    //return saturate(1.055 * pow(c, 0.416666667) - 0.055);
    half3 S1 = sqrt(c);
    half3 S2 = sqrt(S1);
    half3 S3 = sqrt(S2);
    return 0.662002687 * S1 + 0.684122060 * S2 - 0.323583601 * S3 - 0.0225411470 * c;    
} 

// Tint and saturation
float3 PPTintAndSaturation_float(float3 c)
{
    float invertedPPSaturation = (1 - _PreProcessDesaturation); // Inverted to support the uninitialized property
    float luma = dot(c, float3(0.2126729, 0.7151522, 0.0721750));
    float3 saturated = luma.xxx + invertedPPSaturation.xxx * (c - luma.xxx);
    return lerp(saturated, _PreProcessColor.rgb, _PreProcessColor.a);
}

half3 PPTintAndSaturation_half(half3 c)
{
    half invertedPPSaturation = (1 - _PreProcessDesaturation); // Inverted to support the uninitialized property
    half luma = dot(c, half3(0.2126729, 0.7151522, 0.0721750));
    half3 saturated = luma.xxx + invertedPPSaturation.xxx * (c - luma.xxx);
    return lerp(saturated, _PreProcessColor.rgb, _PreProcessColor.a);
}

half3 PreProcessingNoise(float2 uv, half3 c)
{   
    float2 modUV = (_ScreenParams.xy * uv);
    half randomNum = tex2D (_PreProcessNoise, modUV + _Time.x).r * _PreProcessNoiseAmount; // A little noise goes a long way (0.3)

    return (c + randomNum); // This is working well
}

// Full precision for texture coordinates, LUT, tint, and saturation
float4 PreProcessing_float(float2 uv, float3 c, float a)
{
    float3 scaleOffset = float3(0.0009765625, 0.03125, 31);
    // In LDR do the lookup in sRGB for the LUT, & saturate to prevent LUT errors if values are > 1
    //half3 c_srgb = PreProcessingNoise(uv,saturate(FastLUTLinearToSRGB(c))); // Removing the noise    
    half3 c_srgb = saturate(FastLUTLinearToSRGB(c));

    // Strip format where `height = sqrt(width)`
    c_srgb.z *= scaleOffset.z;
    float shift = floor(c_srgb.z);
    c_srgb.xy = c_srgb.xy * scaleOffset.z * scaleOffset.xy + scaleOffset.xy * 0.5;
    c_srgb.x += shift * scaleOffset.y;
    // Interpolating between two LUT colors
    c_srgb.xyz = lerp(
        tex2D(_PreProcessLUT, c_srgb.xy).rgb,
        tex2D(_PreProcessLUT, c_srgb.xy + float2(scaleOffset.y, 0.0)).rgb,
        c_srgb.z - shift
    );

    c_srgb = FastLUTSRGBToLinear(c_srgb);
    return float4(PPTintAndSaturation_float(lerp(c, c_srgb, _PreProcessLUTStrength)), a);
}

// Half precision, LUT, tint, and saturation
half4 PreProcessing_half(half2 uv, half3 c, half a)
{
    half3 scaleOffset = half3(0.0009765625, 0.03125, 31);
    // In LDR do the lookup in sRGB for the LUT, & saturate to prevent LUT errors if values are > 1
    //half3 c_srgb = PreProcessingNoise(uv,saturate(FastLUTLinearToSRGB(c))); // Removing the noise  
    half3 c_srgb = saturate(FastLUTLinearToSRGB(c));

    // Strip format where `height = sqrt(width)`
    c_srgb.z *= scaleOffset.z;
    half shift = floor(c_srgb.z);
    c_srgb.xy = c_srgb.xy * scaleOffset.z * scaleOffset.xy + scaleOffset.xy * 0.5;
    c_srgb.x += shift * scaleOffset.y;
    // Interpolating between two LUT colors
    c_srgb.xyz = lerp(
        tex2D(_PreProcessLUT, c_srgb.xy).rgb,
        tex2D(_PreProcessLUT, c_srgb.xy + half2(scaleOffset.y, 0.0)).rgb,
        c_srgb.z - shift
    );

    c_srgb = FastLUTSRGBToLinear(c_srgb);
    return half4(PPTintAndSaturation_half(lerp(c, c_srgb, _PreProcessLUTStrength)), a);
}

void PreProcessing_Graph_half(half2 UV, half3 Color, half1 Alpha, out half4 PreProcessed)
{
    PreProcessed = PreProcessing_half(UV, Color, Alpha);
}

void PreProcessing_Graph_float(float2 UV, float3 Color, float1 Alpha, out float4 PreProcessed)
{
    PreProcessed = PreProcessing_float(UV, Color, Alpha);
}

// Lite variants only do the tint and saturation, no LUTs or noise.
float4 PreProcessing_Lite_float(float2 uv, float3 c, float a)
{
    return float4(PPTintAndSaturation_float(c), a);
}

half4 PreProcessing_Lite_half(half2 uv, half3 c, half a)
{
    return half4(PreProcessing_Lite_float(float2(uv), float3(c), float(a)));
}

void PreProcessing_Lite_Graph_half(half2 UV, half3 Color, half1 Alpha, out half4 PreProcessed)
{
    PreProcessed = PreProcessing_Lite_half(UV, Color, Alpha);
}

void PreProcessing_Lite_Graph_float(float2 UV, float3 Color, float1 Alpha, out float4 PreProcessed)
{
    PreProcessed = PreProcessing_Lite_float(UV, Color, Alpha);
}