Please use english language
It is currently 20 Sep 2017, 14:48

All times are UTC


Forum rules


new topics are not allowed in this subsection, only replies.




Post new topic Reply to topic  [ 1 post ] 
Author Message
PostPosted: 23 Sep 2013, 18:04 
Offline
*blah-blah-blah maniac*
User avatar

Joined: 27 Dec 2011, 08:53
Posts: 11269
Location: St.Petersburg
This effect is an example of night/day separation via interpolator. Developed for version 0.221, but should work with different versions which support annotations (see changes log).

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



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

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



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

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



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

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

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

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

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

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

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

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

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

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

float3   ECCColorBalanceShadowsNight
<
   string UIName="CC: Color balance shadows Night";
   string UIWidget="Color";
> = {0.5, 0.5, 0.5};
float3   ECCColorBalanceShadowsDay
<
   string UIName="CC: Color balance shadows Day";
   string UIWidget="Color";
> = {0.5, 0.5, 0.5};

float3   ECCColorBalanceHighlightsNight
<
   string UIName="CC: Color balance highlights Night";
   string UIWidget="Color";
> = {0.5, 0.5, 0.5};
float3   ECCColorBalanceHighlightsDay
<
   string UIName="CC: Color balance highlights Day";
   string UIWidget="Color";
> = {0.5, 0.5, 0.5};

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

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

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



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



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

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

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

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

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

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

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

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



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

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

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

   return OUT;
}


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

float4 PS_D6EC7DD1(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR
{
   //night/day interpolators
   float   ECCGamma=lerp(ECCGammaNight, ECCGammaDay, ENightDayFactor);
   float   ECCInBlack=lerp(ECCInBlackNight, ECCInBlackDay, ENightDayFactor);
   float   ECCInWhite=lerp(ECCInWhiteNight, ECCInWhiteDay, ENightDayFactor);
   float   ECCOutBlack=lerp(ECCOutBlackNight, ECCOutBlackDay, ENightDayFactor);
   float   ECCOutWhite=lerp(ECCOutWhiteNight, ECCOutWhiteDay, ENightDayFactor);
   float   ECCBrightness=lerp(ECCBrightnessNight, ECCBrightnessDay, ENightDayFactor);
   float   ECCContrastGrayLevel=lerp(ECCContrastGrayLevelNight, ECCContrastGrayLevelDay, ENightDayFactor);
   float   ECCContrast=lerp(ECCContrastNight, ECCContrastDay, ENightDayFactor);
   float   ECCSaturation=lerp(ECCSaturationNight, ECCSaturationDay, ENightDayFactor);
   float   ECCDesaturateShadows=lerp(ECCDesaturateShadowsNight, ECCDesaturateShadowsDay, ENightDayFactor);
   float3   ECCColorBalanceShadows=lerp(ECCColorBalanceShadowsNight, ECCColorBalanceShadowsDay, ENightDayFactor);
   float3   ECCColorBalanceHighlights=lerp(ECCColorBalanceHighlightsNight, ECCColorBalanceHighlightsDay, ENightDayFactor);
   float3   ECCChannelMixerR=lerp(ECCChannelMixerRNight, ECCChannelMixerRDay, ENightDayFactor);
   float3   ECCChannelMixerG=lerp(ECCChannelMixerGNight, ECCChannelMixerGDay, ENightDayFactor);
   float3   ECCChannelMixerB=lerp(ECCChannelMixerBNight, ECCChannelMixerBDay, ENightDayFactor);

   float4 _oC0=0.0; //output

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

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


   float4 _v0=0.0;

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

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

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

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

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

#endif //APPLYGAMECOLORCORRECTION

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

   float4 color=_oC0;


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

#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



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



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

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

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

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

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

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

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

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

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

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



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

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



//original shader of post processing
technique Shader_ORIGINALPOSTPROCESS <string UIName="Vanilla";>
{
   pass p0
   {
      VertexShader  = compile vs_3_0 VS_Quad();
      PixelShader=
   asm
   {
// Parameters:
//   sampler2D Avg;
//   sampler2D Blend;
//   float4 Cinematic;
//   float4 ColorRange;
//   float4 Fade;
//   sampler2D Image;
//   float4 Param;
//   float4 Tint;
// Registers:
//   Name         Reg   Size
//   ------------ ----- ----
//   ColorRange   c1       1
//   Param        c2       1
//   Cinematic    c3       1
//   Tint         c4       1
//   Fade         c5       1
//   Image        s0       1
//   Blend        s1       1
//   Avg          s2       1
//s0 bloom result
//s1 color
//s2 is average color

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

_________________
Core i5-4690K 3.5 GHz, 16 Gb ram, GeForce 650 Ti 2 Gb, X-Fi Xtreme Music, WinXP/Win7
I am INFP, not the brutal, godamnit.


Top
 Profile  
 
Tomoko
Display posts from previous:  Sort by  
Post new topic Reply to topic  [ 1 post ] 

All times are UTC


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to:  
Powered by phpBB® Forum Software © phpBB Group