Rudy ENB for Fallout New Vegas enbeffect.fx file

share shaders here
Post Reply
  • Author
  • Message
Offline
User avatar
*blah-blah-blah maniac*
Posts: 983
Joined: 09 Dec 2012, 00:29

Rudy ENB for Fallout New Vegas enbeffect.fx file

Code: Select all

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

// Rudy ENB for Fallout New Vegas
// NIGHTEYE CODE v2.5 by Scegielski author of "Enhanced ENB Night Eye" - http://www.nexusmods.com/newvegas/mods/55764/?



//========== GUI ==========================================

//========== NIGHT BRIGHTNESS GUI ==========================================

string NightBrightness = "!!! CHOOSE NIGHT BRIGHTNESS - 1.0 IS DEFAULT !!!";

float   fNightlevel
<
   string UIName="NIGHT BRIGHTNESS";
   string UIWidget="spinner";
   float UIMin=0.6;
   float UIMax=1.6;
   float UIStep=0.1;
> = {1.0};

//========== NIGHT BRIGHTNESS GUI END ==========================================

//========== INTERIORS BRIGHTNESS GUI ==========================================

string InteriorBrightness = "!!! CHOOSE INTERIORS BRIGHTNESS - 1.0 IS DEFAULT !!!";

float   fInteriorlevel
<
   string UIName="INTERIORS BRIGHTNESS";
   string UIWidget="spinner";
   float UIMin=0.6;
   float UIMax=1.6;
   float UIStep=0.1;
> = {1.0};

//========== INTERIORS BRIGHTNESS GUI END ==========================================

//========== LUT GUI ==========================================

string Lutchoose = "!!! CHOOSE LUT (1-4) - 1 IS DEFAULT !!!";

float   LUTSwitch
<
   string UIName="LUT NUMBER";
   string UIWidget="spinner";
   float UIMin=1.0;
   float UIMax=4.0;
   float UIStep=1.0;
> = {0.0};

//========== LUT GUI END ==========================================

string DayParam = "DAY";

	float	EBrightnessV2Day <
		string UIName="Brightness Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.70};

	float	EAdaptationMinV2Day <
		string UIName="Adaptation Min Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.04};

	float	EAdaptationMaxV2Day <
		string UIName="Adaptation Max Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.17};

	float	EToneMappingCurveV2Day <
		string UIName="ToneMapping Curve Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {1.65};

	float	EIntensityContrastV2Day <
		string UIName="Intensity Contrast Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {1.30};

	float	EToneMappingOversaturationV2Day <
		string UIName="ToneMapping Oversaturation Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=200.0;
	> = {200.0};

	float	EColorSaturationV2Day <
		string UIName="Color Saturation Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {1.45};


string NightParam = "NIGHT";

	float	EBrightnessV2Night <
		string UIName="Brightness Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.45};

	float	EAdaptationMinV2Night <
		string UIName="Adaptation Min Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.035};

	float	EAdaptationMaxV2Night <
		string UIName="Adaptation Max Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.1};

	float	EToneMappingCurveV2Night <
		string UIName="ToneMapping Curve Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {2.0};

	float	EIntensityContrastV2Night <
		string UIName="Intensity Contrast Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {1.1};

	float	EToneMappingOversaturationV2Night <
		string UIName="ToneMapping Oversaturation Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=200.0;
	> = {60.0};

	float	EColorSaturationV2Night <
		string UIName="Color Saturation Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.9};


string InteriorsParam = "INTERIORS";

	float	EBrightnessV2Interior <
		string UIName="Brightness Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.3};

	float	EAdaptationMinV2Interior <
		string UIName="Adaptation Min Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.036};

	float	EAdaptationMaxV2Interior <
		string UIName="Adaptation Max Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.2};

	float	EToneMappingCurveV2Interior <
		string UIName="ToneMapping Curve Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {1.7};

	float	EIntensityContrastV2Interior <
		string UIName="Intensity Contrast Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {0.9};

	float	EToneMappingOversaturationV2Interior <
		string UIName="ToneMapping Oversaturation Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=200.0;
	> = {160.0};

	float	EColorSaturationV2Interior <
		string UIName="Color Saturation Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=50.0;
	> = {1.05};

//========== DITHERING ==========================================

#define DITHER_METHOD 2 //0==linear, 1==srgb, 2==energy-preserved
	
string DitherHeader = "DITHER";
bool	HHKingDither
<
	string UIName = "Dither: Enable/Disable";
> = {true};

bool	HHDitherAdapt
<
	string UIName = "Dither: Adaptation";
> = {true};

float	dither_amp
<
	string UIName="Dither: Amplitude";
	string UIWidget="Spinner";
	float UIMin=0.0;
	float UIMax=10.0;
> = {1.0};

//========== DITHERING ==========================================


			
//parameters for ldr color correction, if enabled

string LdrCC = "PCC";
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  UTILITIES
// #########################
#define ENABLE_CALIBRATION
#define	ENABLE_CALIBRATION_REGISTERS
//#define ENABLE_WARPING
//#define ENABLE_VIGNETTE
#define ENABLE_NOISE
//#define ENABLE_LENS
#define ENABLE_SCANLINES
#define ENABLE_NIGHT_VISION
#define ENABLE_THERMAL_VISION
#define ENABLE_EMI_VISION
//#define ENABLE_GENERAL_IMOD

#include "EnhancedENBDiagnostics.fxh"

float3 EENV_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 EENV_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 EENV_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 EENV_linStep(float minVal, float maxVal, float t)
{
	return saturate((t - minVal) / (maxVal - minVal));
}

texture2D EENV_LensMask
<
	string ResourceName="enblensmask.png";
>;

sampler2D EENV_LensMaskSampler = sampler_state
{
	Texture = <EENV_LensMask>;
	MinFilter = LINEAR;
	MagFilter = LINEAR;
};
// #########################
// END NIGHTEYE  UTILITIES
// #########################

string Param06 = "NIGHTEYE";
// ##########################
// BEGIN NIGHTEYE  PARAMETERS
// ##########################
//{
//{ MASTER ENABLE
	bool EENV_Enable <
		string UIName = "EENV Master Enable";
	> = {true};
	bool EENV_Game_CC_Override_Enable <
		string UIName = "EENV Game CC Override Enable";
	> = {false};
//}

//{ CALIBRATION DISPLAY
#ifdef ENABLE_CALIBRATION
	bool EENV_CalibrateEnable <
		string UIName = "EENV Calibrate Display";
	> = {false};
	
	float EENV_CalibratePosX
	<
		string UIName="EENV Calibrate Position X";
		string UIWidget="Spinner";
		float UIMin=-1.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.67};
	
	float EENV_CalibratePosY
	<
		string UIName="EENV Calibrate Position Y";
		string UIWidget="Spinner";
		float UIMin=-1.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {-0.10};
#endif // ENABLE_CALIBRATION
//}
			
//{ NIGHT VISION
#ifdef ENABLE_NIGHT_VISION
//{		Enable
	bool EENV_nightVisionEnable <
		string UIName = "EENV Night Vision Enable";
	> = {true};
	//}
//{		Calibration
//{			Offset	
	float EENV_nightVisionCalDayOffset
	<
		string UIName="EENV Night Vision Cal Day Offset";
		string UIWidget="Spinner";
		float UIMin=-10.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {-2.0};
	float EENV_nightVisionCalNightOffset
	<
		string UIName="EENV Night Vision Cal Night Offset";
		string UIWidget="Spinner";
		float UIMin=-10.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {-2.0};
	float EENV_nightVisionCalInteriorOffset
	<
		string UIName="EENV Night Vision Cal Interior Offset";
		string UIWidget="Spinner";
		float UIMin=-10.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {-2.0};
	//}
//{			Mult
	float EENV_nightVisionCalDayMult
	<
		string UIName="EENV Night Vision Cal Day Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {0.5};
	float EENV_nightVisionCalNightMult
	<
		string UIName="EENV Night Vision Cal Night Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {0.5};
	float EENV_nightVisionCalInteriorMult
	<
		string UIName="EENV Night Vision Cal Interior Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {0.5};
	//}
//{			Use Color
	bool EENV_nightVisionCalUseColor <
		string UIName = "EENV Night Vision Cal Use Color";
	> = {true};	
	float EENV_nightVisionCalColorR
	<
		string UIName="EENV Night Vision Cal Color R";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.28};	
	float EENV_nightVisionCalColorG
	<
		string UIName="EENV Night Vision Cal Color G";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.65};
	float EENV_nightVisionCalColorB
	<
		string UIName="EENV Night Vision Cal Color B";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.38};
	float EENV_nightVisionCalRangeMin
	<
		string UIName="EENV Night Vision Cal Color Range Min";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.05};
	float EENV_nightVisionCalRangeMax
	<
		string UIName="EENV Night Vision Cal Color Range Max";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.2};
	//}
