Schakai ENB with night eye

    //++++++++++++++++++++++++++++++++++++++++++++
    // ENBSeries effect file
    // visit http://enbdev.com for updates
    // Copyright (c) 2007-2013 Boris Vorontsov
    //++++++++++++++++++++++++++++++++++++++++++++



    //post processing mode. Change value (could be 1, 2, 3, 4). Every mode have own internal parameters, look below
    #ifndef POSTPROCESS
     #define POSTPROCESS    2
    #endif

    //use original game processing first, then mine
    //#define APPLYGAMECOLORCORRECTION
    // #########################
    // BEGIN NIGHTEYE  UTILITIES
    // #########################

    // ##########################################
    // INCLUDE ENHANCED ENB DIAGNOSTICS  HEADER
    // ##########################################
    #include "EnhancedENBDiagnostics.fxh"

            float3 RGBtoHSV(float3 c)
            {
                    float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
                    float4 p = lerp(float4(c.bg, K.wz), float4(c.gb, K.xy), step(c.b, c.g));
                    float4 q = lerp(float4(p.xyw, c.r), float4(c.r, p.yzx), step(p.x, c.r));

                    float d = q.x - min(q.w, q.y);
                    float e = 1.0e-10;
                    return float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
            }

            float3 HSVtoRGB(float3 c)
            {
                    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
                    float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
                    return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
            }

            float randomNoise(in float3 uvw)
            {
                    float3 noise = (frac(sin(dot(uvw ,float3(12.9898,78.233, 42.2442)*2.0)) * 43758.5453));
                    return abs(noise.x + noise.y + noise.z) * 0.3333;
            }

            float linStep(float minVal, float maxVal, float t)
            {
                    return saturate((t - minVal) / (maxVal - minVal));
            }
    // #########################
    // END NIGHTEYE  UTILITIES
    // #########################

    //+++++++++++++++++++++++++++++
    //internal parameters, can be modified
    //+++++++++++++++++++++++++++++
    //modify these values to tweak various color processing
    //POSTPROCESS 1
    float   EAdaptationMinV1=0.01;
    float   EAdaptationMaxV1=0.07;
    float   EContrastV1=0.95;
    float   EColorSaturationV1=1.0;
    float   EToneMappingCurveV1=6.0;

    //POSTPROCESS 2
    //Opethfeldt's NightDay separation

                                    //DAY
    float   EBrightnessV2Day=1.0;
    float   EAdaptationMinV2Day=0.04;
    float   EAdaptationMaxV2Day=0.15;
    float   EToneMappingCurveV2Day=8.0;
    float   EIntensityContrastV2Day=1.4;
    float   EToneMappingOversaturationV2Day=180.0;
    float   EColorSaturationV2Day=2.2;
                                    //NIGHT
    float   EBrightnessV2Night=1.0;
    float   EAdaptationMinV2Night=0.3;
    float   EAdaptationMaxV2Night=0.3;
    float   EToneMappingCurveV2Night=8.0;
    float   EIntensityContrastV2Night=1.4;
    float   EToneMappingOversaturationV2Night=180.0;
    float   EColorSaturationV2Night=1.4;
    //POSTPROCESS 3
    float   EAdaptationMinV3=0.05;
    float   EAdaptationMaxV3=0.125;
    float   EToneMappingCurveV3=4.0;
    float   EToneMappingOversaturationV3=60.0;

    //POSTPROCESS 4
    float   EAdaptationMinV4=0.2;
    float   EAdaptationMaxV4=0.125;
    float   EBrightnessCurveV4=0.7;
    float   EBrightnessMultiplierV4=0.45;
    float   EBrightnessToneMappingCurveV4=0.5;



    //parameters for ldr color correction, if enabled
    float   ECCGamma
    <
            string UIName="CC: Gamma";
            string UIWidget="Spinner";
            float UIMin=0.2;//not zero!!!
            float UIMax=5.0;
    > = {1.0};

    float   ECCInBlack
    <
            string UIName="CC: In black";
            string UIWidget="Spinner";
            float UIMin=0.0;
            float UIMax=1.0;
    > = {0.0};

    float   ECCInWhite
    <
            string UIName="CC: In white";
            string UIWidget="Spinner";
            float UIMin=0.0;
            float UIMax=1.0;
    > = {1.0};

    float   ECCOutBlack
    <
            string UIName="CC: Out black";
            string UIWidget="Spinner";
            float UIMin=0.0;
            float UIMax=1.0;
    > = {0.0};

    float   ECCOutWhite
    <
            string UIName="CC: Out white";
            string UIWidget="Spinner";
            float UIMin=0.0;
            float UIMax=1.0;
    > = {1.0};

    float   ECCBrightness
    <
            string UIName="CC: Brightness";
            string UIWidget="Spinner";
            float UIMin=0.0;
            float UIMax=10.0;
    > = {1.0};

    float   ECCContrastGrayLevel
    <
            string UIName="CC: Contrast gray level";
            string UIWidget="Spinner";
            float UIMin=0.01;
            float UIMax=0.99;
    > = {0.5};

    float   ECCContrast
    <
            string UIName="CC: Contrast";
            string UIWidget="Spinner";
            float UIMin=0.0;
            float UIMax=10.0;
    > = {1.0};

    float   ECCSaturation
    <
            string UIName="CC: Saturation";
            string UIWidget="Spinner";
            float UIMin=0.0;
            float UIMax=10.0;
    > = {1.0};

    float   ECCDesaturateShadows
    <
            string UIName="CC: Desaturate shadows";
            string UIWidget="Spinner";
            float UIMin=0.0;
            float UIMax=1.0;
    > = {0.0};

    float3  ECCColorBalanceShadows <
            string UIName="CC: Color balance shadows";
            string UIWidget="Color";
    > = {0.5, 0.5, 0.5};

    float3  ECCColorBalanceHighlights <
            string UIName="CC: Color balance highlights";
            string UIWidget="Color";
    > = {0.5, 0.5, 0.5};

    float3  ECCChannelMixerR <
            string UIName="CC: Channel mixer R";
            string UIWidget="Color";
    > = {1.0, 0.0, 0.0};

    float3  ECCChannelMixerG <
            string UIName="CC: Channel mixer G";
            string UIWidget="Color";
    > = {0.0, 1.0, 0.0};

    float3  ECCChannelMixerB <
            string UIName="CC: Channel mixer B";
            string UIWidget="Color";
    > = {0.0, 0.0, 1.0};

    // ##########################
    // BEGIN NIGHTEYE  PARAMETERS
    // ##########################
            // #### GENERAL PARAMETERS ####
                    bool nightEyeEnable <
                        string UIName = "Night Eye Enable";
                    > = {true};

            // #### CALIBRATION PARAMETERS ####
                    // #### Calibrate PARAMETERS ####
                    bool nightEyeCalibrate <
                        string UIName = "Night Eye Calibrate";
                    > = {false};

                    float   nightEyeDayMult
                    <
                        string UIName="Night Eye Day";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                        float UIStep=0.01;
                    > = {0.25};

                    float   nightEyeDayOffset
                    <
                        string UIName="Night Eye Day Offset";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                        float UIStep=0.01;
                    > = {-1.0};

                    float   nightEyeNightMult
                    <
                        string UIName="Night Eye Night";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                        float UIStep=0.01;
                    > = {1.34};

                    float   nightEyeNightOffset
                    <
                        string UIName="Night Eye Night Offset";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                        float UIStep=0.01;
                    > = {-1.0};

                    float   nightEyeInteriorMult
                    <
                        string UIName="Night Eye Interior";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                        float UIStep=0.01;
                    > = {1.34};

                    float   nightEyeInteriorOffset
                    <
                        string UIName="Night Eye Interior Offset";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                        float UIStep=0.01;
                    > = {-1.0};

            // #### VIGNETTE PARAMETERS ####
                    bool nightEyeVignetteEnable <
                        string UIName = "Night Eye Vignette Enable";
                    > = {false};

                    float   nightEyeVignetteMinDistance
                    <
                        string UIName="Night Eye Vignette Min Distance";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {0.5};

                    float   nightEyeVignetteMaxDistance
                    <
                        string UIName="Night Eye Vignette Max Distance";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {0.9};

                    float   nightEyeVignetteDistancePower
                    <
                        string UIName="Night Eye Vignette Distance Power";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {1.5};

                    float   nightEyeVignetteAspectRatio
                    <
                        string UIName="Night Eye Vignette Aspect Ratio Power";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {1.0};

            // #### COLOR CORRECT PARAMETERS ####
                    bool nightEyeCCEnable <
                        string UIName = "Night Eye CC Enable";
                    > = {true};

                    float   nightEyeGamma
                    <
                        string UIName="Night Eye Gamma";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {0.5};

                    float   nightEyeHueShift
                    <
                        string UIName="Night Eye Hue Shift";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                    > = {0.25};

                    float   nightEyeHueSpeed
                    <
                        string UIName="Night Eye Hue Speed";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                    > = {0.0};

                    float   nightEyeSaturationMult
                    <
                        string UIName="Night Eye Saturation";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {0.0};

                    float   nightEyeValueMult
                    <
                        string UIName="Night Eye Value";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                    > = {0.5};

                    float3  nightEyeTint <
                        string UIName="Night Eye Tint";
                        string UIWidget="Color";
                    > = {1.0, 1.0, 1.0};

                    float   nightEyeVignetteValueMult
                    <
                        string UIName="Night Eye Vignette Value Mult";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                    > = {0.0};

                    float   nightEyeVignetteMaskMult
                    <
                        string UIName="Night Eye Vignette Mask Mult";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                    > = {1.0};

            // #### BLOOM PARAMETERS ####
                    bool nightEyeBloomEnable <
                        string UIName = "Night Eye Bloom Enable";
                    > = {true};

                    float   nightEyeBloomGamma
                    <
                        string UIName="Night Eye Bloom Gamma";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {1.0};

                    float   nightEyeBloomHueShift
                    <
                        string UIName="Night Eye Bloom Hue Shift";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                    > = {0.5};

                    float   nightEyeBloomHueSpeed
                    <
                        string UIName="Night Eye Bloom Hue Speed";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                    > = {0.0};

                    float   nightEyeBloomSaturationMult
                    <
                        string UIName="Night Eye Bloom Saturation";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {1.0};

                    float   nightEyeBloomValueMult
                    <
                        string UIName="Night Eye Bloom Value";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                    > = {20.0};

                    float3  nightEyeBloomTint <
                        string UIName="Night Eye Bloom Tint";
                        string UIWidget="Color";
                    > = {1.0, 1.0, 1.0};

                    float   nightEyeBloomVignetteMult
                    <
                        string UIName="Night Eye Bloom Vignette Mult";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                    > = {1.0};

                    float   nightEyeBloomVignetteMaskMult
                    <
                        string UIName="Night Eye Bloom Vignette Mask Mult";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                    > = {1.0};

            // #### NOISE PARAMETERS ####
                    bool nightEyeNoiseEnable <
                        string UIName = "Night Eye Noise Enable";
                    > = {true};

                    float   nightEyeNoiseMult
                    <
                        string UIName="Night Eye Noise Mult";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                    > = {0.15};

                    float3  nightEyeNoiseTint <
                        string UIName="Night Eye Noise Tint";
                        string UIWidget="Color";
                    > = {1.0, 1.0, 1.0};

                    float   nightEyeNoiseVignetteMult
                    <
                        string UIName="Night Eye Noise Vignette Mult";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=100.0;
                    > = {1.0};

                    float   nightEyeNoiseVignetteMaskMult
                    <
                        string UIName="Night Eye Noise Vignette Mask Mult";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                    > = {1.0};

            // #### WARP PARAMETERS ####
                    bool nightEyeWarpEnable <
                        string UIName = "Night Eye Warp Enable";
                    > = {false};

                    float   nightEyeWarpMult
                    <
                        string UIName="Night Eye Warp Mult";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                    > = {25.0};

                    float   nightEyeWarpShift
                    <
                        string UIName="Night Eye Warp Shift";
                        string UIWidget="Spinner";
                        float UIMin=-100.0;
                        float UIMax=100.0;
                    > = {-0.05};

                    float   nightEyeWarpMinDistance
                    <
                        string UIName="Night Eye Warp Min Distance";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {0.4};

                    float   nightEyeWarpMaxDistance
                    <
                        string UIName="Night Eye Warp Max Distance";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {1.0};

                    float   nightEyeWarpDistancePower
                    <
                        string UIName="Night Eye Warp Distance Power";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {1.75};

                    float   nightEyeWarpAspectRatio
                    <
                        string UIName="Night Eye Warp Aspect Ratio Power";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {1.0};
            // #### Eyes PARAMETERS ####
                    bool nightEyeEnableEyes <
                        string UIName = "Night Eye Enable Eyes";
                    > = {false};

                    float   nightEyeEyesSeparation
                    <
                        string UIName="Night Eye Eyes Separation";
                        string UIWidget="Spinner";
                        float UIMin=0.0;
                        float UIMax=10.0;
                    > = {0.35};

    // ##########################
    // END NIGHTEYE  PARAMETERS
    // ##########################

    //+++++++++++++++++++++++++++++
    //external parameters, do not modify
    //+++++++++++++++++++++++++++++
    //keyboard controlled temporary variables (in some versions exists in the config file). Press and hold key 1,2,3...8 together with PageUp or PageDown to modify. By default all set to 1.0
    float4  tempF1; //0,1,2,3
    float4  tempF2; //5,6,7,8
    float4  tempF3; //9,0
    //x=generic timer in range 0..1, period of 16777216 ms (4.6 hours), w=frame time elapsed (in seconds)
    float4  Timer;
    //x=Width, y=1/Width, z=ScreenScaleY, w=1/ScreenScaleY
    float4  ScreenSize;
    //changes in range 0..1, 0 means that night time, 1 - day time
    float   ENightDayFactor;
    //changes 0 or 1. 0 means that exterior, 1 - interior
    float   EInteriorFactor;
    //changes in range 0..1, 0 means full quality, 1 lowest dynamic quality (0.33, 0.66 are limits for quality levels)
    float   EAdaptiveQualityFactor;
    //enb version of bloom applied, ignored if original post processing used
    float   EBloomAmount;
    //fov in degrees
    float   FieldOfView;


    texture2D texs0;//color
    texture2D texs1;//bloom skyrim
    texture2D texs2;//adaptation skyrim
    texture2D texs3;//bloom enb
    texture2D texs4;//adaptation enb
    texture2D texs7;//palette enb

    sampler2D _s0 = sampler_state
    {
            Texture   = <texs0>;
            MinFilter = POINT;//
            MagFilter = POINT;//
            MipFilter = NONE;//LINEAR;
            AddressU  = Clamp;
            AddressV  = Clamp;
            SRGBTexture=FALSE;
            MaxMipLevel=0;
            MipMapLodBias=0;
    };

    sampler2D _s1 = sampler_state
    {
            Texture   = <texs1>;
            MinFilter = LINEAR;//
            MagFilter = LINEAR;//
            MipFilter = NONE;//LINEAR;
            AddressU  = Clamp;
            AddressV  = Clamp;
            SRGBTexture=FALSE;
            MaxMipLevel=0;
            MipMapLodBias=0;
    };

    sampler2D _s2 = sampler_state
    {
            Texture   = <texs2>;
            MinFilter = LINEAR;//
            MagFilter = LINEAR;//
            MipFilter = NONE;//LINEAR;
            AddressU  = Clamp;
            AddressV  = Clamp;
            SRGBTexture=FALSE;
            MaxMipLevel=0;
            MipMapLodBias=0;
    };

    sampler2D _s3 = sampler_state
    {
            Texture   = <texs3>;
            MinFilter = LINEAR;//
            MagFilter = LINEAR;//
            MipFilter = NONE;//LINEAR;
            AddressU  = Clamp;
            AddressV  = Clamp;
            SRGBTexture=FALSE;
            MaxMipLevel=0;
            MipMapLodBias=0;
    };

    sampler2D _s4 = sampler_state
    {
            Texture   = <texs4>;
            MinFilter = LINEAR;//
            MagFilter = LINEAR;//
            MipFilter = NONE;//LINEAR;
            AddressU  = Clamp;
            AddressV  = Clamp;
            SRGBTexture=FALSE;
            MaxMipLevel=0;
            MipMapLodBias=0;
    };

    sampler2D _s7 = sampler_state
    {
            Texture   = <texs7>;
            MinFilter = LINEAR;
            MagFilter = LINEAR;
            MipFilter = NONE;
            AddressU  = Clamp;
            AddressV  = Clamp;
            SRGBTexture=FALSE;
            MaxMipLevel=0;
            MipMapLodBias=0;
    };

    struct VS_OUTPUT_POST
    {
            float4 vpos  : POSITION;
            float2 txcoord0 : TEXCOORD0;
    };
    struct VS_INPUT_POST
    {
            float3 pos  : POSITION;
            float2 txcoord0 : TEXCOORD0;
    };



    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    VS_OUTPUT_POST VS_Quad(VS_INPUT_POST IN)
    {
            VS_OUTPUT_POST OUT;

            OUT.vpos=float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0);

            OUT.txcoord0.xy=IN.txcoord0.xy;

            return OUT;
    }

    //skyrim shader specific externals, do not modify
    float4  _c1 : register(c1);
    float4  _c2 : register(c2);
    float4  _c3 : register(c3);
    float4  _c4 : register(c4);
    float4  _c5 : register(c5);

    float4 PS_D6EC7DD1(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR
    {
            float4 _oC0=0.0; //output

            float4 _c6=float4(0, 0, 0, 0);
            float4 _c7=float4(0.212500006, 0.715399981, 0.0720999986, 1.0);

            float4 r0;
            float4 r1;
            float4 r2;
            float4 r3;
            float4 r4;
            float4 r5;
            float4 r6;
            float4 r7;
            float4 r8;
            float4 r9;
            float4 r10;
            float4 r11;


            float4 _v0=0.0;

            _v0.xy=IN.txcoord0.xy;

                    // ################################## //
                    // BEGIN NIGHT EYE SETUP AND WARPING     //
                    // ################################## //
                    float2 unwarpedTxCoord = _v0.xy;

                    // The _c3.w value is from the game needs to be manipulated as
                    // below to get a value from 0 (night eye off) to 1 (night eye on).
                    // The Day, Night, and Interior GUI controls can be used to tune this.
                    float3 nightEyeDayFactor = clamp(_c3.w + nightEyeDayOffset, 0.0, 1.0) * nightEyeDayMult;
                    float3 nightEyeNightFactor = clamp(_c3.w + nightEyeNightOffset, 0.0, 1.0) * nightEyeNightMult;
                    float3 nightEyeInteriorFactor = clamp(_c3.w + nightEyeInteriorOffset, 0.0, 1.0) * nightEyeInteriorMult;

                    // Interpolate night/day/interior
                    float nightEyeT;;
                    nightEyeT = nightEyeDayFactor * ENightDayFactor +
                            nightEyeNightFactor * (1.0 - ENightDayFactor);
                    nightEyeT = nightEyeInteriorFactor * EInteriorFactor +
                            nightEyeT * (1.0 - EInteriorFactor);
                    float aspectRatio = ScreenSize.z;

                    float2 warpVector;
                    [branch] if(nightEyeEnable && nightEyeWarpEnable) // Warp
                    {
                            float2 warpedTxCoord = IN.txcoord0.xy;
                            float2 center = float2(0.5, 0.5);
                            float2 txCorrected = float2((warpedTxCoord.x - center.x) *
                                    aspectRatio / nightEyeWarpAspectRatio + center.x, warpedTxCoord.y);
                            float dist;
                            [branch]if(nightEyeEnableEyes) // Eyes (2 centers)
                            {
                                    float2 leftEyeCenter = float2(center.x - nightEyeEyesSeparation / 2.0, center.y);
                                    float2 rightEyeCenter = float2(center.x + nightEyeEyesSeparation / 2.0, center.y);
                                    float leftEyeDist = distance(txCorrected, leftEyeCenter);
                                    float rightEyeDist = distance(txCorrected, rightEyeCenter);
                                    float leftEyeDistT = linStep(nightEyeWarpMinDistance, nightEyeWarpMaxDistance, leftEyeDist);
                                    float rightEyeDistT = linStep(nightEyeWarpMinDistance, nightEyeWarpMaxDistance, rightEyeDist);
                                    if(leftEyeDist < rightEyeDist){
                                            dist = leftEyeDist;
                                            warpVector = (txCorrected - leftEyeCenter) / leftEyeDist;
                                    }
                                    else
                                    {
                                            dist = rightEyeDist;
                                            warpVector = (txCorrected - rightEyeCenter) / rightEyeDist;
                                    }
                            }
                            else
                            {
                                    dist = distance(txCorrected, center);
                                    warpVector = (txCorrected - center) / dist;
                            }

                            float distT = linStep(nightEyeWarpMinDistance, nightEyeWarpMaxDistance, dist);
                            distT = pow(distT, nightEyeWarpDistancePower);
                            warpedTxCoord += nightEyeT * nightEyeWarpMult * -0.05 *
                                    (distT + nightEyeWarpShift * 0.1) * warpVector;

                            // Mirror and wrap if warped beyond screen border
                            warpedTxCoord = fmod(abs(warpedTxCoord), 2.0);
                            if(warpedTxCoord.x > 1.0) warpedTxCoord.x = warpedTxCoord.x - 2.0 * (warpedTxCoord.x - 1.0);
                            if(warpedTxCoord.y > 1.0) warpedTxCoord.y = warpedTxCoord.y - 2.0 * (warpedTxCoord.y - 1.0);

                            _v0.xy = warpedTxCoord.xy;
                    }
                    // ################################ //
                    // END NIGHT EYE SETUP AND WARPING  //
                    // ################################ //

            r1=tex2D(_s0, _v0.xy); //color

            //apply bloom
            float4  xcolorbloom=tex2D(_s3, _v0.xy);

            xcolorbloom.xyz=xcolorbloom-r1;
            xcolorbloom.xyz=max(xcolorbloom, 0.0);
            r1.xyz+=xcolorbloom*EBloomAmount;

            r11=r1; //my bypass
            _oC0.xyz=r1.xyz; //for future use without game color corrections

    #ifdef APPLYGAMECOLORCORRECTION
            //apply original
        r0.x=1.0/_c2.y;
        r1=tex2D(_s2, _v0);
        r0.yz=r1.xy * _c1.y;
        r0.w=1.0/r0.y;
        r0.z=r0.w * r0.z;
        r1=tex2D(_s0, _v0);
        r1.xyz=r1 * _c1.y;
        r0.w=dot(_c7.xyz, r1.xyz);
        r1.w=r0.w * r0.z;
        r0.z=r0.z * r0.w + _c7.w;
        r0.z=1.0/r0.z;
        r0.x=r1.w * r0.x + _c7.w;
        r0.x=r0.x * r1.w;
        r0.x=r0.z * r0.x;
        if (r0.w<0) r0.x=_c6.x;
        r0.z=1.0/r0.w;
        r0.z=r0.z * r0.x;
        r0.x=saturate(-r0.x + _c2.x);
    //    r2=tex2D(_s3, _v0);//enb bloom
        r2=tex2D(_s1, _v0);//skyrim bloom
        r2.xyz=r2 * _c1.y;
        r2.xyz=r0.x * r2;
        r1.xyz=r1 * r0.z + r2;
        r0.x=dot(r1.xyz, _c7.xyz);
        r1.w=_c7.w;
        r2=lerp(r0.x, r1, _c3.x);
        r1=r0.x * _c4 - r2;
        r1=_c4.w * r1 + r2;
        r1=_c3.w * r1 - r0.y; //khajiit night vision _c3.w
        r0=_c3.z * r1 + r0.y;
        r1=-r0 + _c5;
        _oC0=_c5.w * r1 + r0;

    #endif //APPLYGAMECOLORCORRECTION

    /*
    #ifndef APPLYGAMECOLORCORRECTION
    //temporary fix for khajiit night vision, but it also degrade colors.
    //      r1=tex2D(_s2, _v0);
    //      r0.y=r1.xy * _c1.y;
            r1=_oC0;
            r1.xyz=r1 * _c1.y;
            r0.x=dot(r1.xyz, _c7.xyz);
            r2=lerp(r0.x, r1, _c3.x);
            r1=r0.x * _c4 - r2;
            r1=_c4.w * r1 + r2;
            r1=_c3.w * r1;// - r0.y;
            r0=_c3.z * r1;// + r0.y;
            r1=-r0 + _c5;
            _oC0=_c5.w * r1 + r0;
    #endif //!APPLYGAMECOLORCORRECTION
    */

            float4 color=_oC0;


            //adaptation in time
            float4  Adaptation=tex2D(_s4, 0.5);
            float   grayadaptation=max(max(Adaptation.x, Adaptation.y), Adaptation.z);
            xcolorbloom=tex2D(_s3, _v0.xy); //bloom
            color.xyz+=xcolorbloom.xyz*EBloomAmount;

    #if (POSTPROCESS==1)

            grayadaptation=max(grayadaptation, 0.0);
            grayadaptation=min(grayadaptation, 50.0);
            color.xyz=color.xyz/(grayadaptation*EAdaptationMaxV1+EAdaptationMinV1);//*tempF1.x

            float cgray=dot(color.xyz, float3(0.27, 0.67, 0.06));
            cgray=pow(cgray, EContrastV1);
            float3 poweredcolor=pow(color.xyz, EColorSaturationV1);
            float newgray=dot(poweredcolor.xyz, float3(0.27, 0.67, 0.06));
            color.xyz=poweredcolor.xyz*cgray/(newgray+0.0001);

            float3  luma=color.xyz;
            float   lumamax=300.0;
            color.xyz=(color.xyz * (1.0 + color.xyz/lumamax))/(color.xyz + EToneMappingCurveV1);

    #endif



    //Custom Night-Day separation
    #if (POSTPROCESS==2)

            float newEAdaptationMax=lerp(EAdaptationMaxV2Night, EAdaptationMaxV2Day, ENightDayFactor);
            float newEAdaptationMin=lerp(EAdaptationMinV2Night, EAdaptationMinV2Day, ENightDayFactor);
            float newEBrightnessV2=lerp(EBrightnessV2Night, EBrightnessV2Day, ENightDayFactor);
            float newEToneMappingCurve=lerp(EToneMappingCurveV2Night, EToneMappingCurveV2Day, ENightDayFactor);
            float newEIntensityContrastV2=lerp(EIntensityContrastV2Night, EIntensityContrastV2Day, ENightDayFactor);
            float newEToneMappingOversaturationV2=lerp(EToneMappingOversaturationV2Night, EToneMappingOversaturationV2Day, ENightDayFactor);
            float newEColorSaturationV2=lerp(EColorSaturationV2Night, EColorSaturationV2Day, ENightDayFactor);

            grayadaptation=max(grayadaptation, 0.0);
            grayadaptation=min(grayadaptation, 50.0);
            color.xyz=color.xyz/(grayadaptation*newEAdaptationMax+newEAdaptationMin);//*tempF1.x

            color.xyz*=(newEBrightnessV2);

            color.xyz+=0.000001;
            float3 xncol=normalize(color.xyz);
            float3 scl=color.xyz/xncol.xyz;
            scl=pow(scl, newEIntensityContrastV2);
            xncol.xyz=pow(xncol.xyz, newEColorSaturationV2);
            color.xyz=scl*xncol.xyz;

            float   lumamax=newEToneMappingOversaturationV2;

            color.xyz=(color.xyz * (1.0 + color.xyz/lumamax))/(color.xyz + newEToneMappingCurve);
    #endif


    #if (POSTPROCESS==3)

            grayadaptation=max(grayadaptation, 0.0);
            grayadaptation=min(grayadaptation, 50.0);
            color.xyz=color.xyz/(grayadaptation*EAdaptationMaxV3+EAdaptationMinV3);//*tempF1.x

            float   lumamax=EToneMappingOversaturationV3;
            color.xyz=(color.xyz * (1.0 + color.xyz/lumamax))/(color.xyz + EToneMappingCurveV3);

    #endif

    //color.xyz=tex2D(_s0, _v0.xy) + xcolorbloom.xyz*float3(0.7, 0.6, 1.0)*0.5;
    //color.xyz=tex2D(_s0, _v0.xy) + xcolorbloom.xyz*float3(0.7, 0.6, 1.0)*0.5;
    //color.xyz*=0.7;


    #if (POSTPROCESS==4)

            grayadaptation=max(grayadaptation, 0.0);
            grayadaptation=min(grayadaptation, 50.0);
            color.xyz=color.xyz/(grayadaptation*EAdaptationMaxV4+EAdaptationMinV4);

            float Y = dot(color.xyz, float3(0.299, 0.587, 0.114)); //0.299 * R + 0.587 * G + 0.114 * B;
            float U = dot(color.xyz, float3(-0.14713, -0.28886, 0.436)); //-0.14713 * R - 0.28886 * G + 0.436 * B;
            float V = dot(color.xyz, float3(0.615, -0.51499, -0.10001)); //0.615 * R - 0.51499 * G - 0.10001 * B;
            Y=pow(Y, EBrightnessCurveV4);
            Y=Y*EBrightnessMultiplierV4;
    //      Y=Y/(Y+EBrightnessToneMappingCurveV4);
    //      float   desaturatefact=saturate(Y*Y*Y*1.7);
    //      U=lerp(U, 0.0, desaturatefact);
    //      V=lerp(V, 0.0, desaturatefact);
            color.xyz=V * float3(1.13983, -0.58060, 0.0) + U * float3(0.0, -0.39465, 2.03211) + Y;

            color.xyz=max(color.xyz, 0.0);
            color.xyz=color.xyz/(color.xyz+EBrightnessToneMappingCurveV4);

    #endif



            //pallete texture (0.082+ version feature)
    #ifdef E_CC_PALETTE
            color.rgb=saturate(color.rgb);
            float3  brightness=Adaptation.xyz;//tex2D(_s4, 0.5);//adaptation luminance
    //      brightness=saturate(brightness);//old version from ldr games
            brightness=(brightness/(brightness+1.0));//new version
            brightness=max(brightness.x, max(brightness.y, brightness.z));//new version
            float3  palette;
            float4  uvsrc=0.0;
            uvsrc.y=brightness.r;
            uvsrc.x=color.r;
            palette.r=tex2Dlod(_s7, uvsrc).r;
            uvsrc.x=color.g;
            uvsrc.y=brightness.g;
            palette.g=tex2Dlod(_s7, uvsrc).g;
            uvsrc.x=color.b;
            uvsrc.y=brightness.b;
            palette.b=tex2Dlod(_s7, uvsrc).b;
            color.rgb=palette.rgb;
    #endif //E_CC_PALETTE



    #ifdef E_CC_PROCEDURAL
            float   tempgray;
            float4  tempvar;
            float3  tempcolor;
    /*
            //these replaced by "levels"
            //+++ gamma
            if (ECCGamma!=1.0)
            color=pow(color, 1.0/ECCGamma);

            //+++ brightness like in photoshop
            color=color+ECCAditiveBrightness;

            //+++ lightness
            tempvar.x=saturate(ELightness);
            tempvar.y=saturate(1.0+ECCLightness);
            color=tempvar.x*(1.0-color) + (tempvar.y*color);
    */
            //+++ levels like in photoshop, including gamma, lightness, additive brightness
            color=max(color-ECCInBlack, 0.0) / max(ECCInWhite-ECCInBlack, 0.0001);
            if (ECCGamma!=1.0) color=pow(color, ECCGamma);
            color=color*(ECCOutWhite-ECCOutBlack) + ECCOutBlack;

            //+++ brightness
            color=color*ECCBrightness;

            //+++ contrast
            color=(color-ECCContrastGrayLevel) * ECCContrast + ECCContrastGrayLevel;

            //+++ saturation
            tempgray=dot(color, 0.3333);
            color=lerp(tempgray, color, ECCSaturation);

            //+++ desaturate shadows
            tempgray=dot(color, 0.3333);
            tempvar.x=saturate(1.0-tempgray);
            tempvar.x*=tempvar.x;
            tempvar.x*=tempvar.x;
            color=lerp(color, tempgray, ECCDesaturateShadows*tempvar.x);

            //+++ color balance
            color=saturate(color);
            tempgray=dot(color, 0.3333);
            float2  shadow_highlight=float2(1.0-tempgray, tempgray);
            shadow_highlight*=shadow_highlight;
            color.rgb+=(ECCColorBalanceHighlights*2.0-1.0)*color * shadow_highlight.x;
            color.rgb+=(ECCColorBalanceShadows*2.0-1.0)*(1.0-color) * shadow_highlight.y;

            //+++ channel mixer
            tempcolor=color;
            color.r=dot(tempcolor, ECCChannelMixerR);
            color.g=dot(tempcolor, ECCChannelMixerG);
            color.b=dot(tempcolor, ECCChannelMixerB);
    #endif //E_CC_PROCEDURAL


            // ##############################
            // BEGIN NIGHTEYE  IMPLEMENTATION
            // ##############################
            if(nightEyeEnable)
            {
                    float vignette = 0.0;
                    if(nightEyeVignetteEnable) //  Add Vignette
                    {
                            float2 vignetteTxCoord = IN.txcoord0.xy;
                            float2 center = float2(0.5, 0.5);
                            float2 txCorrected = float2((vignetteTxCoord.x - center.x) *
                                    aspectRatio / nightEyeVignetteAspectRatio + center.x, vignetteTxCoord.y);
                            float dist;
                            [branch]if(nightEyeEnableEyes) // Eyes (2 centers)
                            {
                                    float2 leftEyeCenter = float2(center.x - nightEyeEyesSeparation / 2.0, center.y);
                                    float2 rightEyeCenter = float2(center.x + nightEyeEyesSeparation / 2.0, center.y);
                                    float leftEyeDist = distance(txCorrected, leftEyeCenter);
                                    float rightEyeDist = distance(txCorrected, rightEyeCenter);
                                    dist = min(leftEyeDist, rightEyeDist);
                            }
                            else
                            {
                                    dist = distance(txCorrected, center);
                            }
                            float distT = linStep(nightEyeVignetteMinDistance, nightEyeVignetteMaxDistance, dist);
                            vignette = pow(distT, nightEyeVignetteDistancePower);
                    }

                    if(nightEyeCCEnable) // Color Correct
                    {
                            float3 nightEye = color.xyz;
                            nightEye = pow(nightEye, nightEyeGamma);
                            nightEye = RGBtoHSV(nightEye);
                            nightEye.x += nightEyeHueShift + nightEyeHueSpeed * Timer.x * 1000.0;
                            nightEye.y *= nightEyeSaturationMult;
                            nightEye.z *= nightEyeValueMult;
                            nightEye = HSVtoRGB(nightEye);
                            nightEye *= nightEyeTint;
                            float mask = vignette;
                            if(nightEyeVignetteMaskMult < 0) mask = -1.0 * (1.0 - vignette);
                            mask *= nightEyeVignetteMaskMult;
                            nightEye *= (1.0 - mask) + (mask * nightEyeVignetteValueMult);
                            color.xyz = saturate((nightEye.xyz * nightEyeT) + (color.xyz * (1.0 - nightEyeT)));
                            //color.xyz = lerp(color.xyz, nightEye.xyz, t);
                    }

                    if(nightEyeBloomEnable) // Add Bloom
                    {
                            float3 nightEyeBloom = tex2D(_s3, _v0);
                            nightEyeBloom = pow(nightEyeBloom, nightEyeBloomGamma);
                            nightEyeBloom = RGBtoHSV(nightEyeBloom);
                            nightEyeBloom.x += nightEyeBloomHueShift + nightEyeBloomHueSpeed * Timer.x * 1000.0;
                            nightEyeBloom.y *= nightEyeBloomSaturationMult;
                            nightEyeBloom.z *= nightEyeBloomValueMult;
                            nightEyeBloom = HSVtoRGB(nightEyeBloom);
                            nightEyeBloom *= nightEyeBloomTint;
                            float mask = vignette;
                            if(nightEyeBloomVignetteMaskMult < 0) mask = -1.0 * (1.0 - vignette);
                            mask *= nightEyeBloomVignetteMaskMult;
                            nightEyeBloom *= (1.0 - mask) + (mask * nightEyeBloomVignetteMult);
                            nightEyeBloom *= nightEyeT;
                            color.xyz= saturate(color.xyz + nightEyeBloom.xyz);
                    }

                    if(nightEyeNoiseEnable) //  Add Noise
                    {
                            float3 noiseCoord = float3(_v0.x, _v0.y, Timer.x);
                            float3 nightEyeNoise = randomNoise(noiseCoord);
                            nightEyeNoise *= nightEyeNoiseMult;
                            nightEyeNoise *= nightEyeNoiseTint;
                            float mask = vignette;
                            if(nightEyeNoiseVignetteMaskMult < 0) mask = -1.0 * (1.0 - vignette);
                            mask *= nightEyeNoiseVignetteMaskMult;
                            nightEyeNoise *= mask + ((1.0 - mask) * nightEyeNoiseVignetteMult);
                            nightEyeNoise *= nightEyeT;
                            color.xyz = saturate(color.xyz + nightEyeNoise.xyz);
                    }
                    if(nightEyeCalibrate) //  Calibrate
                    {

                            float2 calibrateCoords = IN.txcoord0;
                            float4 calibrateText = 0;
                            calibrateText += float4(1.0, 1.0, 0.0, 1.0) *
                                    EED_drawFloatText(
                                    //ASCII N   i    g    h
                                    float4(78, 105, 103, 104),
                                    // ACII t    E   y    e
                                    float4(116, 69, 121, 101),
                                    nightEyeT,
                                    calibrateCoords,
                                    float2(0.85, 0),
                                    1.2,
                                    6 // precision
                            );

                            calibrateText += EED_drawFloatText(
                                    //ASCII N   i    g    h
                                    float4(78, 105, 103, 104),
                                    // ACII t    D   a    y
                                    float4(116, 68, 97, 121),
                                    ENightDayFactor,
                                    calibrateCoords,
                                    float2(0.85, 0.05),
                                    1.0,
                                    6 // precision
                            );

                            calibrateText += EED_drawFloatText(
                                    //ASCII I   n    t    e
                                    float4(73, 110, 116, 101),
                                    // ACII r    i   o    r
                                    float4(114, 105, 111, 114),
                                    EInteriorFactor,
                                    calibrateCoords,
                                    float2(0.85, 0.075),
                                    1.0,
                                    6 // precision
                            );

                            calibrateText += EED_drawCRegistersText(_c1, _c2, _c3, _c4, _c5,
                                    calibrateCoords, float2(0.85, 0.125), 1.0, 6);

                            color.xyz += calibrateText.xyz;
                    }

            }
            // ##############################
            // END NIGHTEYE  IMPLEMENTATION
            // ##############################

            _oC0.w=1.0;
            _oC0.xyz=color.xyz;
            return _oC0;
    }



    //switch between vanilla and mine post processing
    #ifndef ENB_FLIPTECHNIQUE
    technique Shader_D6EC7DD1
    #else
    technique Shader_ORIGINALPOSTPROCESS
    #endif

    {
            pass p0
            {
                    VertexShader  = compile vs_3_0 VS_Quad();
                    PixelShader  = compile ps_3_0 PS_D6EC7DD1();

                    ColorWriteEnable=ALPHA|RED|GREEN|BLUE;
                    ZEnable=FALSE;
                    ZWriteEnable=FALSE;
                    CullMode=NONE;
                    AlphaTestEnable=FALSE;
                    AlphaBlendEnable=FALSE;
                    SRGBWRITEENABLE=FALSE;
            }
    }



    //original shader of post processing
    #ifndef ENB_FLIPTECHNIQUE
    technique Shader_ORIGINALPOSTPROCESS
    #else
    technique Shader_D6EC7DD1

    #endif
    {
            pass p0
            {
                    VertexShader  = compile vs_3_0 VS_Quad();
                    PixelShader=
            asm
            {
    // Parameters:
    //   sampler2D Avg;
    //   sampler2D Blend;
    //   float4 Cinematic;
    //   float4 ColorRange;
    //   float4 Fade;
    //   sampler2D Image;
    //   float4 Param;
    //   float4 Tint;
    // Registers:
    //   Name         Reg   Size
    //   ------------ ----- ----
    //   ColorRange   c1       1
    //   Param        c2       1
    //   Cinematic    c3       1
    //   Tint         c4       1
    //   Fade         c5       1
    //   Image        s0       1
    //   Blend        s1       1
    //   Avg          s2       1
    //s0 bloom result
    //s1 color
    //s2 is average color

        ps_3_0
        def c6, 0, 0, 0, 0
        //was c0 originally
        def c7, 0.212500006, 0.715399981, 0.0720999986, 1
        dcl_texcoord v0.xy
        dcl_2d s0
        dcl_2d s1
        dcl_2d s2
        rcp r0.x, c2.y
        texld r1, v0, s2
        mul r0.yz, r1.xxyw, c1.y
        rcp r0.w, r0.y
        mul r0.z, r0.w, r0.z
        texld r1, v0, s1
        mul r1.xyz, r1, c1.y
        dp3 r0.w, c7, r1
        mul r1.w, r0.w, r0.z
        mad r0.z, r0.z, r0.w, c7.w
        rcp r0.z, r0.z
        mad r0.x, r1.w, r0.x, c7.w
        mul r0.x, r0.x, r1.w
        mul r0.x, r0.z, r0.x
        cmp r0.x, -r0.w, c6.x, r0.x
        rcp r0.z, r0.w
        mul r0.z, r0.z, r0.x
        add_sat r0.x, -r0.x, c2.x
        texld r2, v0, s0
        mul r2.xyz, r2, c1.y
        mul r2.xyz, r0.x, r2
        mad r1.xyz, r1, r0.z, r2
        dp3 r0.x, r1, c7
        mov r1.w, c7.w
        lrp r2, c3.x, r1, r0.x
        mad r1, r0.x, c4, -r2
        mad r1, c4.w, r1, r2
        mad r1, c3.w, r1, -r0.y
        mad r0, c3.z, r1, r0.y
        add r1, -r0, c5
        mad oC0, c5.w, r1, r0
            };
                    ColorWriteEnable=ALPHA|RED|GREEN|BLUE;
                    ZEnable=FALSE;
                    ZWriteEnable=FALSE;
                    CullMode=NONE;
                    AlphaTestEnable=FALSE;
                    AlphaBlendEnable=FALSE;
                    SRGBWRITEENABLE=FALSE;
        }
    }