//post processing mode. Change value (could be 1, 2, 3, 4).

Every mode have own

internal parameters, look below
#ifndef POSTPROCESS
#define POSTPROCESS 3
#endif

//use original game processing first, then mine

//#define APPLYGAMECOLORCORRECTION

//use original game processing only, with vanilla bloom

//#define ENB_FLIPTECHNIQUE

//+++++++++++++++++++++++++++++
//internal parameters, can be modified
//+++++++++++++++++++++++++++++
//float3 EColorFilter=float3(1.0, 0.9, 0.9);

//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
//float EBrightnessV2=2.5;
float EAdaptationMinV2=0.05;
float EAdaptationMaxV2=0.05;//0.125;
float EToneMappingCurveV2=8.0;
float EIntensityContrastV2=1.0;
float EColorSaturationV2=1.0;
float EToneMappingOversaturationV2=180.0;

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

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Postprocessing 6 by Kermles
#if POSTPROCESS == 6
//DAY
float EBrightnessV6Day = 2.9; //higher
than normal values needed for shadow and brightspot to work correctly
float EIntensityContrastV6Day = 2.2; //very
powerful, be careful of high values
float EColorSaturationV6Day = 2.0; //very powerful,
be careful of high values
 float HCompensateSatV6Day = 2.9;
//higher than normal values needed for shadow and brightspot to work
correctly
float EAdaptationMinV6Day = 0.64; //works
differently than usual, be careful with too high/too low values
float EAdaptationMaxV6Day = 0.24; //works
differently than usual, be careful with too high/too low values
float EAdaptationCompensateV6Day = 1.0; //darkening that
happens after adaptation, higher is darker
float EBrightnessMinV6Day = 0.0; //clamps rgb
brightness, range 0-1
float EBrightnessMaxV6Day = 1.0; //clamps rgb
brightness, range 0-1
float EToneMappingCurveV6Day = 8;
float EToneMappingOversaturationV6Day = 2500.0;
float EHSVDesatCurveDay = 1.444444;
//intelligent desaturation, idea credit goes to saltr. higher is less
saturated
///////////////////////////////////Red Green Blue
float3 EMoodColorDay = float3(0.0, 0.0, 0.0);
float EMoodAmountDay = 0.0; //higher is
stronger, range 0-1
float EMoodCurveDay = 4.0; //lower is
stronger, be careful of going under 1.0
/////////////////////////////////////Red Green Blue
float3 EShadowColorDay = float3(0.0, 0.0, 0.55); //unlike other two
color controls, colors shadows/dark spots only. max is 2.55
float EShadowThresholdDay = 1.0; //lower is
stronger, be careful of low values under 0.4
float EShadowCurveDay = 16.0;
//lower is stronger, be careful of low values under 4
//////////////////////////////////////////Red Green Blue
float3 EBrightSpotColorDay = float3(0.0, 0.25, 2.55);
float EBrightSpotThresholdDay = 1.0; //lower is
stronger, be careful of low values under 0.4
float EBrightSpotCurveDay = 24.0; //lower is
stronger, be careful of low values under 4
////////////////////////////////////////////////////////////
#endif
float3 HUEtoRGB(in float H)
{
float R = abs(H * 6.0 - 3.0) - 1.0;
float G = 2.0 - abs(H * 6.0 - 2.0);
float B = 2.0 - abs(H * 6.0 - 4.0);
return saturate(float3(R,G,B));
}

float RGBCVtoHUE(in float3 RGB, in float C, in float V)

{
float3 Delta = (V - RGB) / C;
Delta.rgb -= Delta.brg;
Delta.rgb += float3(2.0,4.0,6.0);
Delta.brg = step(V, RGB) * Delta.brg;
float H;
H = max(Delta.r, max(Delta.g, Delta.b));
return frac(H / 6.0);
}

float3 HSVtoRGB(in float3 HSV)

{
float3 RGB = HUEtoRGB(HSV.x);
return ((RGB - 1) * HSV.y + 1) * HSV.z;
}

float3 RGBtoHSV(in float3 RGB)