//}
//{		Settings
//{ 		Color Correction
	float EENV_nightVisionGammaDay
	<
		string UIName="EENV Night Vision Gamma Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.7};
	float EENV_nightVisionGammaNight
	<
		string UIName="EENV Night Vision Gamma Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.6};
	float EENV_nightVisionGammaInterior
	<
		string UIName="EENV Night Vision Gamma Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_nightVisionHue
	<
		string UIName="EENV Night Vision Hue";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
	> = {0.0};
	float EENV_nightVisionSaturationDay
	<
		string UIName="EENV Night Vision Saturation Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_nightVisionSaturationNight
	<
		string UIName="EENV Night Vision Saturation Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_nightVisionSaturationInterior
	<
		string UIName="EENV Night Vision Saturation Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_nightVisionValueDay
	<
		string UIName="EENV Night Vision Value Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_nightVisionValueNight
	<
		string UIName="EENV Night Vision Value Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_nightVisionValueInterior
	<
		string UIName="EENV Night Vision Value Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	//}
//{			Bloom
	float EENV_nightVisionGameBloom
	<
		string UIName="EENV Night Vision Game Bloom";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.5};
	float EENV_nightVisionENBBloom
	<
		string UIName="EENV Night Vision ENB Bloom";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.0};
	float EENV_nightVisionENBBloomGamma
	<
		string UIName="EENV Night Vision ENB Bloom Gamma";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_nightVisionENBBloomTint
	<
		string UIName="EENV Night Vision ENB Bloom Tint";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
	> = {1.0};
	//}
//{			Vignette
	#ifdef ENABLE_VIGNETTE
		float EENV_nightVisionVignette
		<
			string UIName="EENV Night Vision Vignette";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=1.0;
		> = {0.0};
	#else
		float EENV_nightVisionVignette = 0;
	#endif // ENABLE_VIGNETTE
	//}
//{			Warping
	#ifdef ENABLE_WARPING
		float EENV_nightVisionWarp
		<
			string UIName="EENV Night Vision Warp";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
	#else
		float EENV_nightVisionWarp = 0;
	#endif // ENABLE_WARPING
	//}
//{			Noise
	#ifdef ENABLE_NOISE
		float EENV_nightVisionNoise
		<
			string UIName="EENV Night Vision Noise";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
	#else
		float EENV_nightVisionNoise = 0;
	#endif // ENABLE_NOISE
	//}
//{			Lens
	#ifdef ENABLE_LENS
		float EENV_nightVisionLensDay
		<
			string UIName="EENV Night Vision Lens Day";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float EENV_nightVisionLensNight
		<
			string UIName="EENV Night Vision Lens Night";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {1.0};
		float EENV_nightVisionLensInterior
		<
			string UIName="EENV Night Vision Lens Interior";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {1.0};
	#else
		float EENV_nightVisionLensDay = 0;
		float EENV_nightVisionLensNight = 0;
		float EENV_nightVisionLensInterior = 0;
	#endif // ENABLE_LENS
	//}
//{			Scanlines
	#ifdef ENABLE_SCANLINES
		float EENV_nightVisionScanlinesDay
		<
			string UIName="EENV Night Vision Scanlines Day";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float EENV_nightVisionScanlinesNight
		<
			string UIName="EENV Night Vision Scanlines Night";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float EENV_nightVisionScanlinesInterior
		<
			string UIName="EENV Night Vision Scanlines Interior";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float4 EENV_nightVisionScanlinesColor <
			string UIName="EENV Night Vision Scanlines Color";
			string UIWidget="Color";
		> = {0.702, 0.529, 0, 1};
	#else
		float EENV_nightVisionScanlinesDay = 0;
		float EENV_nightVisionScanlinesNight = 0;
		float EENV_nightVisionScanlinesInterior = 0;
		float4 EENV_nightVisionScanlinesColor = float4(1, 1, 1, 1);
	#endif // ENABLE_SCANLINES
	//}
//}
#else
float EENV_nightVisionWarp = 0;
#endif // ENABLE_NIGHT_VISION
//}

//{ THERMAL VISION
#ifdef ENABLE_THERMAL_VISION
//{		Enable
	bool EENV_thermalVisionEnable <
		string UIName = "EENV Thermal Vision Enable";
	> = {true};
//}
//{		Calibration
//{			Offset
	float EENV_thermalVisionCalDayOffset
	<
		string UIName="EENV Thermal Vision Cal Day Offset";
		string UIWidget="Spinner";
		float UIMin=-10.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {-0.2};
	float EENV_thermalVisionCalNightOffset
	<
		string UIName="EENV Thermal Vision Cal Night Offset";
		string UIWidget="Spinner";
		float UIMin=-10.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {-0.2};
	float EENV_thermalVisionCalInteriorOffset
	<
		string UIName="EENV Thermal Vision Cal Interior Offset";
		string UIWidget="Spinner";
		float UIMin=-10.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {-0.2};
	//}
//{			Mult
	float EENV_thermalVisionCalDayMult
	<
		string UIName="EENV Thermal Vision Cal Day Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {2.1};
	float EENV_thermalVisionCalNightMult
	<
		string UIName="EENV Thermal Vision Cal Night Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {2.1};
	float EENV_thermalVisionCalInteriorMult
	<
		string UIName="EENV Thermal Vision Cal Interior Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {2.1};
	//}
//{			Use Color
	bool EENV_thermalVisionCalUseColor <
		string UIName = "EENV Thermal Vision Cal Use Color";
	> = {true};	
	float EENV_thermalVisionCalColorR
	<
		string UIName="EENV Thermal Vision Cal Color R";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.0};	
	float EENV_thermalVisionCalColorG
	<
		string UIName="EENV Thermal Vision Cal Color G";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.0};
	float EENV_thermalVisionCalColorB
	<
		string UIName="EENV Thermal Vision Cal Color B";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.6};
	float EENV_thermalVisionCalRangeMin
	<
		string UIName="EENV Thermal Vision Cal Color Range Min";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.1};
	float EENV_thermalVisionCalRangeMax
	<
		string UIName="EENV Thermal Vision Cal Color Range Max";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.2};
	//}
//}
//{		Settings
//{			Color Correction
	float EENV_thermalVisionGammaDay
	<
		string UIName="EENV Thermal Vision Gamma Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.5};
	float EENV_thermalVisionGammaNight
	<
		string UIName="EENV Thermal Vision Gamma Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.5};
	float EENV_thermalVisionGammaInterior
	<
		string UIName="EENV Thermal Vision Gamma Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.5};
	float EENV_thermalVisionHue
	<
		string UIName="EENV Thermal Vision Hue";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
	> = {0.0};
	float EENV_thermalVisionSaturationDay
	<
		string UIName="EENV Thermal Vision Saturation Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {2.0};
	float EENV_thermalVisionSaturationNight
	<
		string UIName="EENV Thermal Vision Saturation Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {2.0};
	float EENV_thermalVisionSaturationInterior
	<
		string UIName="EENV Thermal Vision Saturation Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {2.0};
	float EENV_thermalVisionValueDay
	<
		string UIName="EENV Thermal Vision Value Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_thermalVisionValueNight
	<
		string UIName="EENV Thermal Vision Value Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_thermalVisionValueInterior
	<
		string UIName="EENV Thermal Vision Value Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	//}
//{			Bloom
	float EENV_thermalVisionGameBloom
	<
		string UIName="EENV Thermal Vision Game Bloom";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_thermalVisionENBBloom
	<
		string UIName="EENV Thermal Vision ENB Bloom";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.5};
	float EENV_thermalVisionENBBloomGamma
	<
		string UIName="EENV Thermal Vision ENB Bloom Gamma";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_thermalVisionENBBloomTint
	<
		string UIName="EENV Thermal Vision ENB Bloom Tint";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
	> = {0.0};
	//}
//{			Vignette
	#ifdef ENABLE_VIGNETTE
		float EENV_thermalVisionVignette
		<
			string UIName="EENV Thermal Vision Vignette";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=100.0;
		> = {0.0};
	#else
		float EENV_thermalVisionVignette = 0;
	#endif // ENABLE_VIGNETTE
	//}
//{			Warping
	#ifdef ENABLE_WARPING
		float EENV_thermalVisionWarp
		<
			string UIName="EENV Thermal Vision Warp";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
	#else
		float EENV_thermalVisionWarp = 0;
	#endif // ENABLE_WARPING
	//}
//{			Noise
	#ifdef ENABLE_NOISE
		float EENV_thermalVisionNoise
		<
			string UIName="EENV Thermal Vision Noise";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=100.0;
		> = {0.0};
	#else
		float EENV_thermalVisionNoise = 0;
	#endif
	//}
//{			Lens
	#ifdef ENABLE_LENS
		float EENV_thermalVisionLensDay
		<
			string UIName="EENV Thermal Vision Lens Day";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float EENV_thermalVisionLensNight
		<
			string UIName="EENV Thermal Vision Lens Night";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float EENV_thermalVisionLensInterior
		<
			string UIName="EENV Thermal Vision Lens Interior";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
	#else
		float EENV_thermalVisionLensDay = 0;
		float EENV_thermalVisionLensNight = 0;
		float EENV_thermalVisionLensInterior = 0;
	#endif // ENABLE_LENS
	//}
