RMIT
/
Major_Project_A


								Shader "Hidden/Post FX/Eye Adaptation"

								{

								    Properties

								    {

								        _MainTex("Texture", 2D) = "white" {}

								    }


								    CGINCLUDE


								        #pragma target 4.5

								        #pragma multi_compile __ AUTO_KEY_VALUE

								        #include "UnityCG.cginc"

								        #include "Common.cginc"

								        #include "EyeAdaptation.cginc"


								        // Eye adaptation pass

								        float4 _Params; // x: lowPercent, y: highPercent, z: minBrightness, w: maxBrightness

								        float2 _Speed; // x: down, y: up

								        float4 _ScaleOffsetRes; // x: scale, y: offset, w: histogram pass width, h: histogram pass height

								        float _ExposureCompensation;


								        StructuredBuffer<uint> _Histogram;


								        float GetBinValue(uint index, float maxHistogramValue)

								        {

								            return float(_Histogram[index]) * maxHistogramValue;

								        }


								        // Done in the vertex shader

								        float FindMaxHistogramValue()

								        {

								            uint maxValue = 0u;


								            for (uint i = 0; i < HISTOGRAM_BINS; i++)

								            {

								                uint h = _Histogram[i];

								                maxValue = max(maxValue, h);

								            }


								            return float(maxValue);

								        }


								        void FilterLuminance(uint i, float maxHistogramValue, inout float4 filter)

								        {

								            float binValue = GetBinValue(i, maxHistogramValue);


								            // Filter dark areas

								            float offset = min(filter.z, binValue);

								            binValue -= offset;

								            filter.zw -= offset.xx;


								            // Filter highlights

								            binValue = min(filter.w, binValue);

								            filter.w -= binValue;


								            // Luminance at the bin

								            float luminance = GetLuminanceFromHistogramBin(float(i) / float(HISTOGRAM_BINS), _ScaleOffsetRes.xy);


								            filter.xy += float2(luminance * binValue, binValue);

								        }


								        float GetAverageLuminance(float maxHistogramValue)

								        {

								            // Sum of all bins

								            uint i;

								            float totalSum = 0.0;


								            UNITY_LOOP

								            for (i = 0; i < HISTOGRAM_BINS; i++)

								                totalSum += GetBinValue(i, maxHistogramValue);


								            // Skip darker and lighter parts of the histogram to stabilize the auto exposure

								            // x: filtered sum

								            // y: accumulator

								            // zw: fractions

								            float4 filter = float4(0.0, 0.0, totalSum * _Params.xy);


								            UNITY_LOOP

								            for (i = 0; i < HISTOGRAM_BINS; i++)

								                FilterLuminance(i, maxHistogramValue, filter);


								            // Clamp to user brightness range

								            return clamp(filter.x / max(filter.y, EPSILON), _Params.z, _Params.w);

								        }


								        float GetExposureMultiplier(float avgLuminance)

								        {

								            avgLuminance = max(EPSILON, avgLuminance);


								        #if AUTO_KEY_VALUE

								            half keyValue = 1.03 - (2.0 / (2.0 + log2(avgLuminance + 1.0)));

								        #else

								            half keyValue = _ExposureCompensation;

								        #endif


								            half exposure = keyValue / avgLuminance;


								            return exposure;

								        }


								        float InterpolateExposure(float newExposure, float oldExposure)

								        {

								            float delta = newExposure - oldExposure;

								            float speed = delta > 0.0 ? _Speed.x : _Speed.y;

								            float exposure = oldExposure + delta * (1.0 - exp2(-unity_DeltaTime.x * speed));

								            //float exposure = oldExposure + delta * (unity_DeltaTime.x * speed);

								            return exposure;

								        }


								        float4 FragAdaptProgressive(VaryingsDefault i) : SV_Target

								        {

								            float maxValue = 1.0 / FindMaxHistogramValue();

								            float avgLuminance = GetAverageLuminance(maxValue);

								            float exposure = GetExposureMultiplier(avgLuminance);

								            float prevExposure = tex2D(_MainTex, (0.5).xx);

								            exposure = InterpolateExposure(exposure, prevExposure);

								            return exposure.xxxx;

								        }


								        float4 FragAdaptFixed(VaryingsDefault i) : SV_Target

								        {

								            float maxValue = 1.0 / FindMaxHistogramValue();

								            float avgLuminance = GetAverageLuminance(maxValue);

								            float exposure = GetExposureMultiplier(avgLuminance);

								            return exposure.xxxx;

								        }


								        // ---- Editor stuff

								        int _DebugWidth;


								        struct VaryingsEditorHisto

								        {

								            float4 pos : SV_POSITION;

								            float2 uv : TEXCOORD0;

								            float maxValue : TEXCOORD1;

								            float avgLuminance : TEXCOORD2;

								        };


								        VaryingsEditorHisto VertEditorHisto(AttributesDefault v)

								        {

								            VaryingsEditorHisto o;

								            o.pos = UnityObjectToClipPos(v.vertex);

								            o.uv = v.texcoord.xy;

								            o.maxValue = 1.0 / FindMaxHistogramValue();

								            o.avgLuminance = GetAverageLuminance(o.maxValue);

								            return o;

								        }


								        float4 FragEditorHisto(VaryingsEditorHisto i) : SV_Target

								        {

								            const float3 kRangeColor = float3(0.05, 0.4, 0.6);

								            const float3 kAvgColor = float3(0.8, 0.3, 0.05);


								            float4 color = float4(0.0, 0.0, 0.0, 0.7);


								            uint ix = (uint)(round(i.uv.x * HISTOGRAM_BINS));

								            float bin = saturate(float(_Histogram[ix]) * i.maxValue);

								            float fill = step(i.uv.y, bin);


								            // Min / max brightness markers

								            float luminanceMin = GetHistogramBinFromLuminance(_Params.z, _ScaleOffsetRes.xy);

								            float luminanceMax = GetHistogramBinFromLuminance(_Params.w, _ScaleOffsetRes.xy);


								            color.rgb += fill.rrr;


								            if (i.uv.x > luminanceMin && i.uv.x < luminanceMax)

								            {

								                color.rgb = fill.rrr * kRangeColor;

								                color.rgb += kRangeColor;

								            }


								            // Current average luminance marker

								            float luminanceAvg = GetHistogramBinFromLuminance(i.avgLuminance, _ScaleOffsetRes.xy);

								            float avgPx = luminanceAvg * _DebugWidth;


								            if (abs(i.pos.x - avgPx) < 2)

								                color.rgb = kAvgColor;


								            return color;

								        }


								    ENDCG


								    SubShader

								    {

								        Cull Off ZWrite Off ZTest Always


								        Pass

								        {

								            CGPROGRAM


								                #pragma vertex VertDefault

								                #pragma fragment FragAdaptProgressive


								            ENDCG

								        }


								        Pass

								        {

								            CGPROGRAM


								                #pragma vertex VertDefault

								                #pragma fragment FragAdaptFixed


								            ENDCG

								        }


								        Pass

								        {

								            CGPROGRAM


								                #pragma vertex VertEditorHisto

								                #pragma fragment FragEditorHisto


								            ENDCG

								        }

								    }

								}