{
float3 HSV = 0.0;
HSV.z = max(RGB.r, max(RGB.g, RGB.b));
float M = min(RGB.r, min(RGB.g, RGB.b));
float C = HSV.z - M;
if (C != 0.0)
{
HSV.x = RGBCVtoHUE(RGB, C, HSV.z);
HSV.y = C / HSV.z;
}
return HSV;
}

//+++++++++++++++++++++++++++++
//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;

texture2D texs0;//color falloutnv

texture2D texs1;//bloom falloutnv
//texture2D texs2;//unused
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;
}

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

// 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
//todo apply uv offsets to coordinates
r0=tex2D(_s0, IN.txcoord0.xy);//r0=tex2D(_s0, IN.txcoord1.xy);
r1=tex2D(_s1, IN.txcoord0.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;
_oC0=r1;

#endif //APPLYGAMECOLORCORRECTION

float4 color=_oC0;

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

#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

#if (POSTPROCESS==2)

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

//color.xyz*=EBrightnessV2;
color.xyz+=0.000001;
float3 xncol=normalize(color.xyz);
float3 scl=color.xyz/xncol.xyz;
scl=pow(scl, EIntensityContrastV2);
xncol.xyz=pow(xncol.xyz, EColorSaturationV2);
color.xyz=scl*xncol.xyz;

float lumamax=EToneMappingOversaturationV2;
color.xyz=(color.xyz * (1.0 + color.xyz/lumamax))/(color.xyz +
EToneMappingCurveV2);

#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

#if (POSTPROCESS==6)
//Postprocessing V6 by Kermles
//hd6/ppv2///////////////////////////////////////////
float EIntensityContrastV6 = EIntensityContrastV6Day;
float EColorSaturationV6 = EColorSaturationV6Day;
float HCompensateSatV6 = HCompensateSatV6Day;
float EToneMappingCurveV6 = EToneMappingCurveV6Day;
float EBrightnessV6 = EBrightnessV6Day;
float EToneMappingOversaturationV6 =
EToneMappingOversaturationV6Day;
float EAdaptationMaxV6 = EAdaptationMaxV6Day;
float EAdaptationMinV6 = EAdaptationMinV6Day;
float lumamax = EToneMappingOversaturationV6;
//kermles////////////////////////////////////////////
float EAdaptationCompensateV6 = EAdaptationCompensateV6Day;
 float EBrightnessMaxV6 = EBrightnessMaxV6Day;
float EBrightnessMinV6 = EBrightnessMinV6Day;
float3 moodColor = EMoodColorDay;
float moodAmount = EMoodAmountDay;
float moodCurve = EMoodCurveDay;
float3 shadowColor = EShadowColorDay;
float shadowThreshold = EShadowThresholdDay;
float shadowCurve = EShadowCurveDay;
float3 brightSpotColor = EBrightSpotColorDay;
float brightSpotThreshold = EBrightSpotThresholdDay;
float brightSpotCurve = EBrightSpotCurveDay / 10;
float hsvDesatCurve = EHSVDesatCurveDay;
float PPAmount = 1.0; //controls interpolation
between vanilla colors and PP6 colors
float4 ncolor; //temporary variable for
color adjustments
float avgbr; //temporary variable for
color adjustments

//begin pp code/////////////////////////////////////////////////
//store vanilla colors//////////////////////////////////////////
float4 oldcolor = color;
//convert to hsv////////////////////////////////////////////////
float3 hsvncolor = RGBtoHSV( color.xyz );
hsvncolor.y = max( hsvncolor.y, 0.0 );
hsvncolor.z = max( hsvncolor.z, 0.0 );
//desaturate based on original saturation then resaturate///////
hsvncolor.y = pow( hsvncolor.y, hsvDesatCurve );
hsvncolor.y = saturate(hsvncolor.y * EColorSaturationV6);
//convert back to rgb///////////////////////////////////////////
hsvncolor.y = max( hsvncolor.y, 0.0 );
color.xyz = HSVtoRGB( hsvncolor );
//brightness clamping///////////////////////////////////////////
color.xyz=clamp(color.xyz, EBrightnessMinV6, EBrightnessMaxV6);
//ppv2 modified by kermles//////////////////////////////////////
grayadaptation = clamp(grayadaptation, 0, 50);
color.xyz *= EBrightnessV6;
float3 xncol = normalize(color.xyz);
float3 scl = color.xyz/xncol.xyz;
scl = pow(scl, EIntensityContrastV6);
xncol.xyz = pow(xncol.xyz, EColorSaturationV6);
color.xyz = scl*xncol.xyz;
color.xyz *= HCompensateSatV6;
color.xyz = (color.xyz * (1.0 + color.xyz/lumamax))/(color.xyz +
EToneMappingCurveV6);
//mood coloring/////////////////////////////////////////////////
ncolor = color;
avgbr = (ncolor.x + ncolor.y + ncolor.z)/3;
moodColor.xyz = lerp( moodColor/10, moodColor, saturate( avgbr * 2 ) );
moodColor.xyz = lerp( moodColor, 1, saturate( avgbr - 0.5 ) * 2 );
moodColor.xyz = lerp( ncolor, moodColor, saturate(avgbr / moodCurve));
ncolor.xyz = lerp( ncolor, moodColor, saturate( avgbr * moodAmount ) );
color.xyz = max(0, ncolor);
//shadows///////////////////////////////////////////////////////
ncolor = color;
avgbr = (ncolor.x + ncolor.y + ncolor.z)/3;
shadowColor = lerp(0.1*(2.55-shadowColor), 2.55-shadowColor,
saturate(avgbr*2));
shadowColor = lerp(shadowColor, 1, saturate(avgbr-0.5)*2);
 ncolor.xyz = max(ncolor, pow(ncolor, ((1.0+ncolor) *
(shadowColor))*shadowThreshold)/shadowCurve);
color.xyz = saturate(ncolor);
//brightspots///////////////////////////////////////////////////
brightSpotColor = lerp(brightSpotColor/10, brightSpotColor,
saturate(avgbr*2));
brightSpotColor = lerp(brightSpotColor, 1, saturate(avgbr-0.5)*2);
ncolor = 1-color;
ncolor.xyz = max(ncolor, pow(ncolor, ((1.0 + ncolor) *
(brightSpotColor))*brightSpotThreshold)/brightSpotCurve);
color.xyz = saturate(1-ncolor);
//convert to hsv////////////////////////////////////////////////
hsvncolor = RGBtoHSV( color.xyz );
hsvncolor.y = max( hsvncolor.y, 0.0 );
hsvncolor.z = max( hsvncolor.z, 0.0 );
//adaptation/contrast///////////////////////////////////////////
hsvncolor.z = pow(hsvncolor.z,
(grayadaptation*EAdaptationMaxV6+EAdaptationMinV6));
//convert back to rgb///////////////////////////////////////////
hsvncolor.y = max( hsvncolor.y, 0.0 );
hsvncolor.z = max( hsvncolor.z, 0.0 );
color.xyz = HSVtoRGB( hsvncolor );
color.xyz /= grayadaptation*EAdaptationMaxV6+EAdaptationMinV6;
color.xyz /= EAdaptationCompensateV6;
//rerun ppv2////////////////////////////////////////////////////
color.xyz *= EBrightnessV6;
xncol = normalize(color.xyz);
scl = color.xyz/xncol.xyz;
scl = pow(scl, EIntensityContrastV6);
xncol.xyz = pow(xncol.xyz, EColorSaturationV6);
color.xyz = scl*xncol.xyz;
color.xyz *= HCompensateSatV6;
color.xyz = (color.xyz * (1.0 + color.xyz/lumamax))/(color.xyz +
EToneMappingCurveV6);
//lerp between vanilla and pp6 colors///////////////////////////
color = lerp(oldcolor, color, PPAmount);
#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

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

//switch between vanilla and mine post processing

#ifndef ENB_FLIPTECHNIQUE
technique Shader_C1DAE3F7
#else
technique Shader_ORIGINALPOSTPROCESS
#endif
{
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

#ifndef ENB_FLIPTECHNIQUE
technique Shader_ORIGINALPOSTPROCESS
#else
technique Shader_C1DAE3F7
#endif
{
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;
}
}