//{			Scalines
	#ifdef ENABLE_SCANLINES
		float EENV_thermalVisionScanlinesDay
		<
			string UIName="EENV Thermal Vision Scanlines Day";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
		float EENV_thermalVisionScanlinesNight
		<
			string UIName="EENV Thermal Vision Scanlines Night";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
		float EENV_thermalVisionScanlinesInterior
		<
			string UIName="EENV Thermal Vision Scanlines Interior";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
		float4 EENV_thermalVisionScanlinesColor <
			string UIName="EENV Thermal Vision Scanlines Color";
			string UIWidget="Color";
		> = {0.702, 0.529, 0, 1};
	#else
		float EENV_thermalVisionScanlinesDay = 0;
		float EENV_thermalVisionScanlinesNight = 0;
		float EENV_thermalVisionScanlinesInterior = 0;
		float4 EENV_thermalVisionScanlinesColor = float4(1, 1, 1, 1);
	#endif // ENABLE_SCANLINES
	//}
//}
#else
float EENV_thermalVisionWarp = 0;
#endif // ENABLE_THERMAL_VISION
//}

//{ EMI VISION
#ifdef ENABLE_EMI_VISION
//{		Enable
	bool EENV_emiVisionEnable <
		string UIName = "EENV EMI Vision Enable";
	> = {true};
//}
//{		Calibration
//{			Offset
	float EENV_emiVisionCalDayOffset
	<
		string UIName="EENV EMI Vision Cal Day Offset";
		string UIWidget="Spinner";
		float UIMin=-100.0;
		float UIMax=100.0;
		float UIStep=0.01;
	> = {-0.22};
	float EENV_emiVisionCalNightOffset
	<
		string UIName="EENV EMI Vision Cal Night Offset";
		string UIWidget="Spinner";
		float UIMin=-100.0;
		float UIMax=100.0;
		float UIStep=0.01;
	> = {-0.22};
	float EENV_emiVisionCalInteriorOffset
	<
		string UIName="EENV EMI Vision Cal Interior Offset";
		string UIWidget="Spinner";
		float UIMin=-100.0;
		float UIMax=100.0;
		float UIStep=0.01;
	> = {-0.22};
	//}
//{			Mult
	float EENV_emiVisionCalDayMult
	<
		string UIName="EENV EMI Vision Cal Day Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=100.0;
		float UIStep=0.01;
	> = {3.5};
	float EENV_emiVisionCalNightMult
	<
		string UIName="EENV EMI Vision Cal Night Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=100.0;
		float UIStep=0.01;
	> = {3.5};
	float EENV_emiVisionCalInteriorMult
	<
		string UIName="EENV EMI Vision Cal Interior Mult";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=100.0;
		float UIStep=0.01;
	> = {3.5};
	//}
//{			Use Color
	bool EENV_emiVisionCalUseColor <
		string UIName = "EENV EMI Vision Cal Use Color";
	> = {true};	
	float EENV_emiVisionCalColorR
	<
		string UIName="EENV EMI Vision Cal Color R";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.27};	
	float EENV_emiVisionCalColorG
	<
		string UIName="EENV EMI Vision Cal Color G";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.6};
	float EENV_emiVisionCalColorB
	<
		string UIName="EENV EMI Vision Cal Color B";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.92};
	float EENV_emiVisionCalRangeMin
	<
		string UIName="EENV EMI Vision Cal Color Range Min";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.01};
	float EENV_emiVisionCalRangeMax
	<
		string UIName="EENV EMI Vision Cal Color Range Max";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.1};
	
	// Interior EMI Color Calibration
	float EENV_emiVisionCalColorInteriorR
	<
		string UIName="EENV EMI Vision Cal Color Interior R";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.4341};	
	float EENV_emiVisionCalColorInteriorG
	<
		string UIName="EENV EMI Vision Cal Color Interior G";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.6285};
	float EENV_emiVisionCalColorInteriorB
	<
		string UIName="EENV EMI Vision Cal Color Interior B";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.7927};
	float EENV_emiVisionCalRangeInteriorMin
	<
		string UIName="EENV EMI Vision Cal Color Range Interior Min";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.01};
	float EENV_emiVisionCalRangeInteriorMax
	<
		string UIName="EENV EMI Vision Cal Color Range Interior Max";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
		float UIStep=0.01;
	> = {0.1};
	//}
//}
//{		Settings
//{			Color Correction
	float EENV_emiVisionGammaDay
	<
		string UIName="EENV EMI Vision Gamma Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.5};
	float EENV_emiVisionGammaNight
	<
		string UIName="EENV EMI Vision Gamma Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.5};
	float EENV_emiVisionGammaInterior
	<
		string UIName="EENV EMI Vision Gamma Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_emiVisionHue
	<
		string UIName="EENV EMI Vision Hue";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
	> = {0.0};
	float EENV_emiVisionSaturationDay
	<
		string UIName="EENV EMI Vision Saturation Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_emiVisionSaturationNight
	<
		string UIName="EENV EMI Vision Saturation Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_emiVisionSaturationInterior
	<
		string UIName="EENV EMI Vision Saturation Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.75};
	float EENV_emiVisionValueDay
	<
		string UIName="EENV EMI Vision Value Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_emiVisionValueNight
	<
		string UIName="EENV EMI Vision Value Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_emiVisionValueInterior
	<
		string UIName="EENV EMI Vision Value Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	//}
//{			Bloom
	float EENV_emiVisionGameBloom
	<
		string UIName="EENV EMI Vision Game Bloom";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_emiVisionENBBloomDay
	<
		string UIName="EENV EMI Vision ENB Bloom Day";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.0};
	float EENV_emiVisionENBBloomNight
	<
		string UIName="EENV EMI Vision ENB Bloom Night";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.0};
	float EENV_emiVisionENBBloomInterior
	<
		string UIName="EENV EMI Vision ENB Bloom Interior";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.0};
	float EENV_emiVisionENBBloomGamma
	<
		string UIName="EENV EMI Vision ENB Bloom Gamma";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_emiVisionENBBloomTint
	<
		string UIName="EENV EMI Vision ENB Bloom Tint";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	//}
//{			Vignette
	#ifdef ENABLE_VIGNETTE
		float EENV_emiVisionVignette
		<
			string UIName="EENV EMI Vision Vignette";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=100.0;
		> = {0.0};
	#else
		float EENV_emiVisionVignette = 0;
	#endif // ENABLE_VIGNETTE
	//}
//{			Warping
	#ifdef ENABLE_WARPING
		float EENV_emiVisionWarp
		<
			string UIName="EENV EMI Vision Warp";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
	#else
		float EENV_emiVisionWarp = 0;
	#endif // ENABLE_WARPING
	//}
//{			Noise
	#ifdef ENABLE_NOISE
		float EENV_emiVisionNoise
		<
			string UIName="EENV EMI Vision Noise";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
	#else
		float EENV_emiVisionNoise = 0;
	#endif // ENABLE_NOISE
	//}
//{			Lens
	#ifdef ENABLE_LENS
		float EENV_emiVisionLensDay
		<
			string UIName="EENV EMI Vision Lens Day";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float EENV_emiVisionLensNight
		<
			string UIName="EENV EMI Vision Lens Night";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float EENV_emiVisionLensInterior
		<
			string UIName="EENV EMI Vision Lens Interior";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
	#else
		float EENV_emiVisionLensDay = 0;
		float EENV_emiVisionLensNight = 0;
		float EENV_emiVisionLensInterior = 0;
	#endif // ENABLE_LENS
	//}
//{			Scanlines
	#ifdef ENABLE_SCANLINES
		float EENV_emiVisionScanlinesDay
		<
			string UIName="EENV EMI Vision Scanlines Day";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
		float EENV_emiVisionScanlinesNight
		<
			string UIName="EENV EMI Vision Scanlines Night";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
		float EENV_emiVisionScanlinesInterior
		<
			string UIName="EENV EMI Vision Scanlines Interior";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
		float4 EENV_emiVisionScanlinesColor <
			string UIName="EENV EMI Vision Scanlines Color";
			string UIWidget="Color";
		> = {0.702, 0.529, 0, 1};
	#else
		float EENV_emiVisionScanlinesDay = 0;
		float EENV_emiVisionScanlinesNight = 0; 
		float EENV_emiVisionScanlinesInterior = 0;
		float4 EENV_emiVisionScanlinesColor = float4(1, 1, 1, 1);
	#endif
	//}
//}
#else
float EENV_emiVisionWarp = 0;
#endif // ENABLE_EMI_VISION
//}

//{  GENERAL IMOD CALIBRATION ####
#ifdef ENABLE_GENERAL_IMOD
	bool EENV_generalImodEnable <
		string UIName = "EENV General IMOD Enable";
	> = {true};
	float EENV_generalImodC19Min
	<
		string UIName="EENV General IMOD _c19.w Min";
		string UIWidget="Spinner";
		float UIMin=-0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {1.2};
	float EENV_generalImodC19Max
	<
		string UIName="EENV General IMOD _c19.w Max";
		string UIWidget="Spinner";
		float UIMin=-0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {2.0};
	float EENV_generalImodC20Min
	<
		string UIName="EENV General IMOD _c20.w Min";
		string UIWidget="Spinner";
		float UIMin=-0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {0.2};
	float EENV_generalImodC20Max
	<
		string UIName="EENV General IMOD _c20.w Max";
		string UIWidget="Spinner";
		float UIMin=-0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {0.5};
	float EENV_generalImodC22Min
	<
		string UIName="EENV General IMOD _c22.w Min";
		string UIWidget="Spinner";
		float UIMin=-0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {0.05};
	float EENV_generalImodC22Max
	<
		string UIName="EENV General IMOD _c22.w Max";
		string UIWidget="Spinner";
		float UIMin=-0.0;
		float UIMax=10.0;
		float UIStep=0.01;
	> = {0.2};
	// #### GENERAL IMOD SETTINGS ####
	float EENV_generalImodGamma
	<
		string UIName="EENV General IMOD Gamma";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_generalImodHue
	<
		string UIName="EENV General IMOD Hue";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=1.0;
	> = {0.0};
	float EENV_generalImodSaturation
	<
		string UIName="EENV General IMOD Saturation";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
		float EENV_generalImodValue
	<
		string UIName="EENV General IMOD Value";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_generalImodGameBloom
	<
		string UIName="EENV General IMOD Game Bloom";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.5};
	float EENV_generalImodENBBloom
	<
		string UIName="EENV General IMOD ENB Bloom";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {0.0};
	float EENV_generalImodENBBloomGamma
	<
		string UIName="EENV General IMOD ENB Bloom Gamma";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
	float EENV_generalImodENBBloomTint
	<
		string UIName="EENV General IMOD ENB Bloom Tint";
		string UIWidget="Spinner";
		float UIMin=0.0;
		float UIMax=10.0;
	> = {1.0};
#endif // ENABLE_GENERAL_IMOD
//}

//{  EFFECT CONTROLS ####
#ifdef ENABLE_NOISE
	bool EENV_noiseEnable <
		string UIName = "EENV Noise Enable";
	> = {true};
#endif // ENABLE_NOISE
	
	// Vignette
	#ifdef ENABLE_VIGNETTE
		bool EENV_vignetteEnable <
			string UIName = "EENV Vignette Enable";
		> = {true};
		float EENV_vignetteMinDistance
		<
			string UIName="EENV Vignette Min Distance";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.5};

		float EENV_vignetteMaxDistance
		<
			string UIName="EENV Vignette Max Distance";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {1.0};

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

		float EENV_vignetteAspectRatio
		<
			string UIName="EENV Vignette Aspect Ratio Power";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {1.66};
	#endif // ENABLE_VIGNETTE
	
	// Warp
	#ifdef ENABLE_WARPING
		bool EENV_warpEnable <
			string UIName = "EENV Warp Enable";
		> = {true};
		float EENV_warpMinDistance
		<
			string UIName="EENV Warp Min Distance";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.25};
		float EENV_warpMaxDistance
		<
			string UIName="EENV Warp Max Distance";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {1.0};
		float EENV_warpDistancePower
		<
			string UIName="EENV Warp Distance Power";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {1.75};
		float EENV_warpAspectRatio
		<
			string UIName="EENV Warp Aspect Ratio";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {1.0};
		float EENV_warpShift
		<
			string UIName="Warp Shift";
			string UIWidget="Spinner";
			float UIMin=-10.0;
			float UIMax=10.0;
		> = {0.0};
	#endif // ENABLE_WARPING
	
	// Lens
	#ifdef ENABLE_LENS
		bool EENV_lensEnable <
			string UIName = "EENV Lens Enable";
		> = {true};
		bool EENV_lensWarp <
			string UIName = "EENV Lens Warp";
		> = {true};
		float EENV_lensAdaptationMin
		<
			string UIName="EENV Lens Adaptation Min";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.0};
		float EENV_lensAdaptationMax
		<
			string UIName="EENV Lens Adaptation Max";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.1};
		float EENV_lensAdaptationGamma
		<
			string UIName="EENV  Lens Adaptation Gamma";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {2.0};
		float EENV_lensTextureScaleX
		<
			string UIName="EENV Lens Texture ScaleX";
			string UIWidget="Spinner";
			float UIMin=-10.0;
			float UIMax=10.0;
		> = {1.0};
		float EENV_lensTextureScaleY
		<
			string UIName="EENV Lens Texture ScaleY";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {1.0};
	#endif // ENABLE_LENS
	
	// Scanlines
	#ifdef ENABLE_SCANLINES
		bool EENV_scanlinesEnable <
			string UIName = "EENV Scanlines Enable";
		> = {true};
		bool EENV_scanlinesWarp <
			string UIName = "EENV Scanlines Warp";
		> = {true};
		float EENV_scanlinesFrequency
		<
			string UIName="EENV Scanlines Frequency";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=5000.0;
		> = {1000.0};
		float EENV_scanlinesSpeed
		<
			string UIName="EENV Scanlines Speed";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=100.0;
		> = {50.0};
		bool EENV_ScannerLinesEnable <
			string UIName = "EENV Scanner Lines Enable";
		> = {true};
		int EENV_ScannerLinesNum <
			string UIName="EENV Scanner Lines Number";
			string UIWidget="Spinner";
			int UIMin = 1;
			int UIMax = 10;
		> = {2};
		float EENV_ScannerLinesIntensity
		<
			string UIName="EENV Scanner Lines Intensity";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=1000.0;
		> = {50.0};
		float EENV_ScannerLinesDistance
		<
			string UIName="EENV Scanner Lines Distance";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=10.0;
		> = {0.1};
		float EENV_ScannerLinesDistancePower
		<
			string UIName="EENV Scanner Lines Distance Power";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=500.0;
		> = {20.0};
		float EENV_ScannerLinesSpeed
		<
			string UIName="EENV Scanner Lines Speed";
			string UIWidget="Spinner";
			float UIMin=0.0;
			float UIMax=500.0;
		> = {10.0};
	#endif // ENABLE_SCANLINES
//}
//}
// ##########################
// 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;
//enb version of bloom applied, ignored if original post processing used
float	EBloomAmount;

//===============//
// 3D LUT helper //
//===============//

#define LOAD_TEXTURE( Name, Path, sampler, UV ) \
texture2D tex##Name <string ResourceName= #Path ; >; \
sampler2D Sampler##Name = sampler_state {   \
    Texture   = < tex##Name >; SRGBTexture=FALSE;   \
    MinFilter = sampler; MagFilter = sampler; MipFilter = NONE; \
    AddressU = UV; AddressV = UV; }
	
LOAD_TEXTURE( LUT_1,          LUT_1.bmp,          LINEAR, CLAMP );
LOAD_TEXTURE( LUT_2,          LUT_2.bmp,          LINEAR, CLAMP );
LOAD_TEXTURE( LUT_3,          LUT_3.bmp,          LINEAR, CLAMP );
LOAD_TEXTURE( LUT_4,          LUT_4.bmp,          LINEAR, CLAMP );

//===============//
// 3D LUT helper //
//===============//

texture2D texs0;//color falloutnv
texture2D texs1;//bloom falloutnv
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 _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;
};

//========== DITHERING ==========================================

	float InterleavedGradientNoise( float2 uv )
	{
		float3 magic = { 0.06711056, 0.00583715, 52.9829189 };
		return frac( magic.z * frac( dot( uv, magic.xy ) ) );
	}

//========== DITHERING ==========================================
	
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
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;
}


//==============//
// LUT Function //
//==============//

static const float2 CLut_Size = float2(256.0, 16.0);

float3 CLutFunc( float3 colorIN, sampler2D LutSampler ) {
    float2 CLut_pSize = 1.0 / CLut_Size;
    float4 CLut_UV;
    colorIN    = saturate(colorIN) * ( CLut_Size.y - 1.0);
    CLut_UV.w  = floor(colorIN.b);
    CLut_UV.xy = (colorIN.rg + 0.5) * CLut_pSize;
    CLut_UV.x += CLut_UV.w * CLut_pSize.y;
    CLut_UV.z  = CLut_UV.x + CLut_pSize.y;
    return lerp( tex2Dlod(LutSampler, CLut_UV.xyzz).rgb, 
                 tex2Dlod(LutSampler, CLut_UV.zyzz).rgb, colorIN.b - CLut_UV.w);
}

//==============//
// LUT Function //
//==============//

//falloutnv shader specific externals, do not modify
float4	_c1 : register(c1);
float4	_c2 : register(c2);
float4	_c19 : register(c19);
float4	_c20 : register(c20);
float4	_c22 : register(c22);

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

	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 NIGHTEYE SETUP
	// ##########################
	// Default(Off) Values (used in Implementation section
	float EENV_nightVisionT = 0.0;
	float EENV_thermalVisionT = 0.0;
	float EENV_emiVisionT = 0.0;
	float EENV_warpT = 0.0;
	float EENV_generalImodT = 0.0;
	float4 EENV_gameCC=tex2D(_s0, _v0.xy);
	float4 EENV_Reg1 = _c1;
	float4 EENV_Reg2 = _c2;
	float4 EENV_Reg3 = _c19;
	float4 EENV_Reg4 = _c20;
	float4 EENV_Reg5 = _c22;
	
	if (EENV_Enable)
	{

		// EENV_nightVisionT
		#ifdef ENABLE_NIGHT_VISION
			//if(EENV_nightVisionEnable)
			//{
				float3 nightVisionDayFactor = clamp((EENV_Reg3.w + EENV_nightVisionCalDayOffset) * EENV_nightVisionCalDayMult, 0.0, 1.0);
				float3 nightVisionNightFactor = clamp((EENV_Reg3.w + EENV_nightVisionCalNightOffset) * EENV_nightVisionCalNightMult, 0.0, 1.0);
				float3 nightVisionInteriorFactor = clamp((EENV_Reg3.w + EENV_nightVisionCalInteriorOffset) * EENV_nightVisionCalInteriorMult, 0.0, 1.0);
				EENV_nightVisionT = lerp(lerp(nightVisionNightFactor, nightVisionDayFactor, ENightDayFactor), nightVisionInteriorFactor, EInteriorFactor);
				if (EENV_nightVisionCalUseColor)
				{
					float nightVisionRedT = 	lerp(1.0, 0.0, EENV_linStep(EENV_nightVisionCalRangeMin, EENV_nightVisionCalRangeMax, abs(EENV_Reg4.x - EENV_nightVisionCalColorR)));
					float nightVisionGreenT = 	lerp(1.0, 0.0, EENV_linStep(EENV_nightVisionCalRangeMin, EENV_nightVisionCalRangeMax, abs(EENV_Reg4.y - EENV_nightVisionCalColorG)));
					float nightVisionBlueT = 	lerp(1.0, 0.0, EENV_linStep(EENV_nightVisionCalRangeMin, EENV_nightVisionCalRangeMax, abs(EENV_Reg4.z - EENV_nightVisionCalColorB)));
					float nightVisionColorFactor = lerp(0.0, 1.0, min(min(nightVisionRedT, nightVisionGreenT), nightVisionBlueT));
					EENV_nightVisionT *= nightVisionColorFactor;
				}
			//}
		#endif // ENABLE_NIGHT_VISION
		
		// EENV_thermalVisionT
		#ifdef ENABLE_THERMAL_VISION
			//if(EENV_thermalVisionEnable)
			//{
				float3 thermalVisionDayFactor = clamp((EENV_Reg5.w + EENV_thermalVisionCalDayOffset) * EENV_thermalVisionCalDayMult, 0.0, 1.0);
				float3 thermalVisionNightFactor = clamp((EENV_Reg5.w + EENV_thermalVisionCalNightOffset) * EENV_thermalVisionCalNightMult, 0.0, 1.0);
				float3 thermalVisionInteriorFactor = clamp((EENV_Reg5.w + EENV_thermalVisionCalInteriorOffset) * EENV_thermalVisionCalInteriorMult, 0.0, 1.0);
				EENV_thermalVisionT = lerp(lerp(thermalVisionNightFactor, thermalVisionDayFactor, ENightDayFactor), thermalVisionInteriorFactor, EInteriorFactor);
				if (EENV_thermalVisionCalUseColor)
				{
					float thermalVisionRedT = 	lerp(1.0, 0.0, EENV_linStep(EENV_thermalVisionCalRangeMin, EENV_thermalVisionCalRangeMax, abs(EENV_Reg5.x - EENV_thermalVisionCalColorR)));
					float thermalVisionGreenT = lerp(1.0, 0.0, EENV_linStep(EENV_thermalVisionCalRangeMin, EENV_thermalVisionCalRangeMax, abs(EENV_Reg5.y - EENV_thermalVisionCalColorG)));
					float thermalVisionBlueT = 	lerp(1.0, 0.0, EENV_linStep(EENV_thermalVisionCalRangeMin, EENV_thermalVisionCalRangeMax, abs(EENV_Reg5.z - EENV_thermalVisionCalColorB)));
					float thermalVisionColorFactor = lerp(0.0, 1.0, min(min(thermalVisionRedT, thermalVisionGreenT), thermalVisionBlueT));
					EENV_thermalVisionT *= thermalVisionColorFactor;
				}
			//}
		#endif // ENABLE_THERMAL_VISION
		
		// EENV_emiVisionT
		#ifdef ENABLE_EMI_VISION
			//if(EENV_emiVisionEnable)
			//{
				float3 emiVisionDayFactor = clamp((EENV_Reg3.y + EENV_emiVisionCalDayOffset) * EENV_emiVisionCalDayMult, 0.0, 1.0);
				float3 emiVisionNightFactor = clamp((EENV_Reg3.y + EENV_emiVisionCalNightOffset) * EENV_emiVisionCalNightMult, 0.0, 1.0);
				float3 emiVisionInteriorFactor = clamp((EENV_Reg3.y + EENV_emiVisionCalInteriorOffset) * EENV_emiVisionCalInteriorMult, 0.0, 1.0);
				EENV_emiVisionT = lerp(lerp(emiVisionNightFactor, emiVisionDayFactor, ENightDayFactor), emiVisionInteriorFactor, EInteriorFactor);
				if (EENV_emiVisionCalUseColor)
				{
					float emiVisionRedT = 	lerp(1.0, 0.0, EENV_linStep(EENV_emiVisionCalRangeMin, EENV_emiVisionCalRangeMax, abs(EENV_Reg4.x - EENV_emiVisionCalColorR)));
					float emiVisionGreenT = lerp(1.0, 0.0, EENV_linStep(EENV_emiVisionCalRangeMin, EENV_emiVisionCalRangeMax, abs(EENV_Reg4.y - EENV_emiVisionCalColorG)));
					float emiVisionBlueT = 	lerp(1.0, 0.0, EENV_linStep(EENV_emiVisionCalRangeMin, EENV_emiVisionCalRangeMax, abs(EENV_Reg4.z - EENV_emiVisionCalColorB)));
					float emiVisionColorFactor = lerp(0.0, 1.0, min(min(emiVisionRedT, emiVisionGreenT), emiVisionBlueT));
					
					// Interior EMI Color Cal
					float emiVisionRedInteriorT = 	lerp(1.0, 0.0, EENV_linStep(EENV_emiVisionCalRangeInteriorMin, EENV_emiVisionCalRangeInteriorMax, abs(EENV_Reg4.x - EENV_emiVisionCalColorInteriorR)));
					float emiVisionGreenInteriorT = lerp(1.0, 0.0, EENV_linStep(EENV_emiVisionCalRangeInteriorMin, EENV_emiVisionCalRangeInteriorMax, abs(EENV_Reg4.y - EENV_emiVisionCalColorInteriorG)));
					float emiVisionBlueInteriorT = 	lerp(1.0, 0.0, EENV_linStep(EENV_emiVisionCalRangeInteriorMin, EENV_emiVisionCalRangeInteriorMax, abs(EENV_Reg4.z - EENV_emiVisionCalColorInteriorB)));
					float emiVisionColorInteriorFactor = lerp(0.0, 1.0, min(min(emiVisionRedInteriorT, emiVisionGreenInteriorT), emiVisionBlueInteriorT));
					
					EENV_emiVisionT *= lerp(emiVisionColorFactor, emiVisionColorInteriorFactor, EInteriorFactor);
				}
			//}
		#endif // ENABLE_EMI_VISION

		// EENV_generalImodT
		#ifdef ENABLE_GENERAL_IMOD
			if(EENV_generalImodEnable)
			{
				float generalImodC19_T = EENV_linStep(EENV_generalImodC19Min, EENV_generalImodC19Max,  EENV_Reg3.w);
				float generalImodC20_T = EENV_linStep(EENV_generalImodC20Min, EENV_generalImodC20Max,  EENV_Reg4.w);
				float generalImodC22_T = EENV_linStep(EENV_generalImodC22Min, EENV_generalImodC22Max,  EENV_Reg5.w);
				EENV_generalImodT = max(max(generalImodC19_T, generalImodC20_T), generalImodC22_T);
			}
		#endif // ENABLE_GENERAL_IMOD
		
		// Warping
		#ifdef ENABLE_WARPING
			EENV_warpT = 	EENV_nightVisionWarp * EENV_nightVisionT +
							EENV_thermalVisionWarp * EENV_thermalVisionT +
							EENV_emiVisionWarp * EENV_emiVisionT;
			
			float2 warpedTxCoords = IN.txcoord0;
			
			if(EENV_warpT > 0 && EENV_warpEnable)
			{
				float2 center = float2(0.5, 0.5);
				float2 warpedTxCoords = IN.txcoord0;
				float2 txCorrected = float2((warpedTxCoords.x - center.x) * 
					ScreenSize.z / EENV_warpAspectRatio + center.x, warpedTxCoords.y);
				float dist = distance(txCorrected, center);
				float2 warpVector = (txCorrected - center) / dist;

				float distT = EENV_linStep(EENV_warpMinDistance, EENV_warpMaxDistance, dist);
				distT = pow(distT, EENV_warpDistancePower);
				
				warpedTxCoords += EENV_warpT * -0.05 * 
					(distT + EENV_warpShift * 0.1) * warpVector;

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

				_v0.xy = warpedTxCoords.xy;
			}
		#endif // ENABLE_WARPING
	}
	// ##########################
	// END NIGHTEYE SETUP
	// ##########################	
	
	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

//==============//
// DNI Function //
//==============//
	
	float hnd = ENightDayFactor;
	float pi = (1-EInteriorFactor);
	
//==============//
// DNI Function //
//==============//	

	float4 color=_oC0;


	//adaptation in time
	float4	Adaptation=tex2D(_s4, 0.5);
	float	grayadaptation=max(max(Adaptation.x, Adaptation.y), Adaptation.z);

//========== PP2 =================================

	float newEAdaptationMax = lerp( EAdaptationMaxV2Interior, ( lerp( EAdaptationMaxV2Night, EAdaptationMaxV2Day, hnd ) ), pi );
	float newEAdaptationMin = lerp( EAdaptationMinV2Interior, ( lerp( EAdaptationMinV2Night, EAdaptationMinV2Day, hnd ) ), pi );
	float newEBrightnessV2 = lerp( EBrightnessV2Interior, ( lerp( EBrightnessV2Night, EBrightnessV2Day, hnd ) ), pi );
	float newEToneMappingCurve = lerp( ( EToneMappingCurveV2Interior*fInteriorlevel ), ( lerp( ( EToneMappingCurveV2Night*fNightlevel ), EToneMappingCurveV2Day, hnd ) ), pi );
	float newEIntensityContrastV2 = lerp( EIntensityContrastV2Interior, ( lerp( EIntensityContrastV2Night, EIntensityContrastV2Day, hnd ) ), pi );
	float newEToneMappingOversaturationV2 = lerp( EToneMappingOversaturationV2Interior, ( lerp( EToneMappingOversaturationV2Night, EToneMappingOversaturationV2Day, hnd ) ), pi );
	float newEColorSaturationV2 = lerp( EColorSaturationV2Interior, ( lerp( EColorSaturationV2Night, EColorSaturationV2Day, hnd ) ), pi );

	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);

//	--------------------------------------------------------------------------

//////////////////////////////////////////////////////////////////////////////
//LUT Switch
//////////////////////////////////////////////////////////////////////////////	
	
//    color.rgb = CLutFunc(color.rgb, SamplerLUT_1);
	
    if (LUTSwitch==1) {
    color.rgb = CLutFunc(color.rgb, SamplerLUT_1);
   }
   
   if (LUTSwitch==2) {
   color.rgb = CLutFunc(color.rgb, SamplerLUT_2);
   }
   
   if (LUTSwitch==3) {
   color.rgb = CLutFunc(color.rgb, SamplerLUT_3);
   }
   
      if (LUTSwitch==4) {
   color.rgb = CLutFunc(color.rgb, SamplerLUT_4);
   }
	
//////////////////////////////////////////////////////////////////////////////
//LUT Switch
//////////////////////////////////////////////////////////////////////////////	

#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.xyz, 0.3333);
	color=lerp(tempgray, color, ECCSaturation);

	//+++ desaturate shadows
	tempgray=dot(color.xyz, 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.xyz, 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

//========== DITHERING ==========================================

	if ( HHKingDither == true )
	{
		float noise = lerp(-0.5, 0.5, InterleavedGradientNoise( vPos )) * dither_amp;

		if ( HHDitherAdapt == true )
		{
			float Lvl = color.r + color.g + color.b;
			float DitherAdapt = 3.0 - Lvl;
			if ( DitherAdapt < 0 ) DitherAdapt = 0.0;
			noise *= DitherAdapt;
		};

		#if   DITHER_METHOD == 0 //linear
			color.xyz = color.xyz + noise / 255.0;
		#elif DITHER_METHOD == 1 //srgb
			color.xyz = pow( pow( color.xyz, 1.0 / 2.2) + noise / 255.0, 2.2);
		#else //energy-preserved [gdc16]
			color.xyz = pow(color.xyz, 1.0/2.2);
			color.xyz = color.xyz + noise * min(color.xyz + 0.5 * pow(1.0/255.0, 2.2), 0.75 * (pow(256.0/255.0, 2.2) - 1.0));
			color.xyz = pow(color.xyz, 2.2);
		#endif
	};
	
//========== DITHERING ==========================================	



	_oC0.w=1.0;
	
	// ##############################
	// BEGIN NIGHTEYE  IMPLEMENTATION
	// ##############################
	if(EENV_Enable)
	{
		if(EENV_Game_CC_Override_Enable)
		{
			// Game Color Correction
			r0=tex2D(_s0, _v0.xy);
			r1=tex2D(_s1, _v0.xy);
			r0.w=max(r1.w, _c1.x);
			r0.w=1.0/r0.w;
			r1.w=r0.w * 0.5;
			r0.w=r0.w * _c1.x;
			r1.xyz=r1 * r1.w;
			r2.xyz=max(r1, 0.0);
			r0.xyz=r0.w * r0 + r2.xyz;
			r0.w=dot(r0.xyz, float3(0.298999995, 0.587000012, 0.114));
			r1.xyz=lerp(r0.w, r0, _c19.x);
			r0.xyz=_c20 * r0.w - r1;
			r0.xyz=_c20.w * r0 + r1;
			r0.xyz=_c19.w * r0 - _c19.y;
			r0.xyz=_c19.z * r0 + _c19.y;
			r1.xyz=lerp(r0, _c22, _c22.w);
			r1.w=_c2.z;
			EENV_gameCC=r1;
			color.xyz = EENV_gameCC;
		}
		else
		{
			// Vignette
			float vignette = 1.0;
			#ifdef ENABLE_VIGNETTE
				if (EENV_vignetteEnable)
				{
					float2 center = float2(0.5, 0.5);
					float2 txCorrected = float2((IN.txcoord0.x - center.x) * 
						ScreenSize.z / EENV_vignetteAspectRatio + center.x, IN.txcoord0.y);
					float distT = EENV_linStep(EENV_vignetteMaxDistance, EENV_vignetteMinDistance, distance(txCorrected, center));
					vignette = pow(distT, EENV_vignetteDistancePower);
				}
			#endif // ENABLE_VIGNETTE

			// Noise
			float3 noiseVal = 0.0;
			#ifdef ENABLE_NOISE
				if (EENV_noiseEnable)
				{
					float3 noiseCoord = float3(_v0.x, _v0.y, Timer.x);
					noiseVal = EENV_randomNoise(noiseCoord);
				}
			#endif // ENABLE_NOISE
					
			// Lens
			float3	lensTexture = 0.0;
			float lensAdaptation = 0.0;
			#ifdef ENABLE_LENS
				if(EENV_lensEnable)
				{
					// Adaptation
					float3 adaptationENB = tex2D(_s4, IN.txcoord0);
					lensAdaptation = EENV_linStep(EENV_lensAdaptationMin, EENV_lensAdaptationMax, adaptationENB);
					lensAdaptation = pow(lensAdaptation, EENV_lensAdaptationGamma);

					float2 lensCoords = IN.txcoord0;
					if (EENV_lensWarp) lensCoords = _v0;
					lensCoords -= float2(0.5, 0.5);
					lensCoords *= float2(EENV_lensTextureScaleX, EENV_lensTextureScaleY);
					lensCoords += float2(0.5, 0.5);
					lensCoords.x = fmod(abs(lensCoords.x), 1.0);
					lensCoords.y = fmod(abs(lensCoords.y), 1.0);
					lensTexture=tex2D(EENV_LensMaskSampler, lensCoords);
				}
			#endif // ENABLE_LENS
			
			// Scanlines and Scanner Lines
			float scanlinesPattern = 0.0;
			float scannerLinesPattern = 0.0;
			#ifdef ENABLE_SCANLINES
				float2 scanLineCoords = IN.txcoord0;
				if (EENV_scanlinesWarp) scanLineCoords = _v0;
				if (EENV_scanlinesEnable)
				{
					scanlinesPattern = 0.5 + 0.5 * cos((scanLineCoords.y * EENV_scanlinesFrequency) + EENV_scanlinesSpeed * Timer.x * 10000.0);
				}
				if (EENV_ScannerLinesEnable)
				{
					const float offsets[10] = {0.0, 0.342, 0.5231, 0.632, 0.872, 0.2314, 0.4542, 0.75643, 0.93231, 1.0};
					const float speeds[10] = {0.214, 0.342, 0.5231, 0.632, 0.872, .1243, .721, 0.666, 0.151, 0.434};
					for (int i = 0; i < EENV_ScannerLinesNum; i++)
					{
						float linePosition = 0.5 + 0.5 * cos(offsets[i] + EENV_ScannerLinesSpeed * Timer.x * 5000.0 * speeds[i]);
						float dist = abs(scanLineCoords.y - linePosition);
						scannerLinesPattern += EENV_ScannerLinesIntensity * 
							pow(1.0 - EENV_linStep(0.0, EENV_ScannerLinesDistance, dist), EENV_ScannerLinesDistancePower);
					}
				}
			#endif // ENABLE_SCANLINES
			
			// ENB Bloom
			float3 ENBBloom = tex2D(_s3, _v0);
			
			// Night Vision
			#ifdef ENABLE_NIGHT_VISION
				if(EENV_nightVisionEnable && EENV_nightVisionT > 0)
				{
					// Game Color Correction
					float EENV_nightVisionGamma = lerp(lerp(EENV_nightVisionGammaNight, EENV_nightVisionGammaDay, ENightDayFactor), EENV_nightVisionGammaInterior, EInteriorFactor);
					r0=pow(tex2D(_s0, _v0.xy), EENV_nightVisionGamma);
					r1=tex2D(_s1, _v0.xy) * EENV_nightVisionGameBloom;
					r0.w=max(r1.w, _c1.x);
					r0.w=1.0/r0.w;
					r1.w=r0.w * 0.5;
					r0.w=r0.w * _c1.x;
					r1.xyz=r1 * r1.w;
					r2.xyz=max(r1, 0.0);
					r0.xyz=r0.w * r0 + r2.xyz;
					r0.w=dot(r0.xyz, float3(0.298999995, 0.587000012, 0.114));
					r1.xyz=lerp(r0.w, r0, _c19.x);
					r0.xyz=_c20 * r0.w - r1;
					r0.xyz=_c20.w * r0 + r1;
					r0.xyz=_c19.w * r0 - _c19.y;
					r0.xyz=_c19.z * r0 + _c19.y;
					r1.xyz=lerp(r0, _c22, _c22.w);
					r1.w=_c2.z;
					EENV_gameCC=r1;
						
					float3 nightVision = EENV_gameCC;
					nightVision += noiseVal * EENV_nightVisionNoise;
					float lensDNI = lerp(lerp(EENV_nightVisionLensNight, EENV_nightVisionLensDay, ENightDayFactor), EENV_nightVisionLensInterior, EInteriorFactor);
					nightVision += lensAdaptation * lensDNI * lensTexture;
					float scanlinesDNI = lerp(lerp(EENV_nightVisionScanlinesNight, EENV_nightVisionScanlinesDay, ENightDayFactor), EENV_nightVisionScanlinesInterior, EInteriorFactor);

					
					nightVision += pow(lerp(ENBBloom, ENBBloom * EENV_Reg4, EENV_nightVisionENBBloomTint), EENV_nightVisionENBBloomGamma) * 
						(EENV_nightVisionENBBloom + scannerLinesPattern * scanlinesDNI);
					nightVision = EENV_RGBtoHSV(nightVision);
					nightVision.x += EENV_nightVisionHue;
					float EENV_nightVisionSaturation = lerp(lerp(EENV_nightVisionSaturationNight, EENV_nightVisionSaturationDay, ENightDayFactor), EENV_nightVisionSaturationInterior, EInteriorFactor);
					nightVision.y *= EENV_nightVisionSaturation;
					float EENV_nightVisionValue = lerp(lerp(EENV_nightVisionValueNight, EENV_nightVisionValueDay, ENightDayFactor), EENV_nightVisionValueInterior, EInteriorFactor);
					nightVision.z *= EENV_nightVisionValue;
					nightVision = EENV_HSVtoRGB(nightVision);
					nightVision *= lerp(1.0, vignette, EENV_nightVisionVignette);
					color.xyz = lerp(color.xyz, nightVision.xyz, EENV_nightVisionT);
					color.xyz = lerp(color.xyz, EENV_nightVisionScanlinesColor.xyz, scanlinesDNI * scanlinesPattern);
				}
			#endif // ENABLE_NIGHT_VISION
			
			// Thermal Vision
			#ifdef ENABLE_THERMAL_VISION
				if(EENV_thermalVisionEnable && EENV_thermalVisionT > 0)
				{
					// Game Color Correction
					float EENV_thermalVisionGamma = lerp(lerp(EENV_thermalVisionGammaNight, EENV_thermalVisionGammaDay, ENightDayFactor), EENV_thermalVisionGammaInterior, EInteriorFactor);
					r0=pow(tex2D(_s0, _v0.xy), EENV_thermalVisionGamma);
					r1=tex2D(_s1, _v0.xy) * EENV_thermalVisionGameBloom;
					r0.w=max(r1.w, _c1.x);
					r0.w=1.0/r0.w;
					r1.w=r0.w * 0.5;
					r0.w=r0.w * _c1.x;
					r1.xyz=r1 * r1.w;
					r2.xyz=max(r1, 0.0);
					r0.xyz=r0.w * r0 + r2.xyz;
					r0.w=dot(r0.xyz, float3(0.298999995, 0.587000012, 0.114));
					r1.xyz=lerp(r0.w, r0, _c19.x);
					r0.xyz=_c20 * r0.w - r1;
					r0.xyz=_c20.w * r0 + r1;
					r0.xyz=_c19.w * r0 - _c19.y;
					r0.xyz=_c19.z * r0 + _c19.y;
					r1.xyz=lerp(r0, _c22, _c22.w);
					r1.w=_c2.z;
					EENV_gameCC=r1;
					
					float3 thermalVision = EENV_gameCC.xyz;
					thermalVision += noiseVal * EENV_thermalVisionNoise;
					float lensDNI = lerp(lerp(EENV_thermalVisionLensNight, EENV_thermalVisionLensDay, ENightDayFactor), EENV_thermalVisionLensInterior, EInteriorFactor);
					thermalVision += lensAdaptation * lensDNI * lensTexture;
					float scanlinesDNI = lerp(lerp(EENV_thermalVisionScanlinesNight, EENV_thermalVisionScanlinesDay, ENightDayFactor), EENV_thermalVisionScanlinesInterior, EInteriorFactor);

					thermalVision += pow(lerp(ENBBloom, ENBBloom * EENV_Reg5, EENV_thermalVisionENBBloomTint), EENV_thermalVisionENBBloomGamma) * 
						(EENV_thermalVisionENBBloom + scannerLinesPattern * scanlinesDNI);
					thermalVision = EENV_RGBtoHSV(thermalVision);
					thermalVision.x += EENV_thermalVisionHue;
					float EENV_thermalVisionSaturation = lerp(lerp(EENV_thermalVisionSaturationNight, EENV_thermalVisionSaturationDay, ENightDayFactor), EENV_thermalVisionSaturationInterior, EInteriorFactor);
					thermalVision.y *= EENV_thermalVisionSaturation;
					float EENV_thermalVisionValue = lerp(lerp(EENV_thermalVisionValueNight, EENV_thermalVisionValueDay, ENightDayFactor), EENV_thermalVisionValueInterior, EInteriorFactor);
					thermalVision.z *= EENV_thermalVisionValue;
					thermalVision = EENV_HSVtoRGB(thermalVision);
					//thermalVision = ((thermalVision - 0.5) * max(EENV_thermalVisionContrast + 1.0, 0)) + 0.5;  
					thermalVision *= lerp(1.0, vignette, EENV_thermalVisionVignette);
					color.xyz = lerp(color.xyz, thermalVision.xyz, EENV_thermalVisionT);
					color.xyz = lerp(color.xyz, EENV_thermalVisionScanlinesColor.xyz, scanlinesDNI * scanlinesPattern);
				}
			#endif // ENABLE_THERMAL_VISION
			
			// EMI Vision
			#ifdef ENABLE_EMI_VISION
				if(EENV_emiVisionEnable && EENV_emiVisionT > 0)
				{
					// Game Color Correction
					float EENV_emiVisionGamma = lerp(lerp(EENV_emiVisionGammaNight, EENV_emiVisionGammaDay, ENightDayFactor), EENV_emiVisionGammaInterior, EInteriorFactor);
					r0=pow(tex2D(_s0, _v0.xy), EENV_emiVisionGamma);
					r1=tex2D(_s1, _v0.xy) * EENV_emiVisionGameBloom;
					r0.w=max(r1.w, _c1.x);
					r0.w=1.0/r0.w;
					r1.w=r0.w * 0.5;
					r0.w=r0.w * _c1.x;
					r1.xyz=r1 * r1.w;
					r2.xyz=max(r1, 0.0);
					r0.xyz=r0.w * r0 + r2.xyz;
					r0.w=dot(r0.xyz, float3(0.298999995, 0.587000012, 0.114));
					r1.xyz=lerp(r0.w, r0, _c19.x);
					r0.xyz=_c20 * r0.w - r1;
					r0.xyz=_c20.w * r0 + r1;
					r0.xyz=_c19.w * r0 - _c19.y;
					r0.xyz=_c19.z * r0 + _c19.y;
					r1.xyz=lerp(r0, _c22, _c22.w);
					r1.w=_c2.z;
					EENV_gameCC=r1;
					
					float3 emiVision = EENV_gameCC;
					emiVision += noiseVal * EENV_emiVisionNoise;
					float lensDNI = lerp(lerp(EENV_emiVisionLensNight, EENV_emiVisionLensDay, ENightDayFactor), EENV_emiVisionLensInterior, EInteriorFactor);
					emiVision += lensAdaptation * lensDNI * lensTexture;
					float scanlinesDNI = lerp(lerp(EENV_emiVisionScanlinesNight, EENV_emiVisionScanlinesDay, ENightDayFactor), EENV_emiVisionScanlinesInterior, EInteriorFactor);

					float EENV_emiVisionENBBloomDNI = lerp(lerp(EENV_emiVisionENBBloomNight, EENV_emiVisionENBBloomDay, ENightDayFactor), EENV_emiVisionENBBloomInterior, EInteriorFactor);
					emiVision += pow(lerp(ENBBloom, ENBBloom * EENV_Reg4, EENV_emiVisionENBBloomTint), EENV_emiVisionENBBloomGamma) * 
						(EENV_emiVisionENBBloomDNI + scannerLinesPattern * scanlinesDNI);
					emiVision = EENV_RGBtoHSV(emiVision);
					emiVision.x += EENV_emiVisionHue;
					float EENV_emiVisionSaturation = lerp(lerp(EENV_emiVisionSaturationNight, EENV_emiVisionSaturationDay, ENightDayFactor), EENV_emiVisionSaturationInterior, EInteriorFactor);
					emiVision.y *= EENV_emiVisionSaturation;
					float EENV_emiVisionValue = lerp(lerp(EENV_emiVisionValueNight, EENV_emiVisionValueDay, ENightDayFactor), EENV_emiVisionValueInterior, EInteriorFactor);
					emiVision.z *= EENV_emiVisionValue;
					emiVision = EENV_HSVtoRGB(emiVision);
					emiVision *= lerp(1.0, vignette, EENV_emiVisionVignette);
					color.xyz = lerp(color.xyz, emiVision.xyz, EENV_emiVisionT);
					color.xyz = lerp(color.xyz, EENV_emiVisionScanlinesColor.xyz, scanlinesDNI * scanlinesPattern);
				}
			#endif // ENABLE_EMI_VISION
			
			#ifdef ENABLE_GENERAL_IMOD
				if(EENV_generalImodEnable && EENV_generalImodT > 0 && EENV_nightVisionT <= 0.05 && EENV_thermalVisionT <= 0.05 && EENV_emiVisionT <= 0.05)
				{
					// Game Color Correction
					r0=pow(tex2D(_s0, _v0.xy), EENV_generalImodGamma);
					r1=tex2D(_s1, _v0.xy) * EENV_generalImodGameBloom;
					r0.w=max(r1.w, _c1.x);
					r0.w=1.0/r0.w;
					r1.w=r0.w * 0.5;
					r0.w=r0.w * _c1.x;
					r1.xyz=r1 * r1.w;
					r2.xyz=max(r1, 0.0);
					r0.xyz=r0.w * r0 + r2.xyz;
					r0.w=dot(r0.xyz, float3(0.298999995, 0.587000012, 0.114));
					r1.xyz=lerp(r0.w, r0, _c19.x);
					r0.xyz=_c20 * r0.w - r1;
					r0.xyz=_c20.w * r0 + r1;
					r0.xyz=_c19.w * r0 - _c19.y;
					r0.xyz=_c19.z * r0 + _c19.y;
					r1.xyz=lerp(r0, _c22, _c22.w);
					r1.w=_c2.z;
					EENV_gameCC=r1;
						
					float3 generalImod = EENV_gameCC;

					generalImod += pow(lerp(ENBBloom, ENBBloom * EENV_Reg4, EENV_generalImodENBBloomTint), EENV_generalImodENBBloomGamma) * EENV_generalImodENBBloom;
					generalImod = EENV_RGBtoHSV(generalImod);
					generalImod.x += EENV_generalImodHue;
					generalImod.y *= EENV_generalImodSaturation;
					generalImod.z *= EENV_generalImodValue;
					generalImod = EENV_HSVtoRGB(generalImod);
					color.xyz = lerp(color.xyz, generalImod.xyz, EENV_generalImodT);
				}
			#endif // ENABLE_GENERAL_IMOD
			
		}

		// Calibration Display
		#ifdef ENABLE_CALIBRATION
			if(EENV_CalibrateEnable)
			{
				float2 calibrateCoords = IN.txcoord0 + 
					float2(-EENV_CalibratePosX, EENV_CalibratePosY);
				float4 calibrateText = 0;

				calibrateText += float4(1.0, 1.0, 1.0, 1.0) *
					EED_drawFloatText(
					//ASCII N   i    g    h
					float4(78, 105, 103, 104),  	
					// ACII t    V   i    s
					float4(116, 86, 105, 115),  	
					EENV_nightVisionT,
					calibrateCoords,
					float2(0.0, -0.05),
					1.2,
					6 // precision
				);
				
				calibrateText += float4(1.0, 1.0, 1.0, 1.0) *
					EED_drawFloatText(
					//ASCII T   h    e    r
					float4(84, 104, 101, 114),  	
					// ACII m    a   l     
					float4(109, 97, 108, 32),  	
					EENV_thermalVisionT,
					calibrateCoords,
					float2(0.0, -0.025),
					1.2,
					6 // precision
				);
				
				calibrateText += float4(1.0, 1.0, 1.0, 1.0) *
					EED_drawFloatText(
					//ASCII 
					float4(32, 32, 32, 32),  	
					// ACII E    M   I     
					float4(69, 77, 73, 32),  	
					EENV_emiVisionT,
					calibrateCoords,
					float2(0.0, 0.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.0, 0.065),
					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.0, 0.085),
					1.0,
					6 // precicsion
				);
				
				#ifdef ENABLE_CALIBRATION_REGISTERS
					calibrateText += EED_drawCRegistersText2(
						EENV_Reg1, EENV_Reg2, EENV_Reg3, EENV_Reg4, EENV_Reg5,
						calibrateCoords, float2(0.0, 0.125), 1.0, 6
					);
				#endif //ENABLE_CALIBRATION_REGISTERS
				
				float2 regSize = 100.0 * float2(ScreenSize.y * ScreenSize.w, ScreenSize.y);
				color.xyz = EED_drawCRegistersColors(
					color.xyz,
					EENV_Reg1, EENV_Reg2, EENV_Reg3, EENV_Reg4, EENV_Reg5,
					IN.txcoord0, float2(EENV_CalibratePosX + 0.115, -EENV_CalibratePosY + 0.15),
					regSize, float2(0.05, 0.1)
				);
				
				color.xyz += calibrateText.xyz;
			}
		#endif  //ENABLE_CALIBRATION

	}
	// ##############################
	// END NIGHTEYE  IMPLEMENTATION
	// ##############################	
	
	_oC0.xyz=color.xyz;
	return _oC0;
 
	
	
}



//switch between vanilla and mine post processing
technique Shader_C1DAE3F7 <string UIName="ENBSeries";>
{
	pass p0
	{
		VertexShader  = compile vs_3_0 VS_Quad();
		PixelShader  = compile ps_3_0 PS_C1DAE3F7();

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



//original shader of post processing
technique Shader_ORIGINALPOSTPROCESS <string UIName="Vanilla";>
{
	pass p0
	{
		//VertexShader  = compile vs_3_0 VS_Quad();
		VertexShader=
	asm
	{
// Parameters:
//   float4 geometryOffset;
//   float4 texOffset0;
//   float4 texOffset1;
// Registers:
//   Name           Reg   Size
//   -------------- ----- ----
//   geometryOffset c0       1
//   texOffset0     c1       1
//   texOffset1     c2       1
//
    vs_1_1
    def c3, 2, -2, 0, 0
    dcl_position v0
    dcl_texcoord v1
    mov r0.xy, c0
    mad oPos.xy, r0, -c3, v0
    add oT0.xy, v1, c1
    add oT1.xy, v1, c2
    mov oPos.zw, v0
	};
		PixelShader=
	asm
	{
// Parameters:
//   float3 BlurScale;
//   float4 Cinematic;
//   sampler2D DestBlend;
//   float4 Fade;
//   float4 HDRParam;
//   sampler2D Src0;
//   float4 Tint;
// Registers:
//   Name         Reg   Size
//   ------------ ----- ----
//   HDRParam     c1       1
//   BlurScale    c2       1
//   Cinematic    c19      1
//   Tint         c20      1
//   Fade         c22      1
//   Src0         s0       1
//   DestBlend    s1       1
//
    ps_2_x
    def c0, 0.5, 0, 0, 0
    def c3, 0.298999995, 0.587000012, 0.114, 0
    dcl t0.xy
    dcl t1.xy
    dcl_2d s0
    dcl_2d s1
    texld r0, t1, s1
    texld r1, t0, s0
    max r0.w, r1.w, c1.x
    rcp r0.w, r0.w
    mul r1.w, r0.w, c0.x
    mul r0.w, r0.w, c1.x
    mul r1.xyz, r1, r1.w
    max r2.xyz, r1, c0.y
    mad r0.xyz, r0.w, r0, r2
    dp3 r0.w, r0, c3
    lrp r1.xyz, c19.x, r0, r0.w
    mad r0.xyz, r0.w, c20, -r1
    mad r0.xyz, c20.w, r0, r1
    mad r0.xyz, c19.w, r0, -c19.y
    mad r0.xyz, c19.z, r0, c19.y
    lrp r1.xyz, c22.w, c22, r0
    mov r1.w, c2.z
    mov oC0, r1
	};
		ColorWriteEnable=ALPHA|RED|GREEN|BLUE;
		ZEnable=FALSE;
		ZWriteEnable=FALSE;
		CullMode=NONE;
		AlphaTestEnable=FALSE;
		AlphaBlendEnable=FALSE;
		SRGBWRITEENABLE=FALSE;
    }
}

_________________
Rudy ENB for Skyrim, Skyrim SE, for Fallout New Vegas, for Dragon's Dogma

English is not my native language.

AMD Ryzen 9 5900X, Gigabyte B550 AORUS PRO AC, Arctic Liquid Freezer II 280, Nvidia Geforce RTX 2070 Super, 64GB ram
Post Reply