diff --git a/effect.txt b/effect.txt index 17dbcf4..e0599a6 100644 --- a/effect.txt +++ b/effect.txt @@ -1,593 +1,1187 @@ -/* - Pseudo-CRT emulation shader (and some other stuff). - (C)2013 Marisa Kirisame, UnSX Team - Some parts cobbled together from original effect.txt by Boris, and - random algorithms taken from the internet. - Released under the WTFPL. -*/ - -/* - The original code for some sections (mainly the curvature one) made me wish - I could choke the original authors through standard TCP/IP. -*/ - -/* PS: HLSL is disgusting. I prefer GLSL, or even pure C software shaders. */ - -/* Borders are blurred */ -#define EBORDERBLUR -/* border shine blur sampling range */ -float blursamp = 1.5; -/* blend power of blur */ -float blurpow = 28.0; -/* falloff curve of blur towards center of screen */ -float blurcurve = 2.2; -/* blur falloff radius */ -float blurradius = 0.56; - -/* Crossblur modified from Uboa Engine */ -#define ECROSSBLUR -/* crossblur sampling range */ -float cblursamp = 0.3; - -/* Soft grain */ -#define EGRAIN -/* soft grain speed */ -float nf = 0.02; -/* soft grain intensity */ -float ni = 0.01; -/* soft grain saturation */ -float ns = 0.15; - -/* Block graphics filter with palette reduction */ -#define EBLOCKGFX -/* emulated resolution for block graphics (0 or less for real resolution) */ -float2 bres = float2(320,200); -/* do not scale */ -bool bnoscale = false; -/* perform aspect ratio correction on emulated screen (ignored if no scale) */ -bool bratio = true; -/* extra border factor (negative values for overscan) */ -float bborderf = 0.05; -/* - palette type for block graphics: - 0: 64-color AOS - 1: 6bpc - 2: CGA - 3: 16-bit RGB565 - other values disable palette reduction -*/ -int paltype = 0; -/* Use AOS CGA colors rather than standard CGA */ -#define AOSCGA - -/* Cheap dot matrix filter */ -#define EDOTMATRIX -/* blend factor for dot matrix */ -float dotblend = 0.4; -/* subpixel size in pixels */ -int dotsize = 1; - -/* Dirty screen effect (static noise) */ -#define EDIRT -/* dirt amount */ -float dirtfactor = 0.08; - -/* Use CRT curvature shader */ -#define ECRT -/* chromatic aberration on CRT: fancy effect that isn't really realistic */ -float chromaab = 0.015; -/* curvature lens zoom (0.5 = none) */ -float lenszoom = 0.53; -/* curvature lens distortion */ -float lensdist = 0.1; -/* not sure what this does */ -float lensdistc = 0.1; - -/* - +------------------------------+ - |User-tweakable stuff ends here| - +------------------------------+ -*/ - -/* do not touch this! */ -#define E_SHADER_3_0 - -/* standard stuff */ -float tempF1; -float tempF2; -float tempF3; -float tempF4; -float tempF5; -float tempF6; -float tempF7; -float tempF8; -float tempF9; -float tempF0; -float4 Timer; -float4 ScreenSize; - -/* samplers and textures */ -texture2D texColor; -texture texNoise; -sampler2D SamplerColor = sampler_state -{ - Texture = ; - MinFilter = LINEAR; - MagFilter = LINEAR; - MipFilter = NONE; - AddressU = Clamp; - AddressV = Clamp; - SRGBTexture = FALSE; - MaxMipLevel = 0; - MipMapLodBias = 0; -}; -sampler2D SamplerNoise = sampler_state -{ - Texture = ; - MinFilter = POINT; - MagFilter = POINT; - MipFilter = NONE; - AddressU = Wrap; - AddressV = Wrap; - SRGBTexture = FALSE; - MaxMipLevel = 0; - MipMapLodBias = 0; -}; - -/* whatever */ -struct VS_OUTPUT_POST -{ - float4 vpos : POSITION; - float2 txcoord : TEXCOORD0; -}; -struct VS_INPUT_POST -{ - float3 pos : POSITION; - float2 txcoord : TEXCOORD0; -}; - -/* Shader routines */ - -VS_OUTPUT_POST VS_Process(VS_INPUT_POST IN) -{ - VS_OUTPUT_POST OUT; - float4 pos = float4(IN.pos.x,IN.pos.y,IN.pos.z,1); - OUT.vpos = pos; - OUT.txcoord.xy = IN.txcoord.xy; - return OUT; -} - -float4 PS_ProcessBlur(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR -{ - float4 coord = float4(IN.txcoord.x,IN.txcoord.y,0,0); - float4 res = tex2Dlod(SamplerColor,coord); -#ifdef EBORDERBLUR - float4 origcolor = res; - float4 tcol = float4(0,0,0,0); - float2 bresl = float2(ScreenSize.x,ScreenSize.x*ScreenSize.w); - float4 bof = float4(1.0/bresl.x,1.0/bresl.y,0,0)*blursamp; - int i, j; - for ( i=-2; i<3; i++ ) - for( j=-2; j<3; j++ ) - tcol += tex2Dlod(SamplerColor, - coord+float4(i,j,0,0)*bof); - tcol *= 0.04; - float2 uv = (IN.txcoord.xy-0.5)*blurradius; - float vig = pow(saturate(dot(uv.xy,uv.xy)),blurcurve); - res.xyz = lerp(origcolor.xyz,tcol.xyz,vig*blurpow); -#endif - return res; -} - -float4 PS_ProcessDirt(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR -{ - float4 coord = float4(IN.txcoord.x,IN.txcoord.y,0,0); - float4 res = tex2Dlod(SamplerColor,coord); -#ifdef EDIRT - float gray = (res.r+res.g+res.b)/3.0; - float4 ncol = tex2Dlod(SamplerNoise, coord*16+gray); - res = lerp(res,(ncol.r+1)*res,dirtfactor*saturate(1-gray*0.5)); -#endif - return res; -} - -float4 PS_ProcessCurve(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR -{ - float4 coord = float4(IN.txcoord.x,IN.txcoord.y,0,0); - float4 res = tex2Dlod(SamplerColor,coord); -#ifdef ECRT - float4 tcol = res; - float3 eta = float3(1+chromaab*0.9,1+chromaab*0.6,1+chromaab*0.3); - float2 center = float2(coord.x-0.5,coord.y-0.5); - float zfact = 1.0/lenszoom; - float r2 = center.x*center.x+center.y*center.y; - float f = 0; - if( lensdistc == 0.0) - f = 1+r2*lensdist; - else - f = 1+r2*(lensdist+lensdistc*sqrt(r2)); - float x = f*zfact*center.x+0.5; - float y = f*zfact*center.y+0.5; - float2 rcoord = (f*eta.r)*zfact*(center.xy*0.5)+0.5; - float2 gcoord = (f*eta.g)*zfact*(center.xy*0.5)+0.5; - float2 bcoord = (f*eta.b)*zfact*(center.xy*0.5)+0.5; - float4 idist = float4(tex2D(SamplerColor,rcoord).r, - tex2D(SamplerColor,gcoord).g, - tex2D(SamplerColor,bcoord).b, - tex2D(SamplerColor,float2(x,y)).a); - /* clamp (currently hard, will add softening later */ - float clampval = 0.01; - if ( rcoord.x < clampval || rcoord.x >= 1-clampval - || rcoord.y < clampval || rcoord.y >= 1-clampval ) - idist.r *= 0; - if ( gcoord.x < clampval || gcoord.x >= 1-clampval - || gcoord.y < clampval || gcoord.y >= 1-clampval ) - idist.g *= 0; - if ( bcoord.x < clampval || bcoord.x >= 1-clampval - || bcoord.y < clampval || bcoord.y >= 1-clampval ) - idist.b *= 0; - - res.rgb = idist.rgb; -#endif - return res; -} - -float4 PS_ProcessCrossblur( VS_OUTPUT_POST IN, float2 vPos : VPOS ) : COLOR -{ - float4 coord = float4(IN.txcoord.x,IN.txcoord.y,0,0); - float4 res = tex2Dlod(SamplerColor,coord); -#ifdef ECROSSBLUR - float2 bresl = float2(ScreenSize.x,ScreenSize.x*ScreenSize.w); - float4 bof = float4(1.0/bresl.x,1.0/bresl.y,0,0)*cblursamp; - float factor[4] = {0.3,0.2,0.1,0.05}; - int i, j; - res *= 0; - /* I'm going to hell for this ugly staircase code */ - for ( i=-3; i<4; i++ ) - for ( j=-3; j<4; j++ ) - res += factor[abs(i)]*factor[abs(j)] - *tex2Dlod(SamplerColor, - coord+float4(i,j,0,0)*bof); -#endif - return res; -} - -float4 PS_ProcessBlock( VS_OUTPUT_POST IN, float2 vPos : VPOS ) : COLOR -{ - float4 coord = float4(IN.txcoord.x,IN.txcoord.y,0,0); - float4 res = tex2Dlod(SamplerColor,coord); -#ifdef EBLOCKGFX - float4 rresl = float4(ScreenSize.x,ScreenSize.x*ScreenSize.w,1,1); - float4 bresl; - if ( bres.x <= 0 || bres.y <= 0 ) - bresl = rresl; - else - bresl = float4(bres.x,bres.y,1,1); - float4 ncoord = floor(coord*bresl)/bresl; - float4 rratio = rresl/bresl; - if ( !bnoscale ) - { - if ( bratio ) - rratio /= min(rratio.x,rratio.y); - else - rratio /= rratio; - } - rratio *= 1+bborderf; - ncoord = ((ncoord-float4(0.5,0.5,0,0))*rratio)+float4(0.5,0.5,0,0); - float4 tcol = tex2Dlod(SamplerColor,ncoord); - /* clamp */ - if ( ncoord.x < 0 || ncoord.x >= 1 || ncoord.y < 0 || ncoord.y >= 1 ) - tcol *= 0; - /* 64-color (4bpc) AOS EGA region */ - if ( paltype == 0 ) - { - /* dither */ - bool evx = (coord.x*bresl.x)%2 < 1; - bool evy = (coord.y*bresl.y)%2 < 1; - if ( evx != evy ) - tcol = tcol+float4(1,1,1,0)*0.01; - else - tcol = tcol-float4(1,1,1,0)*0.01; - /* truncate */ - res.rgb = trunc(tcol.rgb*16.0)/16.0; - /* additional brightness bump */ - res = res+float4(1,1,1,0)*0.02; - } - /* 6bpc */ - else if ( paltype == 1 ) - { - /* dither */ - bool evx = (coord.x*bresl.x)%2 < 1; - bool evy = (coord.y*bresl.y)%2 < 1; - if ( evx != evy ) - tcol = tcol+float4(1,1,1,0)*0.01; - else - tcol = tcol-float4(1,1,1,0)*0.01; - /* truncate */ - res.rgb = trunc(tcol.rgb*64.0)/64.0; - /* additional brightness bump */ - res = res+float4(1,1,1,0)*0.02; - } - /* CGA palette */ - else if ( paltype == 2 ) - { - float4 dac; - /* brighten shadows */ - tcol.rgb = pow(tcol.rgb,0.5); - /* dither */ - bool evx = (coord.x*bresl.x)%2 < 1; - bool evy = (coord.y*bresl.y)%2 < 1; - if ( evx != evy ) - tcol = tcol+float4(1,1,1,0)*0.01; - else - tcol = tcol-float4(1,1,1,0)*0.01; - /* additional brightness bump */ - tcol = tcol-float4(1,1,1,0)*0.01; - /* oversaturate components */ - dac.a = (tcol.r+tcol.g+tcol.b)/3.0; - dac.r = dac.a+(tcol.r-dac.a)*3.0; - dac.g = dac.a+(tcol.g-dac.a)*3.0; - dac.b = dac.a+(tcol.b-dac.a)*3.0; - /* color lookup */ - #ifdef AOSCGA - float3 cgapal[16] = - { - float3(0.000000,0.000000,0.000000), - float3(0.500000,0.000000,0.000000), - float3(0.125000,0.500000,0.000000), - float3(0.625000,0.250000,0.125000), - float3(0.000000,0.125000,0.343750), - float3(0.234375,0.000000,0.343750), - float3(0.062500,0.625000,0.812500), - float3(0.343750,0.343750,0.343750), - float3(0.125000,0.125000,0.125000), - float3(1.000000,0.250000,0.250000), - float3(0.281250,1.000000,0.250000), - float3(1.000000,0.875000,0.234375), - float3(0.187500,0.500000,1.000000), - float3(0.750000,0.187500,1.000000), - float3(0.281250,0.875000,1.000000), - float3(1.000000,1.000000,1.000000), - }; - #else - float3 cgapal[16] = - { - float3(0.000,0.000,0.000), - float3(0.333,0.000,0.000), - float3(0.000,0.333,0.000), - float3(0.333,0.333,0.000), - float3(0.000,0.000,0.333), - float3(0.333,0.000,0.333), - float3(0.000,0.333,0.333), - float3(0.666,0.666,0.666), - float3(0.333,0.333,0.333), - float3(1.000,0.333,0.333), - float3(0.333,1.000,0.333), - float3(1.000,1.000,0.333), - float3(0.333,0.333,1.000), - float3(1.000,0.333,1.000), - float3(0.333,1.000,1.000), - float3(1.000,1.000,1.000), - }; - #endif - float dist = 2.0; - int idx = 0; - for ( int i=0; i<16; i++ ) - { - if ( distance(dac.rgb,cgapal[i]) < dist ) - { - idx = i; - dist = distance(dac.rgb,cgapal[i]); - } - } - res.rgb = cgapal[idx]; - /* additional brightness bump */ - res = res+float4(1,1,1,0)*0.02; - } - /* RGB565 */ - else if ( paltype == 3 ) - { - /* dither */ - bool evx = (coord.x*bresl.x)%2 < 1; - bool evy = (coord.y*bresl.y)%2 < 1; - if ( evx != evy ) - tcol = tcol+float4(1,1,1,0)*0.01; - else - tcol = tcol-float4(1,1,1,0)*0.01; - /* truncate */ - res.r = trunc(tcol.r*32.0)/32.0; - res.g = trunc(tcol.g*64.0)/64.0; - res.b = trunc(tcol.b*32.0)/32.0; - /* additional brightness bump */ - res = res+float4(1,1,1,0)*0.02; - } -#endif - return res; -} - -float4 PS_ProcessDotmatrix( VS_OUTPUT_POST IN, float2 vPos : VPOS ) : COLOR -{ - float4 coord = float4(IN.txcoord.x,IN.txcoord.y,0,0); - float4 res = tex2Dlod(SamplerColor,coord); -#ifdef EDOTMATRIX - /* number of dots */ - float4 bresl = float4(ScreenSize.x,ScreenSize.x*ScreenSize.w,1,1); - bresl.xy *= 1.0/dotsize; - /* RGBI dot luminance values */ - float4 dac = float4(res.r*0.5,res.g*0.5,res.b*0.5, - (res.r+res.g+res.b)/6.0); - float3 tcol; - /* 2x2 matrix */ - if ( ((coord.x*bresl.x)%2 < 1) && ((coord.y*bresl.y)%2 < 1) ) - tcol.rgb = float3(dac.r,0,0); - else if ( ((coord.x*bresl.x)%2 >= 0) && ((coord.y*bresl.y)%2 < 1) ) - tcol.rgb = float3(0,dac.g,0); - else if ( ((coord.x*bresl.x)%2 < 1) && ((coord.y*bresl.y)%2 >= 0) ) - tcol.rgb = float3(0,0,dac.b); - else - tcol.rgb = float3(dac.a,dac.a,dac.a); - /* blend in */ - res.rgb = res.rgb*(1-dotblend)+tcol.rgb*dotblend; - /* screen boundary */ - float2 bfact = float2(0.0,0.0); - float2 bounds = float2(bfact.x/bresl.x,bfact.y/bresl.y); - if ( (coord.x < bounds.x) || (coord.x > 1-bounds.x) - || (coord.y < bounds.y) || (coord.y > 1-bounds.y) ) - res *= 0; -#endif - return res; -} - -/* pseudorandom number generator */ -float random( in float2 uv ) -{ - float2 n = frac(sin(dot(uv,float2(12.9898,78.233)*2.0))*43758.5453); - return abs(n.x+n.y)*0.5; -} - -float4 PS_ProcessGrain( VS_OUTPUT_POST IN, float2 vPos : VPOS ) : COLOR -{ - float4 coord = float4(IN.txcoord.x,IN.txcoord.y,0,0); - float4 res = tex2Dlod(SamplerColor,coord); -#ifdef EGRAIN - float ts = Timer.x*nf; - float2 tcs = coord.xy; - float2 s1 = tcs+float2(0,ts); - float2 s2 = tcs+float2(ts,0); - float2 s3 = tcs+float2(ts,ts); - float n1 = random(s1); - float n2 = random(s2); - float n3 = random(s3); - float n4 = (n1+n2+n3)/3; - float3 ng = float3(n4,n4,n4); - float3 nc = float3(n1,n2,n3); - res.rgb += lerp(ng,nc,ns)*ni-0.5*ni; -#endif - return res; -} - -technique PostProcess -{ - pass P0 - { - VertexShader = compile vs_3_0 VS_Process(); - PixelShader = compile ps_3_0 PS_ProcessBlur(); - DitherEnable = FALSE; - ZEnable = FALSE; - CullMode = NONE; - ALPHATESTENABLE = FALSE; - SEPARATEALPHABLENDENABLE = FALSE; - AlphaBlendEnable = FALSE; - StencilEnable = FALSE; - FogEnable = FALSE; - SRGBWRITEENABLE = FALSE; - } -} - -technique PostProcess2 -{ - pass P0 - { - VertexShader = compile vs_3_0 VS_Process(); - PixelShader = compile ps_3_0 PS_ProcessCrossblur(); - DitherEnable = FALSE; - ZEnable = FALSE; - CullMode = NONE; - ALPHATESTENABLE = FALSE; - SEPARATEALPHABLENDENABLE = FALSE; - AlphaBlendEnable = FALSE; - StencilEnable = FALSE; - FogEnable = FALSE; - SRGBWRITEENABLE = FALSE; - } -} - -technique PostProcess3 -{ - pass P0 - { - VertexShader = compile vs_3_0 VS_Process(); - PixelShader = compile ps_3_0 PS_ProcessGrain(); - DitherEnable = FALSE; - ZEnable = FALSE; - CullMode = NONE; - ALPHATESTENABLE = FALSE; - SEPARATEALPHABLENDENABLE = FALSE; - AlphaBlendEnable = FALSE; - StencilEnable = FALSE; - FogEnable = FALSE; - SRGBWRITEENABLE = FALSE; - } -} - -technique PostProcess4 -{ - pass P0 - { - VertexShader = compile vs_3_0 VS_Process(); - PixelShader = compile ps_3_0 PS_ProcessBlock(); - DitherEnable = FALSE; - ZEnable = FALSE; - CullMode = NONE; - ALPHATESTENABLE = FALSE; - SEPARATEALPHABLENDENABLE = FALSE; - AlphaBlendEnable = FALSE; - StencilEnable = FALSE; - FogEnable = FALSE; - SRGBWRITEENABLE = FALSE; - } -} - -technique PostProcess5 -{ - pass P0 - { - VertexShader = compile vs_3_0 VS_Process(); - PixelShader = compile ps_3_0 PS_ProcessDotmatrix(); - DitherEnable = FALSE; - ZEnable = FALSE; - CullMode = NONE; - ALPHATESTENABLE = FALSE; - SEPARATEALPHABLENDENABLE = FALSE; - AlphaBlendEnable = FALSE; - StencilEnable = FALSE; - FogEnable = FALSE; - SRGBWRITEENABLE = FALSE; - } -} - -technique PostProcess6 -{ - pass P0 - { - VertexShader = compile vs_3_0 VS_Process(); - PixelShader = compile ps_3_0 PS_ProcessDirt(); - DitherEnable = FALSE; - ZEnable = FALSE; - CullMode = NONE; - ALPHATESTENABLE = FALSE; - SEPARATEALPHABLENDENABLE = FALSE; - AlphaBlendEnable = FALSE; - StencilEnable = FALSE; - FogEnable = FALSE; - SRGBWRITEENABLE = FALSE; - } -} - -technique PostProcess7 -{ - pass P0 - { - VertexShader = compile vs_3_0 VS_Process(); - PixelShader = compile ps_3_0 PS_ProcessCurve(); - DitherEnable = FALSE; - ZEnable = FALSE; - CullMode = NONE; - ALPHATESTENABLE = FALSE; - SEPARATEALPHABLENDENABLE = FALSE; - AlphaBlendEnable = FALSE; - StencilEnable = FALSE; - FogEnable = FALSE; - SRGBWRITEENABLE = FALSE; - } -} +/* + effect.txt : MariENB additional filters. + (C)2013 Marisa Kirisame, UnSX Team. + Part of MariENB, the personal ENB of Marisa. + Released under the MIT License. +*/ +/* FXAA */ +bool fxaaenable +< + string UIName = "EnableFXAA"; + string UIWidget = "Checkbox"; +> = {false}; +float fxaaspanmax +< + string UIName = "FXAASpanMax"; + string UIWidget = "Checkbox"; +> = {4.0}; +float fxaareducemul +< + string UIName = "FXAAReduceMul"; + string UIWidget = "Checkbox"; +> = {16.0}; +float fxaareducemin +< + string UIName = "FXAAReduceMin"; + string UIWidget = "Checkbox"; +> = {128.0}; +/* border blurring */ +bool bbenable +< + string UIName = "BlurEnable"; + string UIWidget = "Checkbox"; +> = {true}; +/* border blur sampling range */ +float bbsamp +< + string UIName = "BlurSample"; + string UIWidget = "Spinner"; +> = {1.0}; +/* border blur level */ +int bblevel +< + string UIName = "BlurLevel"; + string UIWidget = "Spinner"; +> = {1}; +/* blend power of blur */ +float bbpow +< + string UIName = "BlurPower"; + string UIWidget = "Spinner"; +> = {15.46}; +/* falloff curve of blur towards center of screen */ +float bbcurve +< + string UIName = "BlurCurve"; + string UIWidget = "Spinner"; +> = {1.2}; +/* blur falloff radius */ +float bbradius +< + string UIName = "BlurRadius"; + string UIWidget = "Spinner"; +> = {0.69}; +/* border darkening */ +bool dkenable +< + string UIName = "DarkEnable"; + string UIWidget = "Checkbox"; +> = {true}; +/* radius of darkening (relative to screen width) */ +float dkradius +< + string UIName = "DarkRadius"; + string UIWidget = "Spinner"; +> = {0.37}; +/* falloff of darkening */ +float dkcurve +< + string UIName = "DarkCurve"; + string UIWidget = "Spinner"; +> = {1.94}; +/* bump of darkening */ +float dkbump +< + string UIName = "DarkBump"; + string UIWidget = "Spinner"; +> = {0.79}; +/* shine/bloom compensation */ +bool compenable +< + string UIName = "EnableCompensate"; + string UIWidget = "Checkbox"; +> = {true}; +/* compensation factor */ +float compfactor +< + string UIName = "CompensateFactor"; + string UIWidget = "Spinner"; +> = {0.19}; +/* compensation power */ +float comppow +< + string UIName = "CompensatePower"; + string UIWidget = "Spinner"; +> = {1.05}; +/* compensation saturation */ +float compsat +< + string UIName = "CompensateSaturation"; + string UIWidget = "Spinner"; +> = {0.3}; +/* brightness bump for compensation */ +float compbump +< + string UIName = "CompensateBump"; + string UIWidget = "Spinner"; +> = {0.0}; +bool gradeenable +< + string UIName = "EnableGrading"; + string UIWidget = "Checkbox"; +> = {true}; +/* miscellaneous color grading parameters */ +float gradeadd_r +< + string UIName = "GradingAddR"; + string UIWidget = "Spinner"; +> = {0.0}; +float gradeadd_g +< + string UIName = "GradingAddG"; + string UIWidget = "Spinner"; +> = {0.0}; +float gradeadd_b +< + string UIName = "GradingAddB"; + string UIWidget = "Spinner"; +> = {0.0}; +float grademul_r +< + string UIName = "GradingMulR"; + string UIWidget = "Spinner"; +> = {1.02}; +float grademul_g +< + string UIName = "GradingMulG"; + string UIWidget = "Spinner"; +> = {1.08}; +float grademul_b +< + string UIName = "GradingMulB"; + string UIWidget = "Spinner"; +> = {1.04}; +float gradepow_r +< + string UIName = "GradingPowR"; + string UIWidget = "Spinner"; +> = {1.07}; +float gradepow_g +< + string UIName = "GradingPowG"; + string UIWidget = "Spinner"; +> = {1.12}; +float gradepow_b +< + string UIName = "GradingPowB"; + string UIWidget = "Spinner"; +> = {1.08}; +float gradecol_r +< + string UIName = "GradingColR"; + string UIWidget = "Spinner"; +> = {0.04}; +float gradecol_g +< + string UIName = "GradingColG"; + string UIWidget = "Spinner"; +> = {0.07}; +float gradecol_b +< + string UIName = "GradingColB"; + string UIWidget = "Spinner"; +> = {0.59}; +float gradecolfact +< + string UIName = "GradingColFactor"; + string UIWidget = "Spinner"; +> = {-0.24}; +/* Soft grain */ +bool ne +< + string UIName = "EnableSoftGrain"; + string UIWidget = "Checkbox"; +> = {true}; +/* soft grain speed */ +float nf +< + string UIName = "SoftGrainSpeed"; + string UIWidget = "Spinner"; +> = {2.68}; +/* soft grain intensity */ +float ni +< + string UIName = "SoftGrainIntensity"; + string UIWidget = "Spinner"; +> = {0.04}; +/* soft grain saturation */ +float ns +< + string UIName = "SoftGrainSaturation"; + string UIWidget = "Spinner"; +> = {0.09}; +/* Two-pass noise */ +bool np +< + string UIName = "SoftGrainTwopass"; + string UIWidget = "Checkbox"; +> = {true}; +/* grain blend function: 0 normal, 1 add, 2 overlay, 3 multiply */ +int nb +< + string UIName = "SoftGrainBlendfunc"; + string UIWidget = "Spinner"; +> = {1}; +/* grain deviation */ +float nk +< + string UIName = "SoftGrainDeviation"; + string UIWidget = "Spinner"; +> = {0.05}; +/* grain magnification */ +float nm1 +< + string UIName = "SoftGrainMagnification1"; + string UIWidget = "Spinner"; +> = {1.25}; +float nm2 +< + string UIName = "SoftGrainMagnification2"; + string UIWidget = "Spinner"; +> = {0.64}; +float nm3 +< + string UIName = "SoftGrainMagnification3"; + string UIWidget = "Spinner"; +> = {0.35}; +/* grain magnification pass 1 */ +float nm11 +< + string UIName = "SoftGrainMagnification11"; + string UIWidget = "Spinner"; +> = {2.05}; +float nm12 +< + string UIName = "SoftGrainMagnification12"; + string UIWidget = "Spinner"; +> = {3.11}; +float nm13 +< + string UIName = "SoftGrainMagnification13"; + string UIWidget = "Spinner"; +> = {2.22}; +/* grain magnification pass 2 */ +float nm21 +< + string UIName = "SoftGrainMagnification21"; + string UIWidget = "Spinner"; +> = {4.25}; +float nm22 +< + string UIName = "SoftGrainMagnification22"; + string UIWidget = "Spinner"; +> = {0.42}; +float nm23 +< + string UIName = "SoftGrainMagnification23"; + string UIWidget = "Spinner"; +> = {6.29}; +/* grain power */ +float nj +< + string UIName = "SoftGrainPower"; + string UIWidget = "Spinner"; +> = {2.93}; +/* Block graphics filter with palette reduction */ +bool benable +< + string UIName = "EnableBlockGFX"; + string UIWidget = "Checkbox"; +> = {false}; +/* emulated resolution for block graphics (0 or less for real resolution) */ +float bresw +< + string UIName = "BlockGFXResolutionW"; + string UIWidget = "Spinner"; +> = {1.0}; +float bresh +< + string UIName = "BlockGFXResolutionH"; + string UIWidget = "Spinner"; +> = {1.0}; +/* do not scale */ +bool bnoscale +< + string UIName = "BlockGFXNoScale"; + string UIWidget = "Checkbox"; +> = {false}; +/* perform aspect ratio correction on emulated screen (ignored if no scale) */ +bool bratio +< + string UIName = "BlockGFXAspect"; + string UIWidget = "Checkbox"; +> = {false}; +/* extra border factor (negative values for overscan) */ +float bborderf +< + string UIName = "BlockGFXBorder"; + string UIWidget = "Spinner"; +> = {0.00}; +/* palette type for block graphics */ +int bpaltype +< + string UIName = "BlockGFXpalette"; + string UIWidget = "Spinner"; +> = {5}; +/* CGA subpalette */ +int bcganum +< + string UIName = "BlockGFXcgamode"; + string UIWidget = "Spinner"; +> = {0}; +/* Dirty screen effect (static noise) */ +bool dirtenable +< + string UIName = "EnableDirt"; + string UIWidget = "Checkbox"; +> = {true}; +/* dirt amount */ +float dirtcfactor +< + string UIName = "DirtCoordFactor"; + string UIWidget = "Spinner"; +> = {0.09}; +float dirtlfactor +< + string UIName = "DirtLuminanceFactor"; + string UIWidget = "Spinner"; +> = {0.0}; +float dirtmc +< + string UIName = "DirtCoordMagnification"; + string UIWidget = "Spinner"; +> = {3.04}; +float dirtml +< + string UIName = "DirtLuminanceMagnification"; + string UIWidget = "Spinner"; +> = {1.0}; +/* Letterbox */ +bool boxe +< + string UIName = "EnableBox"; + string UIWidget = "Checkbox"; +> = {true}; +/* horizontal factor */ +float boxh +< + string UIName = "BoxHorizontal"; + string UIWidget = "Spinner"; +> = {1.5}; +/* vertical factor */ +float boxv +< + string UIName = "BoxVertical"; + string UIWidget = "Spinner"; +> = {1.0}; +/* softening */ +float boxb +< + string UIName = "BoxSoften"; + string UIWidget = "Spinner"; +> = {0.02}; +/* box alpha */ +float boxa +< + string UIName = "BoxAlpha"; + string UIWidget = "Spinner"; +> = {6.07}; +/* Use CRT curvature shader */ +bool crtenable +< + string UIName = "EnableCurvature"; + string UIWidget = "Checkbox"; +> = {false}; +/* chromatic aberration on CRT: fancy effect that isn't really realistic */ +float chromaab +< + string UIName = "CurveChromaticAberration"; + string UIWidget = "Spinner"; +> = {0.93}; +/* curvature lens zoom (0.5 = none) */ +float lenszoom +< + string UIName = "CurveZoom"; + string UIWidget = "Spinner"; +> = {50.0}; +/* curvature lens distortion */ +float lensdist +< + string UIName = "CurveLens"; + string UIWidget = "Spinner"; +> = {0.0}; +/* curvature CUBIC lens distortion */ +float lensdistc +< + string UIName = "CurveLensCubic"; + string UIWidget = "Spinner"; +> = {0.0}; +/* do not touch this! */ +#define E_SHADER_3_0 +/* texture sizes */ +#define NOISERES 256.0 +/* gaussian blur matrices */ +const float2x2 gauss3 = +{ + 0.16,0.12, + 0.12,0.09 +}; +const float3x3 gauss5 = +{ + 0.0865051903114,0.0692041522491,0.0346020761246, + 0.0692041522491,0.0553633217993,0.0276816609, + 0.0346020761246,0.0276816609,0.01384083045 +}; +const float4x4 gauss7 = +{ + 0.0632507440209,0.0527089533508,0.0301194019147,0.011294775718, + 0.0527089533508,0.0439241277923,0.0250995015956,0.00941231309835, + 0.0301194019147,0.0250995015956,0.01434257234,0.00537846462763, + 0.011294775718,0.00941231309835,0.00537846462763,0.00201692423536 +}; +/* standard stuff (not all used) */ +float tempF1; +float tempF2; +float tempF3; +float tempF4; +float tempF5; +float tempF6; +float tempF7; +float tempF8; +float tempF9; +float tempF0; +float4 ScreenSize; +float ENightDayFactor; +float EInteriorFactor; +float4 Timer; +float FieldOfView; +/* samplers and textures (some not yet used) */ +texture2D texColor; +texture2D texDepth; +texture2D texPalette; +sampler2D SamplerColor = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; +sampler2D SamplerDepth = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; +sampler2D SamplerPalette = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; +texture2D texNoise1 +< + string ResourceName = "menbnoise1.png"; +>; +texture2D texNoise2 +< + string ResourceName = "menbnoise2.png"; +>; +texture2D texNoise3 +< + string ResourceName = "menbnoise3.png"; +>; +sampler2D SamplerNoise1 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = POINT; + MipFilter = NONE; + AddressU = Wrap; + AddressV = Wrap; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; +sampler2D SamplerNoise2 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = POINT; + MipFilter = NONE; + AddressU = Wrap; + AddressV = Wrap; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; +sampler2D SamplerNoise3 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Wrap; + AddressV = Wrap; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; +/* whatever */ +struct VS_OUTPUT_POST +{ + float4 vpos : POSITION; + float2 txcoord : TEXCOORD0; +}; +struct VS_INPUT_POST +{ + float3 pos : POSITION; + float2 txcoord : TEXCOORD0; +}; +/* Shader routines */ +VS_OUTPUT_POST VS_Process(VS_INPUT_POST IN) +{ + VS_OUTPUT_POST OUT; + float4 pos = float4(IN.pos.x,IN.pos.y,IN.pos.z,1); + OUT.vpos = pos; + OUT.txcoord.xy = IN.txcoord.xy; + return OUT; +} +float4 PS_Process(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float2 coord = float2(IN.txcoord.x,IN.txcoord.y); + float4 res = tex2D(SamplerColor,coord); + return res; +} +float4 PS_ProcessPass1(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float2 coord = float2(IN.txcoord.x,IN.txcoord.y); + float4 res = tex2D(SamplerColor,coord); + if ( fxaaenable ) + { + float fxaareducemul_ = 1.0/max(abs(fxaareducemul),1.0); + float fxaareducemin_ = 1.0/max(abs(fxaareducemin),1.0); + float2 bresl = float2(ScreenSize.x,ScreenSize.x*ScreenSize.w); + float2 bof = float2(1.0/bresl.x,1.0/bresl.y); + float3 rgbNW = tex2D(SamplerColor,coord+float2(-1,-1)*bof).rgb; + float3 rgbNE = tex2D(SamplerColor,coord+float2(1,-1)*bof).rgb; + float3 rgbSW = tex2D(SamplerColor,coord+float2(-1,1)*bof).rgb; + float3 rgbSE = tex2D(SamplerColor,coord+float2(1,1)*bof).rgb; + float3 rgbM = tex2D(SamplerColor,coord).rgb; + float3 luma = float3(0.299,0.587,0.114); + float lumaNW = dot(rgbNW,luma); + float lumaNE = dot(rgbNE,luma); + float lumaSW = dot(rgbSW,luma); + float lumaSE = dot(rgbSE,luma); + float lumaM = dot(rgbM,luma); + float lumaMin = min(lumaM,min(min(lumaNW,lumaNE),min(lumaSW,lumaSE))); + float lumaMax = max(lumaM,max(max(lumaNW,lumaNE),max(lumaSW,lumaSE))); + float2 dir = float2(-((lumaNW+lumaNE)-(lumaSW+lumaSE)),((lumaNW+lumaSW) + -(lumaNE+lumaSE))); + float dirReduce = max((lumaNW+lumaNE+lumaSW+lumaSE)*(0.25 + *fxaareducemul_),fxaareducemin_); + float rcpDirMin = 1.0/(min(abs(dir.x),abs(dir.y))+dirReduce); + dir = min(float2(fxaaspanmax,fxaaspanmax),max(float2(-fxaaspanmax, + -fxaaspanmax),dir*rcpDirMin))/bresl; + float3 rgbA = (1.0/2.0)*(tex2D(SamplerColor,coord+dir*(1.0/3.0-0.5)) + .rgb+tex2D(SamplerColor,coord+dir*(2.0/3.0-0.5)).rgb); + float3 rgbB = rgbA*(1.0/2.0)+(1.0/4.0)*(tex2D(SamplerColor,coord+dir + *(0.0/3.0-0.5)).rgb+tex2D(SamplerColor,coord+dir*(3.0/3.0 + -0.5)).rgb); + float lumaB = dot(rgbB,luma); + if ( (lumaB < lumaMin) || (lumaB > lumaMax) ) + res.rgb = rgbA; + else + res.rgb = rgbB; + } + return res; +} +float4 PS_ProcessPass2(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float2 coord = float2(IN.txcoord.x,IN.txcoord.y); + float4 res = tex2D(SamplerColor,coord); + if ( bbenable ) + { + float4 origcolor = res; + float4 tcol = float4(0,0,0,0); + float2 bresl = float2(ScreenSize.x,ScreenSize.x*ScreenSize.w); + float2 bof = float2(1.0/bresl.x,1.0/bresl.y)*bbsamp; + int i, j; + if ( bblevel == 1 ) + { + for ( i=-2; i<=2; i++ ) + for ( j=-2; j<=2; j++ ) + tcol += gauss5[abs(i)][abs(j)] + *tex2D(SamplerColor,coord+float2(i,j)*bof); + } + else if ( bblevel == 2 ) + { + for ( i=-3; i<=3; i++ ) + for ( j=-3; j<=3; j++ ) + tcol += gauss7[abs(i)][abs(j)] + *tex2D(SamplerColor,coord+float2(i,j)*bof); + } + else + { + for ( i=-1; i<=1; i++ ) + for ( j=-1; j<=1; j++ ) + tcol += gauss3[abs(i)][abs(j)] + *tex2D(SamplerColor,coord+float2(i,j)*bof); + } + float2 uv = (coord.xy-0.5)*bbradius; + float vig = clamp(pow(saturate(dot(uv.xy,uv.xy)),bbcurve),0.0,1.0); + res.rgb = lerp(origcolor.rgb,tcol.rgb,clamp(vig*bbpow,0.0,1.0)); + } + if ( dkenable ) + { + float2 bresl = float2(1.0,ScreenSize.w); + float2 bof = bresl*dkradius; + float val = 0.0; + if ( coord.x < bof.x ) + val = lerp(val,1,1.0-coord.x/bof.x); + if ( coord.y < bof.y ) + val = lerp(val,1,1.0-coord.y/bof.y); + if ( 1.0-coord.x < bof.x ) + val = lerp(val,1,1.0-(1.0-coord.x)/bof.x); + if ( 1.0-coord.y < bof.y ) + val = lerp(val,1,1.0-(1.0-coord.y)/bof.y); + val = clamp(val*dkbump,0,1); + res.rgb = lerp(res.rgb,float3(0,0,0),pow(val,dkcurve)); + } + if ( ne ) + { + float ts = Timer.x*nf; + ts *= 1000.0; + float2 tcs = coord; + float2 s1 = tcs+float2(0,ts); + float2 s2 = tcs+float2(ts,0); + float2 s3 = tcs+float2(ts,ts); + float n1, n2, n3; + float2 nr = float2(ScreenSize.x,ScreenSize.x*ScreenSize.w)/NOISERES; + if ( np ) + { + n1 = tex2D(SamplerNoise2,s1*nm11*nr).r; + n2 = tex2D(SamplerNoise2,s2*nm12*nr).g; + n3 = tex2D(SamplerNoise2,s3*nm13*nr).b; + s1 = tcs+float2(ts+n1*nk,n2*nk); + s2 = tcs+float2(n2,ts+n3*nk); + s3 = tcs+float2(ts+n3*nk,ts+n1*nk); + n1 = tex2D(SamplerNoise2,s1*nm21*nr).r; + n2 = tex2D(SamplerNoise2,s2*nm22*nr).g; + n3 = tex2D(SamplerNoise2,s3*nm23*nr).b; + } + else + { + n1 = tex2D(SamplerNoise3,s1*nm1*nr).r; + n2 = tex2D(SamplerNoise3,s2*nm2*nr).g; + n3 = tex2D(SamplerNoise3,s3*nm3*nr).b; + } + float n4 = (n1+n2+n3)/3; + float3 ng = float3(n4,n4,n4); + float3 nc = float3(n1,n2,n3); + float3 nt = pow(clamp(lerp(ng,nc,ns),0.0,1.0),nj); + if ( nb == 1 ) + res.rgb += nt*ni; + else if ( nb == 2 ) + { + res.r = (res.r<0.5)?(2.0*res.r*(0.5+(nt.r*ni))) + :(1.0-2.0*(1.0-res.r)*(1.0-((0.5+(nt.r*ni))))); + res.g = (res.g<0.5)?(2.0*res.g*(0.5+(nt.g*ni))) + :(1.0-2.0*(1.0-res.g)*(1.0-((0.5+(nt.g*ni))))); + res.b = (res.b<0.5)?(2.0*res.b*(0.5+(nt.b*ni))) + :(1.0-2.0*(1.0-res.b)*(1.0-((0.5+(nt.b*ni))))); + } + else if ( nb == 3 ) + res.rgb *= 1.0+(nt*ni); + else + res.rgb = lerp(res.rgb,nt,ni); + } + if ( compenable ) + { + float4 ovr = pow(saturate(res+compbump),comppow); + float ovrs = (ovr.r+ovr.g+ovr.b)/3.0; + ovr = ovr*compsat+ovrs*(1.0-compsat); + res.rgb -= ovr.rgb*compfactor; + } + if ( gradeenable ) + { + float3 gradeadd = float3(gradeadd_r,gradeadd_g,gradeadd_b); + float3 grademul = float3(grademul_r,grademul_g,grademul_b); + float3 gradepow = float3(gradepow_r,gradepow_g,gradepow_b); + float3 gradecol = float3(gradecol_r,gradecol_g,gradecol_b); + res.rgb = saturate(res.rgb+gradeadd); + res.rgb = saturate(res.rgb*grademul); + res.rgb = saturate(pow(res.rgb,gradepow)); + float tonev = (res.r+res.g+res.b)/3.0; + float3 tonecolor = gradecol*tonev; + res.rgb = res.rgb*(1.0-gradecolfact)+tonecolor*gradecolfact; + } + if ( dirtenable ) + { + float2 r = float2(ScreenSize.x,ScreenSize.x*ScreenSize.w)/NOISERES; + float4 ncolc = tex2D(SamplerNoise1,coord*dirtmc*r); + float2 ds = float2(res.r+res.g,res.g+res.b)/2.0; + float4 ncoll = tex2D(SamplerNoise1,ds*dirtml); + res = lerp(res,(ncolc.r+1)*res, + dirtcfactor*saturate(1-(ds.x+ds.y)*0.25)); + res = lerp(res,(ncoll.r+1)*res, + dirtlfactor*saturate(1-(ds.x+ds.y)*0.25)); + } + if ( boxe ) + { + float boxf = pow(clamp(boxh-abs(2.0*coord.x-1.0),0.0,1.0),boxb) + *pow(clamp(boxv-abs(2.0*coord.y-1.0),0.0,1.0),boxb); + res.rgb = lerp(res.rgb*(1.0-boxa),res.rgb,boxf); + } + return res; +} +float4 PS_ProcessPass3(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float2 coord = float2(IN.txcoord.x,IN.txcoord.y); + float4 res = tex2D(SamplerColor,coord); + if ( !benable ) + return res; + float2 rresl = float2(ScreenSize.x,ScreenSize.x*ScreenSize.w); + float2 bresl = float2(1,1); + float2 dresl; + if ( bresw <= 0 || bresh <= 0 ) + bresl = rresl; + else + { + if ( bresw <= 1.0 ) + bresl.x = rresl.x*bresw; + else + bresl.x = bresw; + if ( bresh <= 1.0 ) + bresl.y = rresl.y*bresh; + else + bresl.y = bresh; + } + float2 rratio = rresl/bresl; + float2 ncoord = coord; + if ( !bnoscale ) + { + if ( bratio ) + rratio /= min(rratio.x,rratio.y); + else + rratio /= rratio; + rratio *= 1+bborderf; + dresl = bresl*rratio; + ncoord = ((coord-float2(0.5,0.5))*rratio)+float2(0.5,0.5); + ncoord = floor(ncoord*bresl)/bresl; + } + else + { + rratio = float2(1.0,1.0); + dresl = rresl; + } + if ( bresw <= 0 || bresh <= 0 ) + ncoord = coord; + float4 tcol = tex2D(SamplerColor,ncoord); + /* clamp */ + if ( ncoord.x < 0 || ncoord.x >= 1 || ncoord.y < 0 || ncoord.y >= 1 ) + tcol *= 0; + if ( bpaltype == 0 ) + { + float4 dac; + if ( bcganum == 0 ) + { + /* brighten shadows */ + tcol.rgb = pow(tcol.rgb,0.35); + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + tcol -= 0.1; + if ( evx != evy ) + tcol += 0.25; + /* oversaturate components */ + dac.a = (tcol.r+tcol.g+tcol.b)/3.0; + dac.r = dac.a+(tcol.r-dac.a)*5.0; + dac.g = dac.a+(tcol.g-dac.a)*5.0; + dac.b = dac.a+(tcol.b-dac.a)*5.0; + } + else if ( bcganum%2 == 0 ) + { + /* brighten shadows */ + tcol.rgb = pow(tcol.rgb,0.4); + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + tcol -= 0.1; + if ( evx != evy ) + tcol += 0.225; + /* oversaturate components */ + dac.a = (tcol.r+tcol.g+tcol.b)/3.0; + dac.r = dac.a+(tcol.r-dac.a)*4.5; + dac.g = dac.a+(tcol.g-dac.a)*4.5; + dac.b = dac.a+(tcol.b-dac.a)*4.5; + } + else + { + /* brighten shadows */ + tcol.rgb = pow(tcol.rgb,0.45); + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + tcol -= 0.1; + if ( evx != evy ) + tcol += 0.2; + /* oversaturate components */ + dac.a = (tcol.r+tcol.g+tcol.b)/3.0; + dac.r = dac.a+(tcol.r-dac.a)*4.0; + dac.g = dac.a+(tcol.g-dac.a)*4.0; + dac.b = dac.a+(tcol.b-dac.a)*4.0; + } + /* color lookup */ + float3 cgapal[4] = + { + float3(0.000,0.000,0.000), + float3(1.000,1.000,1.000), + float3(0.000,0.000,0.000), + float3(0.000,0.000,0.000), + }; + if ( bcganum == 1 ) + { + cgapal[1] = float3(0.000,0.666,0.666); + cgapal[2] = float3(0.666,0.000,0.666); + cgapal[3] = float3(0.666,0.666,0.666); + } + else if ( bcganum == 2 ) + { + cgapal[1] = float3(0.333,1.000,1.000); + cgapal[2] = float3(1.000,0.333,1.000); + cgapal[3] = float3(1.000,1.000,1.000); + } + else if ( bcganum == 3 ) + { + cgapal[1] = float3(0.000,0.666,0.000); + cgapal[2] = float3(0.666,0.000,0.000); + cgapal[3] = float3(0.666,0.333,0.000); + } + else if ( bcganum == 4 ) + { + cgapal[1] = float3(0.333,1.000,0.333); + cgapal[2] = float3(1.000,0.333,0.333); + cgapal[3] = float3(0.333,1.000,0.333); + } + else if ( bcganum == 5 ) + { + cgapal[1] = float3(0.000,0.666,0.666); + cgapal[2] = float3(0.666,0.000,0.000); + cgapal[3] = float3(0.666,0.666,0.666); + } + else if ( bcganum == 6 ) + { + cgapal[1] = float3(0.333,1.000,1.000); + cgapal[2] = float3(1.000,0.333,0.333); + cgapal[3] = float3(1.000,1.000,1.000); + } + float dist = 2.0; + int idx = 0; + for ( int i=0; i<4; i++ ) + { + if ( distance(dac.rgb,cgapal[i]) < dist ) + { + idx = i; + dist = distance(dac.rgb,cgapal[i]); + } + } + res.rgb = cgapal[idx]; + } + else if ( bpaltype == 1 ) + { + float4 dac; + /* brighten shadows */ + tcol.rgb = pow(tcol.rgb,0.5); + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + tcol -= 0.04; + if ( evx != evy ) + tcol += 0.08; + /* oversaturate components */ + dac.a = (tcol.r+tcol.g+tcol.b)/3.0; + dac.r = dac.a+(tcol.r-dac.a)*3.0; + dac.g = dac.a+(tcol.g-dac.a)*3.0; + dac.b = dac.a+(tcol.b-dac.a)*3.0; + float3 egapal[16] = + { + float3(0.000,0.000,0.000), + float3(0.666,0.000,0.000), + float3(0.000,0.666,0.000), + float3(0.666,0.333,0.000), + float3(0.000,0.000,0.666), + float3(0.666,0.000,0.666), + float3(0.000,0.666,0.666), + float3(0.666,0.666,0.666), + float3(0.333,0.333,0.333), + float3(1.000,0.333,0.333), + float3(0.333,1.000,0.333), + float3(1.000,1.000,0.333), + float3(0.333,0.333,1.000), + float3(1.000,0.333,1.000), + float3(0.333,1.000,1.000), + float3(1.000,1.000,1.000), + }; + float dist = 2.0; + int idx = 0; + for ( int i=0; i<16; i++ ) + { + if ( distance(dac.rgb,egapal[i]) < dist ) + { + idx = i; + dist = distance(dac.rgb,egapal[i]); + } + } + res.rgb = egapal[idx]; + } + else if ( bpaltype == 2 ) + { + float4 dac; + /* brighten shadows */ + tcol.rgb = pow(tcol.rgb,0.5); + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + tcol -= 0.04; + if ( evx != evy ) + tcol += 0.08; + /* oversaturate components */ + dac.a = (tcol.r+tcol.g+tcol.b)/3.0; + dac.r = dac.a+(tcol.r-dac.a)*3.0; + dac.g = dac.a+(tcol.g-dac.a)*3.0; + dac.b = dac.a+(tcol.b-dac.a)*3.0; + /* color lookup */ + float3 egapal[16] = + { + float3(0.000000,0.000000,0.000000), + float3(0.500000,0.000000,0.000000), + float3(0.125000,0.500000,0.000000), + float3(0.625000,0.250000,0.125000), + float3(0.000000,0.125000,0.343750), + float3(0.234375,0.000000,0.343750), + float3(0.062500,0.625000,0.812500), + float3(0.343750,0.343750,0.343750), + float3(0.125000,0.125000,0.125000), + float3(1.000000,0.250000,0.250000), + float3(0.281250,1.000000,0.250000), + float3(1.000000,0.875000,0.234375), + float3(0.187500,0.500000,1.000000), + float3(0.750000,0.187500,1.000000), + float3(0.281250,0.875000,1.000000), + float3(1.000000,1.000000,1.000000), + }; + float dist = 2.0; + int idx = 0; + for ( int i=0; i<16; i++ ) + { + if ( distance(dac.rgb,egapal[i]) < dist ) + { + idx = i; + dist = distance(dac.rgb,egapal[i]); + } + } + res.rgb = egapal[idx]; + } + else if ( bpaltype == 3 ) + { + float4 dac; + /* brighten shadows */ + tcol.rgb = pow(tcol.rgb,0.5); + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + tcol.rgb += 0.02; + if ( evx != evy ) + tcol.rgb += 0.04; + /* oversaturate components */ + dac.a = (tcol.r+tcol.g+tcol.b)/3.0; + dac.r = dac.a+(tcol.r-dac.a)*2.5; + dac.g = dac.a+(tcol.g-dac.a)*2.5; + dac.b = dac.a+(tcol.b-dac.a)*2.5; + /* truncate */ + res.rgb = trunc(dac.rgb*4.0)/4.0; + } + else if ( bpaltype == 4 ) + { + float4 dac; + /* brighten shadows */ + tcol.rgb = pow(tcol.rgb,0.7); + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + tcol.rgb += 0.01; + if ( evx != evy ) + tcol.rgb += 0.02; + /* oversaturate components */ + dac.a = (tcol.r+tcol.g+tcol.b)/3.0; + dac.r = dac.a+(tcol.r-dac.a)*1.5; + dac.g = dac.a+(tcol.g-dac.a)*1.5; + dac.b = dac.a+(tcol.b-dac.a)*1.5; + /* truncate */ + res.r = trunc(dac.r*8.0)/8.0; + res.g = trunc(dac.g*4.0)/4.0; + res.b = trunc(dac.b*8.0)/8.0; + } + else if ( bpaltype == 5 ) + { + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + tcol.rgb += 0.01; + if ( evx != evy ) + tcol.rgb += 0.02; + /* truncate */ + res.rgb = trunc(tcol.rgb*16.0)/16.0; + } + else if ( bpaltype == 6 ) + { + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + if ( evx == evy ) + tcol.rgb -= 0.002; + /* truncate */ + res.r = trunc(tcol.r*32.0)/32.0; + res.g = trunc(tcol.g*64.0)/64.0; + res.b = trunc(tcol.b*32.0)/32.0; + } + else if ( bpaltype == 7 ) + { + /* dither */ + bool evx = (coord.x*dresl.x)%2 < 1; + bool evy = (coord.y*dresl.y)%2 < 1; + if ( evx == evy ) + tcol.rgb -= 0.001; + /* truncate */ + res.rgb = trunc(tcol.rgb*64.0)/64.0; + } + else + return tcol; + return res; +} +float4 PS_ProcessPass4(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float2 coord = float2(IN.txcoord.x,IN.txcoord.y); + float4 res = tex2D(SamplerColor,coord); + if ( crtenable ) + { + float4 tcol = res; + float3 eta = float3(1+chromaab*0.09,1+chromaab*0.06,1+chromaab*0.03); + float2 center = float2(coord.x-0.5,coord.y-0.5); + float zfact = 100.0/lenszoom; + float r2 = center.x*center.x+center.y*center.y; + float f = 0; + if( lensdistc == 0.0) + f = 1+r2*lensdist*0.1; + else + f = 1+r2*(lensdist*0.1+lensdistc*0.1*sqrt(r2)); + float x = f*zfact*center.x+0.5; + float y = f*zfact*center.y+0.5; + float2 rcoord = (f*eta.r)*zfact*(center.xy*0.5)+0.5; + float2 gcoord = (f*eta.g)*zfact*(center.xy*0.5)+0.5; + float2 bcoord = (f*eta.b)*zfact*(center.xy*0.5)+0.5; + float4 idist = float4(tex2D(SamplerColor,rcoord).r, + tex2D(SamplerColor,gcoord).g, + tex2D(SamplerColor,bcoord).b, + tex2D(SamplerColor,float2(x,y)).a); + res.rgb = idist.rgb; + } + return res; +} +technique PostProcess +{ + pass P0 + { + VertexShader = compile vs_3_0 VS_Process(); + PixelShader = compile ps_3_0 PS_ProcessPass1(); + AlphaBlendEnable = TRUE; + SrcBlend = ONE; + DestBlend = ONE; + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } +} +technique PostProcess2 +{ + pass P0 + { + VertexShader = compile vs_3_0 VS_Process(); + PixelShader = compile ps_3_0 PS_ProcessPass2(); + AlphaBlendEnable = TRUE; + SrcBlend = ONE; + DestBlend = ONE; + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } +} +technique PostProcess3 +{ + pass P0 + { + VertexShader = compile vs_3_0 VS_Process(); + PixelShader = compile ps_3_0 PS_ProcessPass3(); + AlphaBlendEnable = TRUE; + SrcBlend = ONE; + DestBlend = ONE; + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } +} +technique PostProcess4 +{ + pass P0 + { + VertexShader = compile vs_3_0 VS_Process(); + PixelShader = compile ps_3_0 PS_ProcessPass4(); + AlphaBlendEnable = TRUE; + SrcBlend = ONE; + DestBlend = ONE; + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } +} \ No newline at end of file diff --git a/enbbloom.fx b/enbbloom.fx new file mode 100644 index 0000000..63db810 --- /dev/null +++ b/enbbloom.fx @@ -0,0 +1,470 @@ +//++++++++++++++++++++++++++++++++++++++++++++ +// ENBSeries effect file +// visit http://enbdev.com for updates +// Copyright (c) 2007-2011 Boris Vorontsov +//++++++++++++++++++++++++++++++++++++++++++++ + + + +//+++++++++++++++++++++++++++++ +//internal parameters, can be modified +//+++++++++++++++++++++++++++++ +//none + + + +//+++++++++++++++++++++++++++++ +//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=Width, y=1/Width, z=ScreenScaleY, w=1/ScreenScaleY +float4 ScreenSize; +//x=generic timer in range 0..1, period of 16777216 ms (4.6 hours), w=frame time elapsed (in seconds) +float4 Timer; +//additional info for computations +float4 TempParameters; +//Lenz reflection intensity, lenz reflection power +float4 LenzParameters; +//BloomRadius1, BloomRadius2, BloomBlueShiftAmount, BloomContrast +float4 BloomParameters; + + + +texture2D texBloom1; +texture2D texBloom2; +texture2D texBloom3; +texture2D texBloom4; +texture2D texBloom5; +texture2D texBloom6; +texture2D texBloom7;//additional bloom tex +texture2D texBloom8;//additional bloom tex + +sampler2D SamplerBloom1 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE;//NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom2 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE;//NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom3 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE;//NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom4 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE;//NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom5 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE;//NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom6 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE;//NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom7 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE;//NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom8 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE;//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_Bloom(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+TempParameters.xy;//1.0/(bloomtexsize*2.0) + + return OUT; +} + + +//zero pass HQ, input texture is fullscreen +//SamplerBloom1 - fullscreen texture +float4 PS_BloomPrePass(VS_OUTPUT_POST In) : COLOR +{ + float4 bloomuv; + + float4 bloom=0.0;//tex2D(SamplerBloom1, In.txcoord0); + const float2 offset[4]= + { + float2(0.25, 1.25), + float2(0.25, -0.25), + float2(-0.25, 0.25), + float2(-0.25, -0.25) + }; + //TempParameters.w==1 if first pass, ==2 is second pass + float2 screenfact=TempParameters.z; + screenfact.y*=ScreenSize.z; + float4 srcbloom=bloom; + for (int i=0; i<4; i++) + { + bloomuv.xy=offset[i]; + bloomuv.xy=(bloomuv.xy*screenfact.xy)+In.txcoord0.xy; + float4 tempbloom=tex2D(SamplerBloom1, bloomuv.xy); + bloom.xyz+=tempbloom.xyz; + } + bloom.xyz*=0.25; + + bloom.xyz=min(bloom.xyz, 32768.0); + bloom.xyz=max(bloom.xyz, 0.0); + + return bloom; +} + + + +//first and second passes draw to every texture +//twice, after computations of these two passes, +//result is set as input to next cycle + +//first pass +//SamplerBloom1 is result of prepass or second pass from cycle +float4 PS_BloomTexture1(VS_OUTPUT_POST In) : COLOR +{ + float4 bloomuv; + + float4 bloom=tex2D(SamplerBloom1, In.txcoord0); + const float2 offset[8]= + { + float2(1.0, 1.0), + float2(1.0, -1.0), + float2(-1.0, 1.0), + float2(-1.0, -1.0), + float2(0.0, 1.0), + float2(0.0, -1.0), + float2(1.0, 0.0), + float2(-1.0, 0.0) + }; + float2 screenfact=TempParameters.z; + screenfact.y*=ScreenSize.z; + float4 srcbloom=bloom; + //TempParameters.w == (1+passnumber) + float step=BloomParameters.x;//*pow(2.0, BloomParameters.x * (TempParameters.w-1.0));//*0.5 +// float step=(TempParameters.w-0.25);// + screenfact.xy*=step;//==================================================== + + float4 bloomadd=bloom; + + for (int i=0; i<8; i++) + { + bloomuv.xy=offset[i]; + bloomuv.xy=(bloomuv.xy*screenfact.xy)+In.txcoord0.xy;//-(1.0/256.0);//-(1.0/512.0); + float4 tempbloom=tex2D(SamplerBloom1, bloomuv.xy); + bloom+=tempbloom; + } + bloom*=0.111111; + + + //float3 violet=float3(0.78, 0.5, 1.0); + //float3 violet=float3(0.6, 0.4, 1.0);//v2 + float3 violet=float3(0.6, 0.4, 1.0);//v3 +// float3 violet=float3(0.27, 0.52, 1.0);//v4 + + //this applies when white + //float gray=0.104*dot(srcbloom.xyz, 0.333);//max(srcbloom.x, max(srcbloom.y, srcbloom.z)); + //this applies on dark and when contrast + float ttt=dot(bloom.xyz, 0.333)-dot(srcbloom.xyz, 0.333); + ttt=max(ttt, 0.0); + float gray=BloomParameters.z*ttt*10;//max(srcbloom.x, max(srcbloom.y, srcbloom.z)); + float mixfact=(gray/(1.0+gray)); + mixfact*=1.0-saturate((TempParameters.w-1.0)*0.2); + violet.xy+=saturate((TempParameters.w-1.0)*0.3); + violet.xy=saturate(violet.xy); + bloom.xyz*=lerp(1.0, violet.xyz, mixfact); + + bloom.w=1.0; + return bloom; +} + + +//second pass +//SamplerBloom1 is result of first pass +float4 PS_BloomTexture2(VS_OUTPUT_POST In) : COLOR +{ + float4 bloomuv; + + float4 bloom=tex2D(SamplerBloom1, In.txcoord0); + const float2 offset[8]= + { + float2(1.0, 1.0), + float2(1.0, -1.0), + float2(-1.0, 1.0), + float2(-1.0, -1.0), + float2(0.0, 1.0), + float2(0.0, -1.0), + float2(1.0, 0.0), + float2(-1.0, 0.0) + }; + float2 screenfact=TempParameters.z; + screenfact.y*=ScreenSize.z; + float4 srcbloom=bloom; + + //TempParameters.w == (1+passnumber) +// float step=(TempParameters.w-0.25); + float step=BloomParameters.y;//*pow(2.0, BloomParameters.y * (TempParameters.w-1.0))*2.0;//*0.5 + screenfact.xy*=step;//*0.25==================================================== + float4 rotvec=0.0; + sincos(0.3927, rotvec.x, rotvec.y); + for (int i=0; i<8; i++) + { + bloomuv.xy=offset[i]; + bloomuv.xy=reflect(bloomuv.xy, rotvec.xy); + bloomuv.xy=(bloomuv.xy*screenfact.xy)+In.txcoord0.xy; + float4 tempbloom=tex2D(SamplerBloom1, bloomuv.xy); + bloom+=tempbloom; + } + bloom*=0.111111; + + bloom.w=1.0; + return bloom; +} + + + +//last pass, mix several bloom textures +//SamplerBloom5 is the result of prepass +//float4 PS_BloomPostPass(float2 vPos : VPOS ) : COLOR +float4 PS_BloomPostPass(VS_OUTPUT_POST In) : COLOR +{ + float4 bloom; + + //v1 + bloom =tex2D(SamplerBloom1, In.txcoord0); + bloom+=tex2D(SamplerBloom2, In.txcoord0); + bloom+=tex2D(SamplerBloom3, In.txcoord0); + bloom+=tex2D(SamplerBloom4, In.txcoord0); + bloom+=tex2D(SamplerBloom7, In.txcoord0); + bloom+=tex2D(SamplerBloom8, In.txcoord0); + bloom+=tex2D(SamplerBloom5, In.txcoord0); +// bloom+=tex2D(SamplerBloom6, In.txcoord0); + bloom*=0.142857; + + float3 lenz=0; + float2 lenzuv=0.0; + //deepness, curvature, inverse size + const float3 offset[4]= + { + float3(1.6, 4.0, 1.0), + float3(0.7, 0.25, 2.0), + float3(0.3, 1.5, 0.5), + float3(-0.5, 1.0, 1.0) + }; + //color filter per reflection + const float3 factors[4]= + { + float3(0.3, 0.4, 0.4), + float3(0.2, 0.4, 0.5), + float3(0.5, 0.3, 0.7), + float3(0.1, 0.2, 0.7) + }; + +//lenzuv.xy=0.5-lenzuv.xy; +//distfact=0.5-lenzuv.xy-0.5; + + if (LenzParameters.x>0.00001) + { + for (int i=0; i<4; i++) + { + float2 distfact=(In.txcoord0.xy-0.5); + lenzuv.xy=offset[i].x*distfact; + lenzuv.xy*=pow(2.0*length(float2(distfact.x*ScreenSize.z,distfact.y)), offset[i].y); + lenzuv.xy*=offset[i].z; + lenzuv.xy=0.5-lenzuv.xy;//v1 + // lenzuv.xy=In.txcoord0.xy-lenzuv.xy;//v2 + float3 templenz=tex2D(SamplerBloom2, lenzuv.xy); + templenz=templenz*factors[i]; + distfact=(lenzuv.xy-0.5); + distfact*=2.0; + templenz*=saturate(1.0-dot(distfact,distfact));//limit by uv 0..1 + // templenz=factors[i] * (1.0-dot(distfact,distfact)); + float maxlenz=max(templenz.x, max(templenz.y, templenz.z)); +/* float3 tempnor=(templenz.xyz/maxlenz); + tempnor=pow(tempnor, tempF1.z); + templenz.xyz=tempnor.xyz*maxlenz; +*/ + float tempnor=(maxlenz/(1.0+maxlenz)); + tempnor=pow(tempnor, LenzParameters.y); + templenz.xyz*=tempnor; + + // templenz*=maxlenz*maxlenz; + lenz+=templenz; + // lenz.xyz=max(lenz.xyz, templenz.xyz*0.99); + } + lenz.xyz*=0.25*LenzParameters.x; + + bloom.xyz+=lenz.xyz; +// bloom.w=dot(lenz.xyz, 0.333); + bloom.w=max(lenz.xyz, max(lenz.y, lenz.z)); + } + return bloom; +} + + + +technique BloomPrePass +{ + pass p0 + { + VertexShader = compile vs_3_0 VS_Bloom(); + PixelShader = compile ps_3_0 PS_BloomPrePass(); + + ColorWriteEnable=ALPHA|RED|GREEN|BLUE; + CullMode=NONE; + AlphaBlendEnable=FALSE; + AlphaTestEnable=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } +} + +technique BloomTexture1 +{ + pass p0 + { + VertexShader = compile vs_3_0 VS_Bloom(); + PixelShader = compile ps_3_0 PS_BloomTexture1(); + + ColorWriteEnable=ALPHA|RED|GREEN|BLUE; + CullMode=NONE; + AlphaBlendEnable=FALSE; + AlphaTestEnable=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } +} + + +technique BloomTexture2 +{ + pass p0 + { + VertexShader = compile vs_3_0 VS_Bloom(); + PixelShader = compile ps_3_0 PS_BloomTexture2(); + + ColorWriteEnable=ALPHA|RED|GREEN|BLUE; + CullMode=NONE; + AlphaBlendEnable=FALSE; + AlphaTestEnable=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } +} + +technique BloomPostPass +{ + pass p0 + { + VertexShader = compile vs_3_0 VS_Bloom(); + PixelShader = compile ps_3_0 PS_BloomPostPass(); + + ColorWriteEnable=ALPHA|RED|GREEN|BLUE; + CullMode=NONE; + AlphaBlendEnable=FALSE; + AlphaTestEnable=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } +} + + + diff --git a/enbeffect.fx b/enbeffect.fx new file mode 100644 index 0000000..2c45c3a --- /dev/null +++ b/enbeffect.fx @@ -0,0 +1,616 @@ + #define POSTPROCESS 2 + + + float EBrightnessV2Day < + string UIName="EBrightnessV2Day"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {0.4}; + + float EAdaptationMinV2Day < + string UIName="EAdaptationMinV2Day"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {0.05}; + + float EAdaptationMaxV2Day < + string UIName="EAdaptationMaxV2Day"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {0.15}; + + float EToneMappingCurveV2Day < + string UIName="EToneMappingCurveV2Day"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {1.0}; + + float EIntensityContrastV2Day < + string UIName="EIntensityContrastV2Day"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {1.0}; + + float EToneMappingOversaturationV2Day < + string UIName="EToneMappingOversaturationV2Day"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=200.0; + > = {40.0}; + + float EColorSaturationV2Day < + string UIName="EColorSaturationV2Day"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {1.3}; + + + + + + float EBrightnessV2Night < + string UIName="EBrightnessV2Night"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {1.0}; + + float EAdaptationMinV2Night < + string UIName="EAdaptationMinV2Night"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {0.1}; + + float EAdaptationMaxV2Night < + string UIName="EAdaptationMaxV2Night"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {0.2}; + + float EToneMappingCurveV2Night < + string UIName="EToneMappingCurveV2Night"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {4.3}; + + float EIntensityContrastV2Night < + string UIName="EIntensityContrastV2Night"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {1.0}; + + float EToneMappingOversaturationV2Night < + string UIName="EToneMappingOversaturationV2Night"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=200.0; + > = {20.0}; + + float EColorSaturationV2Night < + string UIName="EColorSaturationV2Night"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {1.0}; + + + + + float EBrightnessV2Interior < + string UIName="EBrightnessV2Interior"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {1.0}; + + float EAdaptationMinV2Interior < + string UIName="EAdaptationMinV2Interior"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {0.1}; + + float EAdaptationMaxV2Interior < + string UIName="EAdaptationMaxV2Interior"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {0.2}; + + float EToneMappingCurveV2Interior < + string UIName="EToneMappingCurveV2Interior"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {4.3}; + + float EIntensityContrastV2Interior < + string UIName="EIntensityContrastV2Interior"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.0; + > = {1.0}; + + float EToneMappingOversaturationV2Interior < + string UIName="EToneMappingOversaturationV2Interior"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=200.0; + > = {20.0}; + + float EColorSaturationV2Interior < + string UIName="EColorSaturationV2Interior"; + string UIWidget="Spinner"; + float UIMin=0.0; + float UIMax=50.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; +//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 = ; + MinFilter = POINT;// + MagFilter = POINT;// + MipFilter = NONE;//LINEAR; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D _s1 = sampler_state +{ + Texture = ; + MinFilter = LINEAR;// + MagFilter = LINEAR;// + MipFilter = NONE;//LINEAR; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D _s2 = sampler_state +{ + Texture = ; + MinFilter = LINEAR;// + MagFilter = LINEAR;// + MipFilter = NONE;//LINEAR; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D _s3 = sampler_state +{ + Texture = ; + MinFilter = LINEAR;// + MagFilter = LINEAR;// + MipFilter = NONE;//LINEAR; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D _s4 = sampler_state +{ + Texture = ; + MinFilter = LINEAR;// + MagFilter = LINEAR;// + MipFilter = NONE;//LINEAR; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D _s7 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +struct VS_OUTPUT_POST +{ + float4 vpos : POSITION; + float2 txcoord0 : TEXCOORD0; +}; +struct VS_INPUT_POST +{ + float3 pos : POSITION; + float2 txcoord0 : TEXCOORD0; +}; + + + +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +VS_OUTPUT_POST VS_Quad(VS_INPUT_POST IN) +{ + VS_OUTPUT_POST OUT; + + OUT.vpos=float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0); + + OUT.txcoord0.xy=IN.txcoord0.xy; + + return OUT; +} + + +//skyrim shader specific externals, do not modify +float4 _c1 : register(c1); +float4 _c2 : register(c2); +float4 _c3 : register(c3); +float4 _c4 : register(c4); +float4 _c5 : register(c5); + +float4 PS_D6EC7DD1(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float4 _oC0=0.0; //output + + float4 _c6=float4(0, 0, 0, 0); + float4 _c7=float4(0.212500006, 0.715399981, 0.0720999986, 1.0); + + float4 r0; + float4 r1; + float4 r2; + float4 r3; + float4 r4; + float4 r5; + float4 r6; + float4 r7; + float4 r8; + float4 r9; + float4 r10; + float4 r11; + + + float4 _v0=0.0; + + _v0.xy=IN.txcoord0.xy; + r1=tex2D(_s0, _v0.xy); //color + + r11=r1; //my bypass + _oC0.xyz=r1.xyz; //for future use without game color corrections + + float hnd = ENightDayFactor; + float pi = (1-EInteriorFactor); + +#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); +// grayadaptation=1.0/grayadaptation; + + + float4 xcolorbloom=tex2D(_s3, _v0.xy); //bloom +// float maxb=max(xcolorbloom.x, max(xcolorbloom.y, xcolorbloom.z)); +// float violetamount=maxb/(maxb+EVioletShiftAmountInv); +// xcolorbloom.xyz=lerp(xcolorbloom.xyz, xcolorbloom.xyz*EVioletShiftColor, violetamount*violetamount); + + + //darkening if too bright screen +// float srcgray=max(color.x, max(color.y, color.z)); +//v1 not good for hdr, scaling required +// color.xyz=color.xyz-(saturate(EAdaptationDarkeningAmount*grayadaptation) * color.xyz)*(1.0-saturate(srcgray*tempF2.y)); +//v2 +// color.xyz=color.xyz-(saturate(EAdaptationDarkeningAmount*grayadaptation) * color.xyz)*(1.0-saturate(srcgray/(srcgray+1.0*tempF2.y))); +//v3 +// color.xyz=color.xyz-(saturate(EAdaptationDarkeningAmount*grayadaptation) * color.xyz)*(1.0/(srcgray*0.7+1.0));//0.7 to modify!!! + + + color.xyz+=xcolorbloom.xyz*EBloomAmount; +// color.xyz=color.xyz-((EAdaptationDarkeningAmount/(grayadaptation*2.0*tempF1.x+1.0)) * color.xyz)*(1.0/(srcgray*0.7+1.0));//0.7 to modify!!! +//v4 +// color.xyz=color.xyz/(grayadaptation*EAdaptationAmount*tempF1.x+1.0); + +//color.xyz=color.xyz+(xcolorbloom.xyz); + +//color.xyz*=EColorFilter; + +//color.xyz*=2.0; + +//-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if (POSTPROCESS==2) + + 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, ( lerp( EToneMappingCurveV2Night, 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); + + + +#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 + + +/* +//temporary testing +color.xyz=tex2D(_s0, _v0.xy); +//color.xyz=xcolorbloom.xyz*tempF1.x; +//color.xyz=pow(color.xyz, 0.5); +color.xyz+=(xcolorbloom.xyz-color.xyz)*tempF1.y; +//color.xyz=xcolorbloom.xyz*tempF1.y; +color.xyz=color.xyz*tempF1.x; +//color.xyz=color.xyz/(color.xyz +1.0*tempF1.z); +color.xyz=(color.xyz * (1.0 + color.xyz/40))/(color.xyz + EToneMappingCurveV3); + Adaptation=tex2D(_s4, 0.5); + grayadaptation=max(max(Adaptation.x, Adaptation.y), Adaptation.z); + grayadaptation=max(grayadaptation, 0.0); + grayadaptation=min(grayadaptation, 50.0); +// color.xyz=Adaptation*2;//*tempF1.x + +//color.xyz=tex2D(_s0, _v0.xy)*1.3; +*/ + +// color.xyz=tex2D(_s0, _v0.xy)*pow(tempF1.x,4); +// color.xyz=max(xcolorbloom.xyz, tex2D(_s0, _v0.xy).xyz)*pow(tempF1.x,4)*0.7; + + _oC0.w=1.0; + _oC0.xyz=color.xyz; + return _oC0; +} + + + +//switch between vanilla and mine post processing +#ifndef ENB_FLIPTECHNIQUE +technique Shader_D6EC7DD1 +#else +technique Shader_ORIGINALPOSTPROCESS +#endif +{ + pass p0 + { + VertexShader = compile vs_3_0 VS_Quad(); + PixelShader = compile ps_3_0 PS_D6EC7DD1(); + + ColorWriteEnable=ALPHA|RED|GREEN|BLUE; + ZEnable=FALSE; + ZWriteEnable=FALSE; + CullMode=NONE; + AlphaTestEnable=FALSE; + AlphaBlendEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } +} + + + +//original shader of post processing +#ifndef ENB_FLIPTECHNIQUE +technique Shader_ORIGINALPOSTPROCESS +#else +technique Shader_D6EC7DD1 +#endif +{ + pass p0 + { + VertexShader = compile vs_3_0 VS_Quad(); + PixelShader= + asm + { +// Parameters: +// sampler2D Avg; +// sampler2D Blend; +// float4 Cinematic; +// float4 ColorRange; +// float4 Fade; +// sampler2D Image; +// float4 Param; +// float4 Tint; +// Registers: +// Name Reg Size +// ------------ ----- ---- +// ColorRange c1 1 +// Param c2 1 +// Cinematic c3 1 +// Tint c4 1 +// Fade c5 1 +// Image s0 1 +// Blend s1 1 +// Avg s2 1 +//s0 bloom result +//s1 color +//s2 is average color + + ps_3_0 + def c6, 0, 0, 0, 0 + //was c0 originally + def c7, 0.212500006, 0.715399981, 0.0720999986, 1 + dcl_texcoord v0.xy + dcl_2d s0 + dcl_2d s1 + dcl_2d s2 + rcp r0.x, c2.y + texld r1, v0, s2 + mul r0.yz, r1.xxyw, c1.y + rcp r0.w, r0.y + mul r0.z, r0.w, r0.z + texld r1, v0, s1 + mul r1.xyz, r1, c1.y + dp3 r0.w, c7, r1 + mul r1.w, r0.w, r0.z + mad r0.z, r0.z, r0.w, c7.w + rcp r0.z, r0.z + mad r0.x, r1.w, r0.x, c7.w + mul r0.x, r0.x, r1.w + mul r0.x, r0.z, r0.x + cmp r0.x, -r0.w, c6.x, r0.x + rcp r0.z, r0.w + mul r0.z, r0.z, r0.x + add_sat r0.x, -r0.x, c2.x + texld r2, v0, s0 + mul r2.xyz, r2, c1.y + mul r2.xyz, r0.x, r2 + mad r1.xyz, r1, r0.z, r2 + dp3 r0.x, r1, c7 + mov r1.w, c7.w + lrp r2, c3.x, r1, r0.x + mad r1, r0.x, c4, -r2 + mad r1, c4.w, r1, r2 + mad r1, c3.w, r1, -r0.y + mad r0, c3.z, r1, r0.y + add r1, -r0, c5 + mad oC0, c5.w, r1, r0 + }; + ColorWriteEnable=ALPHA|RED|GREEN|BLUE; + ZEnable=FALSE; + ZWriteEnable=FALSE; + CullMode=NONE; + AlphaTestEnable=FALSE; + AlphaBlendEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } +} + diff --git a/enbeffectprepass.fx b/enbeffectprepass.fx new file mode 100644 index 0000000..f8c82da --- /dev/null +++ b/enbeffectprepass.fx @@ -0,0 +1,695 @@ +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// ENBSeries effect file +// visit http://enbdev.com for updates +// Copyright (c) 2007-2011 Boris Vorontsov +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +//+++++++++++++++++++++++++++++ +// Internal parameters, can be modified +//+++++++++++++++++++++++++++++ +float EBlurSamplingRange = 4.0; // not used +float EApertureScale = 4.0; // not used + +//+++++++++++++++++++++++++++++ +// 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=Width, y=1/Width, z=ScreenScaleY, w=1/ScreenScaleY +float4 ScreenSize; +// x=generic timer in range 0..1, period of 16777216 ms (4.6 hours), w=frame time elapsed (in seconds) +float4 Timer; +// Adaptation delta time for focusing +float FadeFactor; + +// textures +texture2D texColor; +texture2D texDepth; +texture2D texNoise; +texture2D texPalette; +texture2D texFocus; // computed focusing depth +texture2D texCurr; // 4*4 texture for focusing +texture2D texPrev; // 4*4 texture for focusing + +sampler2D SamplerColor = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Mirror; + AddressV = Mirror; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; + +sampler2D SamplerDepth = sampler_state +{ + Texture = ; + MinFilter = POINT; + MagFilter = POINT; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; + +sampler2D SamplerNoise = sampler_state +{ + Texture = ; + MinFilter = POINT; + MagFilter = POINT; + MipFilter = NONE; + AddressU = Wrap; + AddressV = Wrap; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; + +sampler2D SamplerPalette = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; + +// for focus computation +sampler2D SamplerCurr = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = LINEAR; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; + +// for focus computation +sampler2D SamplerPrev = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; +// for dof only in PostProcess techniques +sampler2D SamplerFocus = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture = FALSE; + MaxMipLevel = 0; + MipMapLodBias = 0; +}; + +struct VS_OUTPUT_POST +{ + float4 vpos : POSITION; + float2 txcoord : TEXCOORD0; +}; + +struct VS_INPUT_POST +{ + float3 pos : POSITION; + float2 txcoord : TEXCOORD0; +}; + +//////////////////////////////////////////////////////////////////// +// Begin focusing (by Boris Vorontsov) +//////////////////////////////////////////////////////////////////// +VS_OUTPUT_POST VS_Focus(VS_INPUT_POST IN) +{ + VS_OUTPUT_POST OUT; + + float4 pos = float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0); + + OUT.vpos = pos; + OUT.txcoord.xy = IN.txcoord.xy; + + return OUT; +} + +//SRCpass1X=ScreenWidth; +//SRCpass1Y=ScreenHeight; +//DESTpass2X=4; +//DESTpass2Y=4; +float4 PS_ReadFocus(VS_OUTPUT_POST IN) : COLOR +{ + float res = tex2D(SamplerDepth, 0.5).x; + //float3 color = tex2D(SamplerColor, 0.5).rgb; + return res; +} + +//SRCpass1X=4; +//SRCpass1Y=4; +//DESTpass2X=4; +//DESTpass2Y=4; +float4 PS_WriteFocus(VS_OUTPUT_POST IN) : COLOR +{ + float res = 0.0; + float curr = tex2D(SamplerCurr, 0.5).x; + float prev = tex2D(SamplerPrev, 0.5).x; + + res = lerp(prev, curr, saturate(FadeFactor));// time elapsed factor + res = max(res, 0.0); + + return res; +} + +technique ReadFocus +{ + pass P0 + { + VertexShader = compile vs_3_0 VS_Focus(); + PixelShader = compile ps_3_0 PS_ReadFocus(); + + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } +} + +technique WriteFocus +{ + pass P0 + { + VertexShader = compile vs_3_0 VS_Focus(); + PixelShader = compile ps_3_0 PS_WriteFocus(); + + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } +} +//////////////////////////////////////////////////////////////////// +// End focusing code +//////////////////////////////////////////////////////////////////// + +/*------------------------------------------------------------------------------ + ENB prepass modification 2.0.6 by Matso + Credits to Boris Vorontsov +------------------------------------------------------------------------------*/ +// Effects enabling options +//#define ENABLE_DOF 1 // comment to disable depth of field +#define ENABLE_FAST_DOF 1 // comment to disable fast depth of field (never use both ENABLE_DOF and ENABLE_FAST_DOF - possible game crash or horrible FPS drop) +//#define ENABLE_SHARP 1 // comment to disable sharpening +//#define ENABLE_CHROMA 1 // comment to disable chromatic aberration (additional chromatic aberration applied beyond depth of field) + +// Methods enabling options +//#define USE_CHROMA_DOF 1 // comment it to disable chromatic aberration sampling in DoF +#define USE_SMOOTH_DOF 1 // comment it to disable smooth DoF +#define USE_BOKEH_DOF 1 // comment it to disable bokeh DoF +//#define USE_ANAMFLARE 1 // comment it to disable anamorphic lens flare (not working very well -_-) +#define USE_DOUBLE_BLUR 1 // comment it to disable additional blur + +// Useful constants +#define SEED Timer.x +#define PI 3.1415926535897932384626433832795 +#define CHROMA_POW 65.0 // the bigger the value, the more visible chomatic aberration effect in DoF + +// Fast DoF constants +#define DOF_SCALE 2356.1944901923449288469825374596 // PI * 750 +#define FIRST_PASS 0 // only 0, 1, 2, or 3 +#define SECOND_PASS 1 // only 0, 1, 2, or 3 +#define THIRD_PASS 2 // only 0, 1, 2, or 3 +#define FOURTH_PASS 3 // only 0, 1, 2, or 3 +#define DOF(sd,sf) fBlurScale * smoothstep(fDofBias, fDofCutoff, abs(sd - sf)) +#define USE_NATURAL_BOKEH 1 + +// Chromatic aberration parameters +float3 fvChroma = float3(0.995, 1.000, 1.005); // displacement scales of red, green and blue respectively +float fBaseRadius = 0.9; // below this radius the effect is less visible +float fFalloffRadius = 1.8; // over this radius the effects is maximal +float fChromaPower = 1.0; // power of the chromatic displacement (curve of the 'fvChroma' vector) + +// Sharpen parameters +float fSharpScale = 0.32; // intensity of sharpening +float2 fvTexelSize = float2(1.0 / 1920.0, 1.0 / 1080.0); // set your resolution sizes + +// Depth of field parameters +float fFocusBias = 0.045; // bigger values for nearsightedness, smaller for farsightedness (lens focal point distance) +float fDofCutoff = 0.25; // manages the smoothness of the DoF (bigger value results in wider depth of field) +float fDofBias = 0.12; // distance not taken into account in DoF (all closer then the distance is in focus) +float fBlurScale = 0.002; // governs image blur scale (the bigger value, the stronger blur) +float fBlurCutoff = 0.1; // bluring tolerance depending on the pixel and sample depth (smaller causes objects edges to be preserved) + +// Bokeh parameters +float fBokehCurve = 2.0; // the larger the value, the more visible the bokeh effect is +float fBokehIntensity = 0.95; // governs bokeh brightness +float fBokehConstant = 0.1; // constant value of the bokeh weighting (bigger cause more powerful bokeh) + +// Grain parameters +float fGrainFreq = 2000.0; // movie grain frequency +float fGrainScale = 0.02; // effect scale + +// Anamorphic flare parameters (by default not used) +float fLuminance = 0.85; // bright pass luminance value +float fBlur = 2000.0; // blur amount, manages the size of the flare +float fIntensity = 0.25; // effect intensity + +// External parameters +extern float fWaterLevel = 1.0; // DO NOT CHANGE - must be 1.0 for now! + +/** + * Chromatic aberration function - given texture coordinate and a focus value + * retrieves chromatically distorted color of the pixel. Each of the color + * channels are displaced according to the pixel coordinate and its distance + * from the center of the image. Also the DoF out-of-focus value is applied. + * (http://en.wikipedia.org/wiki/Chromatic_aberration) + */ +float4 ChromaticAberration(float2 tex, float outOfFocus) +{ + float d = distance(tex, float2(0.5, 0.5)); + float f = smoothstep(fBaseRadius, fFalloffRadius, d + outOfFocus * d); + float3 chroma = pow(f + fvChroma, fChromaPower); + + float2 tr = ((2.0 * tex - 1.0) * chroma.r) * 0.5 + 0.5; + float2 tg = ((2.0 * tex - 1.0) * chroma.g) * 0.5 + 0.5; + float2 tb = ((2.0 * tex - 1.0) * chroma.b) * 0.5 + 0.5; + + float3 color = float3(tex2D(SamplerColor, tr).r, tex2D(SamplerColor, tg).g, tex2D(SamplerColor, tb).b) * (1.0 - f); + + return float4(color, 1.0); +} + +/** + * Chromatic aberration done accoriding to the focus factor provided. + */ +float4 ChromaticAberrationFocus(float2 tex, float outOfFocus) +{ + float d = distance(tex, float2(0.5, 0.5)); + float f = smoothstep(fBaseRadius, fFalloffRadius, d); + float3 chroma = pow(f + fvChroma, CHROMA_POW * outOfFocus * fChromaPower); + + float2 tr = ((2.0 * tex - 1.0) * chroma.r) * 0.5 + 0.5; + float2 tg = ((2.0 * tex - 1.0) * chroma.g) * 0.5 + 0.5; + float2 tb = ((2.0 * tex - 1.0) * chroma.b) * 0.5 + 0.5; + + float3 color = float3(tex2D(SamplerColor, tr).r, tex2D(SamplerColor, tg).g, tex2D(SamplerColor, tb).b) * (1.0 - outOfFocus); + + return float4(color, 1.0); +} + +/** + * Pseudo-random number generator - returns a number generated according to the provided vector. + */ +float Random(float2 co) +{ + return frac(sin(dot(co.xy, float2(12.9898, 78.233))) * 43758.5453); +} + +/** + * Movie grain function - returns a random, time scaled value for the given pixel coordinate. + */ +float Grain(float3 tex) +{ + float r = Random(tex.xy); + float grain = sin(PI * tex.z * r * fGrainFreq) * fGrainScale * r; + return grain; +} + +/** + * Bright pass - rescales sampled pixel to emboss bright enough value. + */ +float3 BrightPass(float2 tex) +{ + float3 c = tex2D(SamplerColor, tex).rgb; + float3 bC = max(c - float3(fLuminance, fLuminance, fLuminance), 0.0); + float bright = dot(bC, 1.0); + bright = smoothstep(0.0f, 0.5, bright); + return lerp(0.0, c, bright); +} + +float3 BrightColor(float3 c) +{ + float3 bC = max(c - float3(fLuminance, fLuminance, fLuminance), 0.0); + float bright = dot(bC, 1.0); + bright = smoothstep(0.0f, 0.5, bright); + return lerp(0.0, c, bright); +} + +/** + * Anamorphic sampling function - scales pixel coordinate + * to stratch the image along one of the axels. + * (http://en.wikipedia.org/wiki/Anamorphosis) + */ +float3 AnamorphicSample(int axis, float2 tex, float blur) +{ + tex = 2.0 * tex - 1.0; + if (!axis) tex.x /= -blur; + else tex.y /= -blur; + tex = 0.5 * tex + 0.5; + return BrightPass(tex); +} + +/** + * Converts pixel color to gray-scale. + */ +float GrayScale(float3 sample) +{ + return dot(sample, float3(0.3, 0.59, 0.11)); +} + +/** + * Returns an under water distortion according to the given coordinate and time factor. + */ +float2 UnderWaterDistortion(float2 coord) +{ + float2 distortion = float2(0.0, 0.0); + // TODO:... + + return coord;// + distortion * (fWaterLevel - 1.0); +} + +///// Shaders //////////////////////////////////////////////////////////////////////////////// +// Vertex shader (Boris code) +VS_OUTPUT_POST VS_PostProcess(VS_INPUT_POST IN) +{ + VS_OUTPUT_POST OUT; + + float4 pos = float4(IN.pos.x, IN.pos.y, IN.pos.z, 1.0); + + OUT.vpos = pos; + OUT.txcoord.xy = IN.txcoord.xy; + + return OUT; +} + +// Sharpen pixel shader (Matso code) +float4 PS_ProcessPass_Sharpen(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float2 coord = IN.txcoord.xy; + float4 Color = 9.0 * tex2D(SamplerColor, coord.xy); + + Color -= tex2D(SamplerColor, coord.xy + float2(-fvTexelSize.x, fvTexelSize.y) * fSharpScale); + Color -= tex2D(SamplerColor, coord.xy + float2(0.0, fvTexelSize.y) * fSharpScale); + Color -= tex2D(SamplerColor, coord.xy + float2(fvTexelSize.x, fvTexelSize.y) * fSharpScale); + Color -= tex2D(SamplerColor, coord.xy + float2(fvTexelSize.x, 0.0) * fSharpScale); + Color -= tex2D(SamplerColor, coord.xy + float2(fvTexelSize.x, -fvTexelSize.y) * fSharpScale); + Color -= tex2D(SamplerColor, coord.xy + float2(0.0, -fvTexelSize.y) * fSharpScale); + Color -= tex2D(SamplerColor, coord.xy + float2(-fvTexelSize.x, -fvTexelSize.y) * fSharpScale); + Color -= tex2D(SamplerColor, coord.xy + float2(-fvTexelSize.x, 0.0) * fSharpScale); + + Color.a = 1.0; + return Color; +} + +// Anamorphic lens flare pixel shader (Matso code) +float4 PS_ProcessPass_Anamorphic(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float4 res; + float2 coord = IN.txcoord.xy; + float3 anamFlare = AnamorphicSample(0, coord.xy, fBlur) * float3(0.0, 0.0, 1.0); + res.rgb = anamFlare * fIntensity; + res.a = 1.0; + return res; +} + +// Fast depth of field pixel shader (Matso code) +float4 PS_ProcessPass_FastDoF(VS_OUTPUT_POST IN, float2 vPos : VPOS, uniform int axis) : COLOR +{ + float4 res; + float2 base = UnderWaterDistortion(IN.txcoord.xy); + float4 tcol = tex2D(SamplerColor, base.xy); + float sd = tex2D(SamplerDepth, base).x; + +#ifndef USE_SMOOTH_DOF + float sf = tex2D(SamplerDepth, 0.5).x - fFocusBias * fWaterLevel; +#else + float sf = tex2D(SamplerFocus, 0.5).x - fFocusBias * 2.0 * fWaterLevel; +#endif + float outOfFocus = DOF(sd, sf); + + float offset[4] = { -1.282, -0.524, 0.524, 1.282 }; +#ifndef USE_NATURAL_BOKEH + float2 tds[4] = { float2(1.0, 0.0), float2(0.0, 1.0), float2(0.707, 0.707), float2(-0.707, 0.707) }; +#else + float2 tds[16] = { + float2(0.2007, 0.9796), + float2(-0.2007, 0.9796), + float2(0.2007, 0.9796), + float2(-0.2007, 0.9796), + + float2(0.8240, 0.5665), + float2(0.5665, 0.8240), + float2(0.8240, 0.5665), + float2(0.5665, 0.8240), + + float2(0.9796, 0.2007), + float2(0.9796, -0.2007), + float2(0.9796, 0.2007), + float2(0.9796, -0.2007), + + float2(-0.8240, 0.5665), + float2(-0.5665, 0.8240), + float2(-0.8240, 0.5665), + float2(-0.5665, 0.8240) + }; +#endif + + float blur = DOF_SCALE * outOfFocus; + float wValue = 1.0; + +#ifndef USE_NATURAL_BOKEH + tdirs[axis].x *= fvTexelSize.x; + tdirs[axis].y *= fvTexelSize.y; +#endif + +#ifdef USE_BOKEH_DOF + blur *= 0.35; +#endif + + for (int i = 0; i < 4; i++) + { +#ifndef USE_NATURAL_BOKEH + float2 tdir = offset[i] * tds[axis] * blur; +#else + float2 tdir = tds[axis * 4 + i] * fvTexelSize * offset[i] * blur; +#endif + + float2 coord = base + tdir.xy; +#ifdef USE_CHROMA_DOF + float4 ct = ChromaticAberrationFocus(coord.xy, outOfFocus); +#else + float4 ct = tex2D(SamplerColor, coord.xy); +#endif + float sds = tex2D(SamplerDepth, coord).x; + +#ifndef USE_BOKEH_DOF + float w = 1.0 + abs(offset[i]); // weight blur for better effect +#else + #if USE_BOKEH_DOF == 1 // my own bokeh weighting + float b = GrayScale(ct.rgb) + length(ct.rgb) + fBokehConstant + blur; + float w = pow(b * fBokehIntensity, fBokehCurve) + abs(offset[i]) + blur; + #endif +#endif + w *= (1.0 - smoothstep(0.0, fBlurCutoff, abs(sds - sd))); + tcol += ct * w; + wValue += w; + } + + tcol /= wValue; + + res.xyz = tcol.xyz; + res.w = 1.0; + return res; +} + +// Chromatic abrration with no DoF (Matso code) +float4 PS_ProcessPass_Chroma(VS_OUTPUT_POST IN, float2 vPos : VPOS) : COLOR +{ + float2 coord = IN.txcoord.xy; + float4 result = ChromaticAberration(coord.xy, 0.0); + result.a = 1.0; + return result; +} + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#ifdef ENABLE_SHARP + technique PostProcess + { + pass P0 + { + VertexShader = compile vs_3_0 VS_PostProcess(); + PixelShader = compile ps_3_0 PS_ProcessPass_Sharpen(); + + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } + #ifdef USE_ANAMFLARE + pass P1 + { + AlphaBlendEnable = true; + SrcBlend = One; + DestBlend = One; + + PixelShader = compile ps_3_0 PS_ProcessPass_Anamorphic(); + } + #endif + } +#endif + +#ifndef ENABLE_FAST_DOF + #ifdef ENABLE_CHROMA + #ifndef ENABLE_SHARP + technique PostProcess + #else + technique PostProcess2 + #endif + { + pass P0 + { + VertexShader = compile vs_3_0 VS_PostProcess(); + PixelShader = compile ps_3_0 PS_ProcessPass_Chroma(); + + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } + } + #endif +#endif + +#ifndef ENABLE_CHROMA + #ifdef ENABLE_FAST_DOF + #ifndef ENABLE_SHARP + technique PostProcess + #else + technique PostProcess2 + #endif + { + pass P0 + { + VertexShader = compile vs_3_0 VS_PostProcess(); + PixelShader = compile ps_3_0 PS_ProcessPass_FastDoF(FIRST_PASS); + + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } + } + + #ifndef ENABLE_SHARP + technique PostProcess2 + #else + technique PostProcess3 + #endif + { + pass P0 + { + VertexShader = compile vs_3_0 VS_PostProcess(); + PixelShader = compile ps_3_0 PS_ProcessPass_FastDoF(SECOND_PASS); + + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } + } + + #ifdef USE_DOUBLE_BLUR + #ifndef ENABLE_SHARP + technique PostProcess3 + #else + technique PostProcess4 + #endif + { + pass P0 + { + VertexShader = compile vs_3_0 VS_PostProcess(); + PixelShader = compile ps_3_0 PS_ProcessPass_FastDoF(THIRD_PASS); + + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } + } + + #ifndef ENABLE_SHARP + technique PostProcess4 + #else + technique PostProcess5 + #endif + { + pass P0 + { + VertexShader = compile vs_3_0 VS_PostProcess(); + PixelShader = compile ps_3_0 PS_ProcessPass_FastDoF(FOURTH_PASS); + + DitherEnable = FALSE; + ZEnable = FALSE; + CullMode = NONE; + ALPHATESTENABLE = FALSE; + SEPARATEALPHABLENDENABLE = FALSE; + AlphaBlendEnable = FALSE; + StencilEnable = FALSE; + FogEnable = FALSE; + SRGBWRITEENABLE = FALSE; + } + } + #endif + #endif +#endif diff --git a/enblens.fx b/enblens.fx new file mode 100644 index 0000000..47b5165 --- /dev/null +++ b/enblens.fx @@ -0,0 +1,351 @@ +//++++++++++++++++++++++++++++++++++++++++++++ +// ENBSeries effect file +// visit http://enbdev.com for updates +// Copyright (c) 2007-2013 Boris Vorontsov +//++++++++++++++++++++++++++++++++++++++++++++ + + + +//+++++++++++++++++++++++++++++ +//internal parameters, can be modified +//+++++++++++++++++++++++++++++ +//none + + + +//+++++++++++++++++++++++++++++ +//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=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; +//x=generic timer in range 0..1, period of 16777216 ms (4.6 hours), w=frame time elapsed (in seconds) +float4 Timer; +//additional info for computations +float4 TempParameters; +//x=reflection intensity, y=reflection power, z=dirt intensity, w=dirt power +float4 LensParameters; +//fov in degrees +float FieldOfView; + + + +texture2D texColor; +texture2D texMask;//enblensmask texture +texture2D texBloom1; +texture2D texBloom2; +texture2D texBloom3; +texture2D texBloom4; +texture2D texBloom5; +texture2D texBloom6; +texture2D texBloom7; +texture2D texBloom8; + +sampler2D SamplerColor = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerMask = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom1 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom2 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom3 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom4 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom5 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom6 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom7 = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerBloom8 = sampler_state +{ + Texture = ; + 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_Draw(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+TempParameters.xy;//1.0/(bloomtexsize*2.0) + + return OUT; +} + + + +float4 PS_Draw(VS_OUTPUT_POST In) : COLOR +{ + float4 res=0.0; + + float2 coord; + //deepness, curvature, inverse size + const float3 offset[4]= + { + float3(1.6, 4.0, 1.0), + float3(0.7, 0.25, 2.0), + float3(0.3, 1.5, 0.5), + float3(-0.5, 1.0, 1.0) + }; + //color filter per reflection + const float3 factors[4]= + { + float3(0.3, 0.4, 0.4), + float3(0.2, 0.4, 0.5), + float3(0.5, 0.3, 0.7), + float3(0.1, 0.2, 0.7) + }; + + for (int i=0; i<4; i++) + { + float2 distfact=(In.txcoord0.xy-0.5); + coord.xy=offset[i].x*distfact; + coord.xy*=pow(2.0*length(float2(distfact.x*ScreenSize.z,distfact.y)), offset[i].y); + coord.xy*=offset[i].z; + coord.xy=0.5-coord.xy;//v1 +// coord.xy=In.txcoord0.xy-coord.xy;//v2 + float3 templens=tex2D(SamplerBloom2, coord.xy); + templens=templens*factors[i]; + distfact=(coord.xy-0.5); + distfact*=2.0; + templens*=saturate(1.0-dot(distfact,distfact));//limit by uv 0..1 +// templens=factors[i] * (1.0-dot(distfact,distfact)); + float maxlens=max(templens.x, max(templens.y, templens.z)); +// float3 tempnor=(templens.xyz/maxlens); +// tempnor=pow(tempnor, tempF1.z); +// templens.xyz=tempnor.xyz*maxlens; + float tempnor=(maxlens/(1.0+maxlens)); + tempnor=pow(tempnor, LensParameters.y); + templens.xyz*=tempnor; + + res.xyz+=templens; + } + res.xyz*=0.25*LensParameters.x; + + + //add mask + { + coord=In.txcoord0.xy; + //coord.y*=ScreenSize.w;//remove stretching of image + float4 mask=tex2D(SamplerMask, coord); + float3 templens=tex2D(SamplerBloom6, In.txcoord0.xy); + float maxlens=max(templens.x, max(templens.y, templens.z)); + float tempnor=(maxlens/(1.0+maxlens)); + tempnor=pow(tempnor, LensParameters.w); + templens.xyz*=tempnor * LensParameters.z; + res.xyz+=mask.xyz * templens.xyz; + } + + return res; +} + + +//blurring may required when quality of blurring is too bad for bilinear filtering on screen +float4 PS_LensPostPass(VS_OUTPUT_POST In) : COLOR +{ + float4 res=0.0; +/* + //blur + const float2 offset[4]= + { + float2( 1.25, 1.25), + float2( 1.25,-1.25), + float2(-1.25, 1.25), + float2(-1.25,-1.25) + }; + //float2 screenfact=TempParameters.y; + //screenfact.y*=ScreenSize.z; + float2 screenfact=ScreenSize.y; + screenfact.y*=ScreenSize.z; + for (int i=0; i<4; i++) + { + float2 coord=offset[i].xy*screenfact.xy+In.txcoord0.xy; + res.xyz+=tex2D(SamplerColor, coord); + } + res.xyz*=0.25; + res.xyz=min(res.xyz, 32768.0); + res.xyz=max(res.xyz, 0.0); +*/ + //no blur + res=tex2D(SamplerColor, In.txcoord0.xy); + res.xyz=min(res.xyz, 32768.0); + res.xyz=max(res.xyz, 0.0); + + return res; +} + + + +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +//actual computation, draw all effects to small texture +technique Draw +{ + pass p0 + { + VertexShader = compile vs_3_0 VS_Draw(); + PixelShader = compile ps_3_0 PS_Draw(); + + ColorWriteEnable=ALPHA|RED|GREEN|BLUE; + CullMode=NONE; + AlphaBlendEnable=FALSE; + AlphaTestEnable=FALSE; + SeparateAlphaBlendEnable=FALSE; + SRGBWriteEnable=FALSE; + } +} + + + +//final pass, output to screen with additive blending and no alpha +technique LensPostPass +{ + pass p0 + { + VertexShader = compile vs_3_0 VS_Draw(); + PixelShader = compile ps_3_0 PS_LensPostPass(); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + ColorWriteEnable=RED|GREEN|BLUE;//warning, no alpha output! + CullMode=NONE; + AlphaTestEnable=FALSE; + SeparateAlphaBlendEnable=FALSE; + SRGBWriteEnable=FALSE; + } +} diff --git a/enblensmask.png b/enblensmask.png new file mode 100644 index 0000000..8445ad0 Binary files /dev/null and b/enblensmask.png differ diff --git a/enblocal.ini b/enblocal.ini new file mode 100644 index 0000000..a5c3bf1 --- /dev/null +++ b/enblocal.ini @@ -0,0 +1,88 @@ +; enblocal.ini : ENB configuration file. +; (C)2013 Marisa Kirisame, UnSX Team. +; Part of MariENB, the personal ENB of Marisa. +; Released under the MIT License. + +[PROXY] +EnableProxyLibrary=false +InitProxyFunctions=false +ProxyLibrary= + +[GLOBAL] +UsePatchSpeedhackWithoutGraphics=false +UseDefferedRendering=true +ForceFakeVideocard=false +IgnoreCreationKit=true + +[PERFORMANCE] +SpeedHack=true +EnableOcclusionCulling=true + +[MULTIHEAD] +ForceVideoAdapterIndex=false +VideoAdapterIndex=0 + +[MEMORY] +ExpandSystemMemoryX64=true +ReduceSystemMemoryUsage=true +DisableDriverMemoryManager=false +ReservedMemorySizeMb=1024 +EnableUnsafeMemoryHacks=false +DisablePreloadToVRAM=true +VideoMemorySizeMb=1024 +EnableCompression=true +AutodetectVideoMemorySize=true + +[WINDOW] +ForceBorderless=true +ForceBorderlessFullscreen=true + +[ENGINE] +ForceAnisotropicFiltering=true +MaxAnisotropy=16 +EnableVSync=false +AddDisplaySuperSamplingResolutions=false +VSyncSkipNumFrames=0 +ForceLodBias=true +LodBias=-0.5 + +[LIMITER] +WaitBusyRenderer=true +EnableFPSLimit=true +FPSLimit=60.0 + +[INPUT] +KeyReadConfig=8 +KeyCombination=16 +KeyUseEffect=123 +KeyFPSLimit=0 +KeyShowFPS=106 +KeyScreenshot=44 +KeyEditor=13 +KeyFreeVRAM=115 + +[ADAPTIVEQUALITY] +Enable=false +Quality=2 +DesiredFPS=60.0 + +[FIX] +FixPhysics=true +FixGameBugs=true +FixParallaxBugs=true +FixAliasedTextures=true +IgnoreLoadingScreen=false +IgnoreInventory=true +FixSsaoWaterTransparency=true +FixSsaoHairTransparency=true +FixTintGamma=true +RemoveBlur=false +FixSubSurfaceScattering=true +FixSkyReflection=true +FixCursorVisibility=true + +[ANTIALIASING] +EnableEdgeAA=false +EnableSubPixelAA=false +EnableTemporalAA=true +EnableTransparencyAA=false diff --git a/enbpalette.bmp b/enbpalette.bmp new file mode 100644 index 0000000..e29cdd6 Binary files /dev/null and b/enbpalette.bmp differ diff --git a/enbraindrops.tga b/enbraindrops.tga new file mode 100644 index 0000000..38062ef Binary files /dev/null and b/enbraindrops.tga differ diff --git a/enbseries.ini b/enbseries.ini index 72272c4..f60475a 100644 --- a/enbseries.ini +++ b/enbseries.ini @@ -1,148 +1,847 @@ -[PROXY] -EnableProxyLibrary=0 -InitProxyFunctions=0 -ProxyLibrary= +; enbseries.ini : ENB configuration file. +; (C)2013 Marisa Kirisame, UnSX Team. +; Part of MariENB, the personal ENB of Marisa. +; Released under the MIT License. [GLOBAL] -UseEffect=1 -AlternativeDepth=1 -AllowAntialias=1 -BugFixMode=0 -SkipShaderOptimization=0 -QuadVertexBuffer=1 -EnableShaders_3_0=1 -AdditionalConfigFile=enbseries2.ini -UseMRTRendering=0 -TempF1=100 -TempF2=100 -TempF3=100 -TempF4=100 -TempF5=100 -TempF6=100 -TempF7=100 -TempF8=100 -TempF9=100 -TempF0=100 +AdditionalConfigFile= +UseEffect=false [EFFECT] -EnableBloom=0 -EnableOcclusion=0 -EnableReflection=0 -EnableMotionBlur=0 -EnableWater=0 -EnableShadow=0 -DepthBias=0 -EnableDepthOfField=0 -EnableReflectiveBump=0 - -[INPUT] -KeyUseEffect=123 -KeyBloom=120 -KeyOcclusion=121 -KeyReflection=122 -KeyCombination=16 -KeyScreenshot=44 -KeyShadow=119 -KeyWater=118 -KeyShowFPS=106 - -[REFLECTION] -ReflectionPower=0 -ChromePower=0 -UseCurrentFrameReflection=0 -ReflectionQuality=0 -ReflectionSourceSpecular=0 -ReflectionSourceTFactor=0 -UseAdditiveReflection=0 -ReflectionDepthBias=0 -UseLowResReflection=0 -ReflectionSinglePass=0 -UseEnvBump=0 -EnvBumpAmount=0 -EnvBumpOffset=0 -ReflectionFlip=0 -IBLAmount=0 -IBLPower=0 +UseOriginalPostProcessing=false +UseOriginalObjectsProcessing=false +EnableBloom=true +EnableAdaptation=false +EnableAmbientOcclusion=true +EnableDepthOfField=false +EnableDetailedShadow=true +EnableSunRays=true +EnableSkyLighting=true +EnableImageBasedLighting=false +EnableReflection=true +EnableSoftParticles=true +EnableParticleLights=true +EnableSunGlare=false +EnableSubSurfaceScattering=true +EnableLens=false +EnableWater=true +EnableUnderwater=true +EnableCloudShadows=true +EnableVolumetricRays=true +EnableProceduralSun=true +EnableMist=true [BLOOM] -BloomPowerDay=0 -BloomFadeTime=0 -BloomConstantDay=0 -BloomQuality=0 -BloomScreenLevelDay=0 -BloomCurveDay=0 -BloomPowerNight=0 -BloomConstantNight=0 -BloomCurveNight=0 -BloomScreenLevelNight=0 -BloomAdaptationScreenLevel=0 -BloomAdaptationMultiplier=0 -BloomAllowOversaturation=0 -BloomMaxLimit=0 +Quality=1 +AmountDay=0.06 +AmountNight=0.09 +AmountInterior=1.35 +BlueShiftAmountDay=21.369999 +BlueShiftAmountNight=13.0 +BlueShiftAmountInterior=12.0 +ContrastDay=1.0 +ContrastNight=3.0 +ContrastInterior=2.0 +AmountSunrise=0.19 +AmountSunset=0.15 +AmountInteriorDay=0.1 +AmountInteriorNight=0.11 +BlueShiftAmountSunrise=15.77 +BlueShiftAmountSunset=17.539999 +BlueShiftAmountInteriorDay=19.209999 +BlueShiftAmountInteriorNight=14.86 +IgnoreWeatherSystem=true -[SSAO] -UseFilter=0 -OcclusionQuality=0 -FilterQuality=0 -DarkeningLevel=0 -BrighteningLevel=0 -IlluminationLevel=0 -AdditiveIlluminationLevel=0 -UseAmbientOcclusion=0 -UseIndirectLighting=0 -FadeDistance=0 -UseForAlphaTest=0 -UseForAlphaBlend=0 +[CAMERAFX] +LenzReflectionIntensityDay=1.29 +LenzReflectionIntensityNight=1.14 +LenzReflectionIntensityInterior=0.0 +LenzReflectionPowerDay=0.91 +LenzReflectionPowerNight=0.74 +LenzReflectionPowerInterior=0.0 +LenzReflectionIntensitySunrise=1.45 +LenzReflectionIntensitySunset=1.53 +LenzReflectionIntensityInteriorDay=0.950001 +LenzReflectionIntensityInteriorNight=1.21 +LenzReflectionPowerSunrise=0.64 +LenzReflectionPowerSunset=0.64 +LenzReflectionPowerInteriorDay=0.76 +LenzReflectionPowerInteriorNight=0.71 + +[SSAO_SSIL] +UseIndirectLighting=false +UseComplexIndirectLighting=false +SamplingQuality=1 +SamplingRange=1.0 +FadeFogRangeDay=0.0 +FadeFogRangeNight=3.0 +FadeFogRangeInterior=0.0 +SizeScale=0.5 +SourceTexturesScale=0.5 +FilterQuality=1 +AOAmount=2.24 +ILAmount=0.0 +UseComplexAmbientOcclusion=true +UseAmbientIndirectLighting=false +SamplingPrecision=1 +FadeFogRange=4.18 +FilterType=0 +AOAmountInterior=2.04 +ILAmountInterior=0.0 +AOIntensity=1.13 +AOIntensityInterior=1.01 +AOType=0 +AOMixingType=0 +AOMixingTypeInterior=0 +UseOldType=false +EnableDenoiser=false +EnableSupersampling=false +EnableComplexFilter=false +ILType=0 + +[NIGHTDAY] +DetectorDefaultDay=false +DetectorLevelDay=0.75 +DetectorLevelNight=0.25 +DetectorLevelCurve=1.0 +DetectorOldVersion=false + +[ADAPTATION] +ForceMinMaxValues=false +AdaptationSensitivity=0.35 +AdaptationTime=3.22 +AdaptationMin=0.85001 +AdaptationMax=1.23 + +[ENVIRONMENT] +DirectLightingIntensityDay=1.29 +DirectLightingIntensityNight=1.28 +DirectLightingIntensityInterior=1.014688 +DirectLightingCurveDay=1.24 +DirectLightingCurveNight=1.28 +DirectLightingCurveInterior=1.25 +DirectLightingDesaturationDay=0.0 +DirectLightingDesaturationNight=0.0 +DirectLightingDesaturationInterior=0.0 +SpecularAmountMultiplierDay=0.81 +SpecularAmountMultiplierNight=1.07 +SpecularAmountMultiplierInterior=1.0 +SpecularPowerMultiplierDay=0.641 +SpecularPowerMultiplierNight=0.401 +SpecularPowerMultiplierInterior=1.0 +SpecularFromLightDay=0.0 +SpecularFromLightNight=0.0 +SpecularFromLightInterior=0.0 +AmbientLightingIntensityDay=0.66 +AmbientLightingIntensityNight=0.16 +AmbientLightingIntensityInterior=0.914 +AmbientLightingCurveDay=1.29 +AmbientLightingCurveNight=1.29 +AmbientLightingCurveInterior=0.75 +AmbientLightingDesaturationDay=0.0 +AmbientLightingDesaturationNight=0.0 +AmbientLightingDesaturationInterior=0.0 +PointLightingIntensityDay=1.04 +PointLightingIntensityNight=1.26 +PointLightingIntensityInterior=0.825 +PointLightingCurveDay=1.01875 +PointLightingCurveNight=1.21 +PointLightingCurveInterior=0.825 +PointLightingDesaturationDay=0.07 +PointLightingDesaturationNight=0.06 +PointLightingDesaturationInterior=0.0 +FogColorMultiplierDay=0.6 +FogColorMultiplierNight=0.51 +FogColorMultiplierInterior=0.5 +FogColorCurveDay=0.83 +FogColorCurveNight=1.44 +FogColorCurveInterior=1.0 +ColorPowDay=1.0 +ColorPowNight=1.0 +ColorPowInterior=0.9 +DirectLightingIntensitySunrise=1.3 +DirectLightingIntensitySunset=1.41 +DirectLightingIntensityInteriorDay=1.27 +DirectLightingIntensityInteriorNight=1.28 +DirectLightingCurveSunrise=1.37 +DirectLightingCurveSunset=1.48 +DirectLightingCurveInteriorDay=1.05 +DirectLightingCurveInteriorNight=1.23 +DirectLightingDesaturationSunrise=0.0 +DirectLightingDesaturationSunset=0.0 +DirectLightingDesaturationInteriorDay=0.0 +DirectLightingDesaturationInteriorNight=0.0 +SpecularAmountMultiplierSunrise=1.17 +SpecularAmountMultiplierSunset=1.2 +SpecularAmountMultiplierInteriorDay=0.92 +SpecularAmountMultiplierInteriorNight=1.1 +SpecularPowerMultiplierSunrise=0.231 +SpecularPowerMultiplierSunset=0.211 +SpecularPowerMultiplierInteriorDay=0.491 +SpecularPowerMultiplierInteriorNight=0.441 +SpecularFromLightSunrise=0.0 +SpecularFromLightSunset=0.0 +SpecularFromLightInteriorDay=0.0 +SpecularFromLightInteriorNight=0.0 +AmbientLightingIntensitySunrise=0.4 +AmbientLightingIntensitySunset=0.34 +AmbientLightingIntensityInteriorDay=0.33 +AmbientLightingIntensityInteriorNight=0.25 +AmbientLightingCurveSunrise=1.32 +AmbientLightingCurveSunset=1.44 +AmbientLightingCurveInteriorDay=1.07 +AmbientLightingCurveInteriorNight=1.14 +AmbientLightingDesaturationSunrise=0.0 +AmbientLightingDesaturationSunset=0.0 +AmbientLightingDesaturationInteriorDay=0.0 +AmbientLightingDesaturationInteriorNight=0.0 +AmbientColorFilterAmountSunrise=0.12 +AmbientColorFilterAmountDay=0.11 +AmbientColorFilterAmountSunset=0.14 +AmbientColorFilterAmountNight=0.17 +AmbientColorFilterAmountInteriorDay=0.11 +AmbientColorFilterAmountInteriorNight=0.15 +AmbientColorFilterTopSunrise=0.902, 0.784, 0.212 +AmbientColorFilterTopDay=0.882, 0.863, 0.71 +AmbientColorFilterTopSunset=0.945, 0.369, 0.0353 +AmbientColorFilterTopNight=0.00784, 0.435, 0.737 +AmbientColorFilterTopInteriorDay=0.373, 0.396, 0.451 +AmbientColorFilterTopInteriorNight=0.369, 0.435, 0.565 +AmbientColorFilterMiddleSunrise=0.396, 0.231, 0.0902 +AmbientColorFilterMiddleDay=0.188, 0.173, 0.149 +AmbientColorFilterMiddleSunset=0.227, 0.0627, 0.0157 +AmbientColorFilterMiddleNight=0.141, 0.192, 0.259 +AmbientColorFilterMiddleInteriorDay=0.227, 0.333, 0.392 +AmbientColorFilterMiddleInteriorNight=0.18, 0.247, 0.376 +AmbientColorFilterBottomSunrise=0.776, 0.545, 0.282 +AmbientColorFilterBottomDay=0.518, 0.455, 0.353 +AmbientColorFilterBottomSunset=0.851, 0.384, 0.184 +AmbientColorFilterBottomNight=0.11, 0.165, 0.408 +AmbientColorFilterBottomInteriorDay=0.169, 0.29, 0.294 +AmbientColorFilterBottomInteriorNight=0.0824, 0.133, 0.278 +PointLightingIntensitySunrise=1.11 +PointLightingIntensitySunset=1.11 +PointLightingIntensityInteriorDay=1.17 +PointLightingIntensityInteriorNight=1.15 +PointLightingCurveSunrise=1.3 +PointLightingCurveSunset=1.33 +PointLightingCurveInteriorDay=1.06 +PointLightingCurveInteriorNight=1.16 +PointLightingDesaturationSunrise=0.08 +PointLightingDesaturationSunset=0.06 +PointLightingDesaturationInteriorDay=0.03 +PointLightingDesaturationInteriorNight=0.04 +ParticleLightsIntensitySunrise=0.92 +ParticleLightsIntensityDay=0.86 +ParticleLightsIntensitySunset=0.93 +ParticleLightsIntensityNight=0.96 +ParticleLightsIntensityInteriorDay=0.62 +ParticleLightsIntensityInteriorNight=0.81 +FogColorMultiplierSunrise=0.4 +FogColorMultiplierSunset=0.35 +FogColorMultiplierInteriorDay=0.39 +FogColorMultiplierInteriorNight=0.13 +FogColorCurveSunrise=1.47 +FogColorCurveSunset=1.88 +FogColorCurveInteriorDay=0.72 +FogColorCurveInteriorNight=1.49 +ColorPowSunrise=1.0 +ColorPowSunset=1.0 +ColorPowInteriorDay=1.0 +ColorPowInteriorNight=1.0 +IgnoreWeatherSystem=true + +[SKY] +Enable=true +StarsIntensity=1.88 +StarsCurve=1.23 +AuroraBorealisIntensity=1.2 +AuroraBorealisCurve=0.46 +CloudsIntensityDay=1.020001 +CloudsIntensityNight=0.510001 +CloudsIntensityInterior=1.49 +CloudsCurveDay=1.18 +CloudsCurveNight=1.03 +CloudsCurveInterior=1.5 +CloudsDesaturationDay=0.15 +CloudsDesaturationNight=0.06 +CloudsDesaturationInterior=0.14 +CloudsEdgeClamp=0.84 +CloudsEdgeIntensity=2.53 +GradientIntensityDay=1.310001 +GradientIntensityNight=0.740001 +GradientIntensityInterior=0.85 +GradientDesaturationDay=0.29 +GradientDesaturationNight=0.04 +GradientDesaturationInterior=0.325 +GradientTopIntensityDay=2.570001 +GradientTopIntensityNight=1.550001 +GradientTopIntensityInterior=5.6125 +GradientTopCurveDay=2.21 +GradientTopCurveNight=1.57 +GradientTopCurveInterior=2.15 +GradientMiddleIntensityDay=2.360001 +GradientMiddleIntensityNight=1.020001 +GradientMiddleIntensityInterior=2.4 +GradientMiddleCurveDay=2.06 +GradientMiddleCurveNight=1.41 +GradientMiddleCurveInterior=1.65 +GradientHorizonIntensityDay=3.76 +GradientHorizonIntensityNight=1.840001 +GradientHorizonIntensityInterior=2.33 +GradientHorizonCurveDay=1.52 +GradientHorizonCurveNight=1.36 +GradientHorizonCurveInterior=1.25 +SunIntensity=3.0 +SunDesaturation=0.0 +SunCoronaIntensity=0.911 +SunCoronaCurve=3.19 +SunCoronaDesaturation=0.09 +MoonIntensity=1.6 +MoonCurve=1.0 +MoonDesaturation=0.2 +DisableWrongSkyMath=true +CloudsIntensitySunrise=0.550001 +CloudsIntensitySunset=0.63 +CloudsIntensityInteriorDay=0.98 +CloudsIntensityInteriorNight=0.44 +CloudsCurveSunrise=1.67 +CloudsCurveSunset=1.46 +CloudsCurveInteriorDay=1.12 +CloudsCurveInteriorNight=1.05 +CloudsDesaturationSunrise=0.04 +CloudsDesaturationSunset=0.02 +CloudsDesaturationInteriorDay=0.13 +CloudsDesaturationInteriorNight=0.04 +GradientIntensitySunrise=0.920001 +GradientIntensitySunset=0.930001 +GradientIntensityInteriorDay=1.41 +GradientIntensityInteriorNight=0.870001 +GradientDesaturationSunrise=0.53 +GradientDesaturationSunset=0.1 +GradientDesaturationInteriorDay=0.29 +GradientDesaturationInteriorNight=0.04 +GradientTopIntensitySunrise=1.620001 +GradientTopIntensitySunset=1.69 +GradientTopIntensityInteriorDay=2.7 +GradientTopIntensityInteriorNight=1.48 +GradientTopCurveSunrise=1.97 +GradientTopCurveSunset=2.04 +GradientTopCurveInteriorDay=2.47 +GradientTopCurveInteriorNight=1.59 +GradientMiddleIntensitySunrise=0.770001 +GradientMiddleIntensitySunset=1.13 +GradientMiddleIntensityInteriorDay=2.6 +GradientMiddleIntensityInteriorNight=1.09 +GradientMiddleCurveSunrise=2.3 +GradientMiddleCurveSunset=2.6 +GradientMiddleCurveInteriorDay=2.2 +GradientMiddleCurveInteriorNight=1.4 +GradientHorizonIntensitySunrise=2.05 +GradientHorizonIntensitySunset=2.21 +GradientHorizonIntensityInteriorDay=3.78 +GradientHorizonIntensityInteriorNight=1.82 +GradientHorizonCurveSunrise=1.13 +GradientHorizonCurveSunset=1.13 +GradientHorizonCurveInteriorDay=1.44 +GradientHorizonCurveInteriorNight=1.34 +SunIntensitySunrise=1.28 +SunIntensityDay=1.1 +SunIntensitySunset=1.07 +SunIntensityNight=1.04 +SunIntensityInteriorDay=1.09 +SunIntensityInteriorNight=1.03 +SunDesaturationSunrise=0.0 +SunDesaturationDay=0.0 +SunDesaturationSunset=0.0 +SunDesaturationNight=0.0 +SunDesaturationInteriorDay=0.0 +SunDesaturationInteriorNight=0.0 +SunColorFilterSunrise=1, 0.788, 0.161 +SunColorFilterDay=1, 1, 1 +SunColorFilterSunset=0.82, 0.239, 0.137 +SunColorFilterNight=0, 0, 0 +SunColorFilterInteriorDay=1, 1, 1 +SunColorFilterInteriorNight=0, 0, 0 +SunGlowIntensitySunrise=3.64 +SunGlowIntensityDay=3.15 +SunGlowIntensitySunset=4.37 +SunGlowIntensityNight=2.92 +SunGlowIntensityInteriorDay=3.45 +SunGlowIntensityInteriorNight=3.24 +SunGlowHazinessSunrise=0.08 +SunGlowHazinessDay=0.37 +SunGlowHazinessSunset=0.07 +SunGlowHazinessNight=0.17 +SunGlowHazinessInteriorDay=0.28 +SunGlowHazinessInteriorNight=0.11 +MoonIntensitySunrise=0.85 +MoonIntensityDay=0.72 +MoonIntensitySunset=1.24 +MoonIntensityNight=1.52 +MoonIntensityInteriorDay=0.58 +MoonIntensityInteriorNight=1.3 +MoonCurveSunrise=0.97 +MoonCurveDay=0.88 +MoonCurveSunset=0.93 +MoonCurveNight=1.07 +MoonCurveInteriorDay=0.86 +MoonCurveInteriorNight=1.04 +MoonDesaturationSunrise=0.17 +MoonDesaturationDay=0.23 +MoonDesaturationSunset=0.14 +MoonDesaturationNight=0.12 +MoonDesaturationInteriorDay=0.22 +MoonDesaturationInteriorNight=0.13 +CloudsOpacitySunrise=1.48 +CloudsOpacityDay=1.52 +CloudsOpacitySunset=1.37 +CloudsOpacityNight=1.12 +CloudsOpacityInteriorDay=1.63 +CloudsOpacityInteriorNight=1.43 +CloudsEdgeFadeRange=0.95 +CloudsEdgeMoonMultiplier=4.32 +IgnoreWeatherSystem=true + +[OBJECT] +SubSurfaceScatteringMultiplierDay=0.0 +SubSurfaceScatteringMultiplierNight=0.0 +SubSurfaceScatteringMultiplierInterior=0.0 +SubSurfaceScatteringPowerDay=1.0 +SubSurfaceScatteringPowerNight=1.0 +SubSurfaceScatteringPowerInterior=1.1 +SubSurfaceScatteringMultiplierSunrise=0.0 +SubSurfaceScatteringMultiplierSunset=0.0 +SubSurfaceScatteringMultiplierInteriorDay=0.0 +SubSurfaceScatteringMultiplierInteriorNight=0.0 +SubSurfaceScatteringPowerSunrise=1.0 +SubSurfaceScatteringPowerSunset=1.0 +SubSurfaceScatteringPowerInteriorDay=1.0 +SubSurfaceScatteringPowerInteriorNight=1.0 +IgnoreWeatherSystem=true + +[LIGHTSPRITE] +IntensityDay=0.53 +IntensityNight=0.81 +IntensityInterior=0.5 +CurveDay=0.93 +CurveNight=1.305 +CurveInterior=0.925 +IntensitySunrise=0.64 +IntensitySunset=0.7 +IntensityInteriorDay=1.07 +IntensityInteriorNight=0.96 +CurveSunrise=1.16 +CurveSunset=0.93 +CurveInteriorDay=1.25 +CurveInteriorNight=1.34 +IgnoreWeatherSystem=true + +[WINDOWLIGHT] +Intensity=2.625 +Curve=1.0 +IntensitySunrise=1.02 +IntensityDay=0.89 +IntensitySunset=1.53 +IntensityNight=1.88 +IntensityInteriorDay=1.98 +IntensityInteriorNight=0.85 +CurveSunrise=1.07 +CurveDay=1.14 +CurveSunset=1.33 +CurveNight=1.14 +CurveInteriorDay=0.86 +CurveInteriorNight=1.32 +IgnoreWeatherSystem=true + +[VOLUMETRICFOG] +IntensityDay=1.106 +IntensityNight=0.89 +IntensityInterior=0.265 +CurveDay=1.11 +CurveNight=0.8 +CurveInterior=1.0 +IntensitySunrise=0.38 +IntensitySunset=0.56 +IntensityInteriorDay=1.17 +IntensityInteriorNight=0.85 +CurveSunrise=1.05 +CurveSunset=1.15 +CurveInteriorDay=1.16 +CurveInteriorNight=0.86 +LightingInfluenceSunrise=1.03 +LightingInfluenceDay=0.58 +LightingInfluenceSunset=1.27 +LightingInfluenceNight=0.85 +LightingInfluenceInteriorDay=0.58 +LightingInfluenceInteriorNight=0.9 +EnableShadows=true +IgnoreWeatherSystem=true + +[FIRE] +IntensityDay=1.875 +IntensityNight=1.5 +IntensityInterior=1.65 +CurveDay=0.75 +CurveNight=1.04 +CurveInterior=1.0 +IntensitySunrise=1.63 +IntensitySunset=1.42 +IntensityInteriorDay=1.31 +IntensityInteriorNight=1.21 +CurveSunrise=0.94 +CurveSunset=0.91 +CurveInteriorDay=0.84 +CurveInteriorNight=0.9 +AdditiveBlending=true +IgnoreWeatherSystem=true [COLORCORRECTION] -DarkeningAmountDay=0 -ScreenLevelDay=0 -ScreenLevelNight=0 -DarkeningAmountNight=0 -GammaCurveDay=0 -GammaCurveNight=0 -ColorSaturationDay=0 -ColorSaturationNight=0 -UsePaletteTexture=0 - -[WATER] -UseWaterDeep=0 -WaterDeepness=0 -WaterQuality=0 +UsePaletteTexture=true +Brightness=1.0 +GammaCurve=1.0 +UseProceduralCorrection=true [SHADOW] -ShadowFadeStart=0 -ShadowFadeEnd=0 -ShadowAmountDay=0 -ShadowAmountNight=0 -ShadowScreenLevelDay=0 -ShadowScreenLevelNight=0 -ShadowQuality=0 -UseShadowFilter=0 -FilterQuality=0 -ShadowBlurRange=0 - -[ENGINE] -ForceAnisotropicFiltering=0 -MaxAnisotropy=16 -ForceDisplayRefreshRate=0 -DisplayRefreshRateHz=60 - -[MOTIONBLUR] -MotionBlurQuality=0 -MotionBlurVelocity=0 -MotionBlurRotation=0 - -[PERPIXELLIGHTING] -SpecularColorMin=0 -SpecularColorMax=0 -SpecularColorMultiplier=0 -SpecularGlossinessMin=0 -SpecularGlossinessMax=0 -SpecularGlossinessMultiplier=0 +ShadowCastersFix=true +ShadowQualityFix=true +DetailedShadowQuality=1 +UseBilateralShadowFilter=true +UseShadowFilter=true +ShadowFilterQuality=1 +ShadowBlurRange=1.65 +ShadowBlurRangeInterior=1.17 +IgnoreWeatherSystem=true [DEPTHOFFIELD] -DOFQuality=0 -DOFNumberOfPasses=0 -DOFFocusRange=0 -DOFBlurinessRange=0 +FadeTime=0.85 +Quality=1 +IgnoreWeatherSystem=true + +[RAYS] +SunRaysMultiplier=0.75 +SunRaysMultiplierSunrise=0.59 +SunRaysMultiplierDay=0.24 +SunRaysMultiplierSunset=0.54 +SunRaysMultiplierNight=0.32 +SunRaysMultiplierInteriorDay=0.37 +SunRaysMultiplierInteriorNight=0.44 +IgnoreWeatherSystem=true + +[SKYLIGHTING] +Quality=1 +FilterQuality=1 +AmbientMinLevel=0.39375 +AmbientMinLevelSunrise=0.33 +AmbientMinLevelDay=0.64 +AmbientMinLevelSunset=0.4 +AmbientMinLevelNight=0.29 +AmbientMinLevelInteriorDay=0.22 +AmbientMinLevelInteriorNight=0.18 +IgnoreWeatherSystem=true + +[WEATHER] +EnableMultipleWeathers=false + +[TIMEOFDAY] +Enable=true +DawnDuration=2.0 +SunriseTime=6.5 +DayTime=12.0 +SunsetTime=18.5 +DuskDuration=2.0 +NightTime=0.0 + +[VEGETATION] +SubSurfaceScatteringMultiplierSunrise=0.0 +SubSurfaceScatteringMultiplierDay=0.0 +SubSurfaceScatteringMultiplierSunset=0.0 +SubSurfaceScatteringMultiplierNight=0.0 +SubSurfaceScatteringMultiplierInteriorDay=0.0 +SubSurfaceScatteringMultiplierInteriorNight=0.0 +SubSurfaceScatteringPowerSunrise=1.0 +SubSurfaceScatteringPowerDay=1.0 +SubSurfaceScatteringPowerSunset=1.0 +SubSurfaceScatteringPowerNight=1.0 +SubSurfaceScatteringPowerInteriorDay=1.0 +SubSurfaceScatteringPowerInteriorNight=1.0 +IgnoreWeatherSystem=true + +[PARTICLE] +IntensitySunrise=0.81 +IntensityDay=0.94 +IntensitySunset=0.85 +IntensityNight=0.72 +IntensityInteriorDay=1.14 +IntensityInteriorNight=0.73 +LightingInfluenceSunrise=1.49 +LightingInfluenceDay=0.86 +LightingInfluenceSunset=1.82 +LightingInfluenceNight=0.92 +LightingInfluenceInteriorDay=0.84 +LightingInfluenceInteriorNight=0.95 +IgnoreWeatherSystem=true + +[REFLECTION] +Quality=1 +FilterQuality=1 +FilterBluriness=1.0 +SizeScale=0.5 +SourceTexturesScale=0.5 +Amount=0.56 +Power=1.41 +GlosinessMin=0.0 +GlosinessMax=1.0 +EnableDenoiser=false +DenoiserType=0 +EnableSupersampling=false +ExteriorEnable=true +InteriorEnable=true +IgnoreWeatherSystem=true + +[IMAGEBASEDLIGHTING] +AdditiveAmountSunrise=0.02 +AdditiveAmountDay=0.03 +AdditiveAmountSunset=0.02 +AdditiveAmountNight=0.01 +AdditiveAmountInteriorDay=0.02 +AdditiveAmountInteriorNight=0.01 +MultiplicativeAmountSunrise=0.09 +MultiplicativeAmountDay=0.06 +MultiplicativeAmountSunset=0.1 +MultiplicativeAmountNight=0.03 +MultiplicativeAmountInteriorDay=0.05 +MultiplicativeAmountInteriorNight=0.02 +ReflectiveAmountSunrise=0.15 +ReflectiveAmountDay=0.12 +ReflectiveAmountSunset=0.17 +ReflectiveAmountNight=0.06 +ReflectiveAmountInteriorDay=0.11 +ReflectiveAmountInteriorNight=0.04 +IgnoreWeatherSystem=true + +[RAIN] +Enable=true +EnableAntialiasing=false +EnableSupersampling=false +MotionStretch=0.35 +MotionTransparency=0.89 +IgnoreWeatherSystem=true + +[EYES] +SubSurfaceScatteringMultiplierSunrise=0.0 +SubSurfaceScatteringMultiplierDay=0.0 +SubSurfaceScatteringMultiplierSunset=0.0 +SubSurfaceScatteringMultiplierNight=0.0 +SubSurfaceScatteringMultiplierInteriorDay=0.0 +SubSurfaceScatteringMultiplierInteriorNight=0.0 +SubSurfaceScatteringPowerSunrise=1.0 +SubSurfaceScatteringPowerDay=1.0 +SubSurfaceScatteringPowerSunset=1.0 +SubSurfaceScatteringPowerNight=1.0 +SubSurfaceScatteringPowerInteriorDay=1.0 +SubSurfaceScatteringPowerInteriorNight=1.0 +IgnoreWeatherSystem=true + +[SUBSURFACESCATTERING] +Quality=1 +Radius=2.18 +Amount=0.5 +EpidermalAmount=1.23 +SubdermalAmount=2.25 +EpidermalDiffuseSaturation=-0.13 +SubdermalDiffuseSaturation=0.03 +EpidermalMix=0.92 +SubdermalMix=0.49 +SubdermalTranslucency=0.95 +SubdermalPhase=0.92 +IgnoreWeatherSystem=true + +[LENS] +ReflectionIntensitySunrise=1.049999 +ReflectionIntensityDay=0.99 +ReflectionIntensitySunset=1.16 +ReflectionIntensityNight=1.4 +ReflectionIntensityInteriorDay=0.88 +ReflectionIntensityInteriorNight=1.120001 +ReflectionPowerSunrise=1.68 +ReflectionPowerDay=2.05 +ReflectionPowerSunset=1.5 +ReflectionPowerNight=1.11 +ReflectionPowerInteriorDay=1.43 +ReflectionPowerInteriorNight=1.22 +DirtIntensitySunrise=1.79 +DirtIntensityDay=1.51 +DirtIntensitySunset=1.84 +DirtIntensityNight=1.08 +DirtIntensityInteriorDay=1.44 +DirtIntensityInteriorNight=1.22 +DirtPowerSunrise=1.16 +DirtPowerDay=1.33 +DirtPowerSunset=1.06 +DirtPowerNight=1.5 +DirtPowerInteriorDay=1.39 +DirtPowerInteriorNight=1.49 +IgnoreWeatherSystem=true + +[WATER] +EnableDispersion=true +EnableCaustics=true +ReflectionAmount=0.86 +FrennelMultiplier=3.16 +FrennelMin=0.18 +FrennelMax=1.0 +DispersionAmount=0.93 +CausticsAmount=1.46 +EnableParallax=true +EnableShadow=true +EnableSelfReflection=true +EnableLighting=true +EnableDisplacement=true +DisplacementQuality=1 +SunSpecularMultiplier=1.63 +SunScatteringMultiplier=2.07 +WavesAmplitudeSunrise=1.0 +WavesAmplitudeDay=1.0 +WavesAmplitudeSunset=1.0 +WavesAmplitudeNight=1.0 +WavesAmplitudeInteriorDay=1.0 +WavesAmplitudeInteriorNight=1.0 +ShadowQuality=1 +EnableShadowNoise=true +SunLightingMultiplier=0.76 +WetMultiplier=0.7 +Muddiness=0.44 +EnablePreCache=true +EnableVolumetricShadow=true +DisplacementFilterQuality=1 +IgnoreWeatherSystem=true +[UNDERWATER] +EnableDispersion=true +EnableParallax=true +EnableDisplacement=true +EnableSilhouette=true +EnableBlurring=true +EnableReflection=true +EnableShadow=true +ShadowQuality=1 +DispersionAmount=0.96 +ReflectionAmount=0.97 +TransparencyFade=3.56 +TransparencyCurve=1.03 +DeepnessFade=3.88 +DeepnessDarkening=0.93 +TintAmount=3.27 +TintFade=4.7 +SunScatteringMultiplier=1.68 +IgnoreWeatherSystem=true +[CLOUDSHADOWS] +EnableAtNight=true +OpacitySunrise=0.73 +OpacityDay=0.57 +OpacitySunset=0.76 +OpacityNight=0.91 +OpacityInteriorDay=0.62 +OpacityInteriorNight=0.98 +IgnoreWeatherSystem=true +[VOLUMETRICRAYS] +Quality=1 +IntensitySunrise=0.67 +IntensityDay=0.42 +IntensitySunset=0.77 +IntensityNight=0.41 +IntensityInteriorDay=0.58 +IntensityInteriorNight=0.5 +DensitySunrise=1.76 +DensityDay=0.94 +DensitySunset=1.6 +DensityNight=0.62 +DensityInteriorDay=1.44 +DensityInteriorNight=0.51 +SkyColorAmountSunrise=0.89 +SkyColorAmountDay=0.69 +SkyColorAmountSunset=0.87 +SkyColorAmountNight=0.72 +SkyColorAmountInteriorDay=0.63 +SkyColorAmountInteriorNight=0.78 +IgnoreWeatherSystem=true +[PROCEDURALSUN] +Size=0.68 +EdgeSoftness=0.51 +GlowIntensitySunrise=0.88 +GlowIntensityDay=0.57 +GlowIntensitySunset=0.89 +GlowIntensityNight=0.16 +GlowIntensityInteriorDay=0.95 +GlowIntensityInteriorNight=0.09 +GlowCurveSunrise=9.68 +GlowCurveDay=7.46 +GlowCurveSunset=8.29 +GlowCurveNight=1.85 +GlowCurveInteriorDay=9.31 +GlowCurveInteriorNight=1.48 +IgnoreWeatherSystem=true +[MIST] +ColorFromEnvironmentFog=0.75 +SkyLightingAmountSunrise=0.55 +SkyLightingAmountDay=0.37 +SkyLightingAmountSunset=0.36 +SkyLightingAmountNight=0.39 +SkyLightingAmountInteriorDay=0.88 +SkyLightingAmountInteriorNight=0.48 +SunLightingAmountSunrise=1.18 +SunLightingAmountDay=0.92 +SunLightingAmountSunset=1.19 +SunLightingAmountNight=0.19 +SunLightingAmountInteriorDay=0.87 +SunLightingAmountInteriorNight=0.05 +DesaturationSunrise=0.0 +DesaturationDay=0.0 +DesaturationSunset=0.0 +DesaturationNight=0.0 +DesaturationInteriorDay=0.0 +DesaturationInteriorNight=0.0 +ColorFilterSunrise=1, 0.957, 0.863 +ColorFilterDay=0.925, 0.984, 1 +ColorFilterSunset=1, 0.714, 0.58 +ColorFilterNight=0.396, 0.494, 0.663 +ColorFilterInteriorDay=0.922, 0.988, 1 +ColorFilterInteriorNight=0.443, 0.506, 0.69 +RelativeToCameraSunrise=0.12 +RelativeToCameraDay=0.51 +RelativeToCameraSunset=0.17 +RelativeToCameraNight=0.25 +RelativeToCameraInteriorDay=0.58 +RelativeToCameraInteriorNight=0.21 +VerticalOffsetSunrise=-9.31 +VerticalOffsetDay=-10.97 +VerticalOffsetSunset=-9.04 +VerticalOffsetNight=-11.14 +VerticalOffsetInteriorDay=-10.44 +VerticalOffsetInteriorNight=-11.26 +DensitySunrise=1.41 +DensityDay=1.25 +DensitySunset=1.28 +DensityNight=1.14 +DensityInteriorDay=1.29 +DensityInteriorNight=1.17 +VerticalFadeSunrise=4.93 +VerticalFadeDay=4.46 +VerticalFadeSunset=5.07 +VerticalFadeNight=4.83 +VerticalFadeInteriorDay=4.39 +VerticalFadeInteriorNight=4.78 +BottomTopSunrise=0.17 +BottomTopDay=0.0 +BottomTopSunset=0.09 +BottomTopNight=0.03 +BottomTopInteriorDay=0.0 +BottomTopInteriorNight=0.01 +ExponentialFadeSunrise=0.89 +ExponentialFadeDay=0.95 +ExponentialFadeSunset=0.83 +ExponentialFadeNight=1.15 +ExponentialFadeInteriorDay=0.96 +ExponentialFadeInteriorNight=1.09 +IgnoreWeatherSystem=true +EnableAnchors=false diff --git a/enbseries/_weatherlist.ini b/enbseries/_weatherlist.ini new file mode 100644 index 0000000..0d26b7d --- /dev/null +++ b/enbseries/_weatherlist.ini @@ -0,0 +1,297 @@ +[WEATHER001] +FileName= +WeatherIDs= +[WEATHER002] +FileName= +WeatherIDs= +[WEATHER003] +FileName= +WeatherIDs= +[WEATHER004] +FileName= +WeatherIDs= +[WEATHER005] +FileName= +WeatherIDs= +[WEATHER006] +FileName= +WeatherIDs= +[WEATHER007] +FileName= +WeatherIDs= +[WEATHER008] +FileName= +WeatherIDs= +[WEATHER009] +FileName= +WeatherIDs= +[WEATHER010] +FileName= +WeatherIDs= +[WEATHER011] +FileName= +WeatherIDs= +[WEATHER012] +FileName= +WeatherIDs= +[WEATHER013] +FileName= +WeatherIDs= +[WEATHER014] +FileName= +WeatherIDs= +[WEATHER015] +FileName= +WeatherIDs= +[WEATHER016] +FileName= +WeatherIDs= +[WEATHER017] +FileName= +WeatherIDs= +[WEATHER018] +FileName= +WeatherIDs= +[WEATHER019] +FileName= +WeatherIDs= +[WEATHER020] +FileName= +WeatherIDs= +[WEATHER021] +FileName= +WeatherIDs= +[WEATHER022] +FileName= +WeatherIDs= +[WEATHER023] +FileName= +WeatherIDs= +[WEATHER024] +FileName= +WeatherIDs= +[WEATHER025] +FileName= +WeatherIDs= +[WEATHER026] +FileName= +WeatherIDs= +[WEATHER027] +FileName= +WeatherIDs= +[WEATHER028] +FileName= +WeatherIDs= +[WEATHER029] +FileName= +WeatherIDs= +[WEATHER030] +FileName= +WeatherIDs= +[WEATHER031] +FileName= +WeatherIDs= +[WEATHER032] +FileName= +WeatherIDs= +[WEATHER033] +FileName= +WeatherIDs= +[WEATHER034] +FileName= +WeatherIDs= +[WEATHER035] +FileName= +WeatherIDs= +[WEATHER036] +FileName= +WeatherIDs= +[WEATHER037] +FileName= +WeatherIDs= +[WEATHER038] +FileName= +WeatherIDs= +[WEATHER039] +FileName= +WeatherIDs= +[WEATHER040] +FileName= +WeatherIDs= +[WEATHER041] +FileName= +WeatherIDs= +[WEATHER042] +FileName= +WeatherIDs= +[WEATHER043] +FileName= +WeatherIDs= +[WEATHER044] +FileName= +WeatherIDs= +[WEATHER045] +FileName= +WeatherIDs= +[WEATHER046] +FileName= +WeatherIDs= +[WEATHER047] +FileName= +WeatherIDs= +[WEATHER048] +FileName= +WeatherIDs= +[WEATHER049] +FileName= +WeatherIDs= +[WEATHER050] +FileName= +WeatherIDs= +[WEATHER051] +FileName= +WeatherIDs= +[WEATHER052] +FileName= +WeatherIDs= +[WEATHER053] +FileName= +WeatherIDs= +[WEATHER054] +FileName= +WeatherIDs= +[WEATHER055] +FileName= +WeatherIDs= +[WEATHER056] +FileName= +WeatherIDs= +[WEATHER057] +FileName= +WeatherIDs= +[WEATHER058] +FileName= +WeatherIDs= +[WEATHER059] +FileName= +WeatherIDs= +[WEATHER060] +FileName= +WeatherIDs= +[WEATHER061] +FileName= +WeatherIDs= +[WEATHER062] +FileName= +WeatherIDs= +[WEATHER063] +FileName= +WeatherIDs= +[WEATHER064] +FileName= +WeatherIDs= +[WEATHER065] +FileName= +WeatherIDs= +[WEATHER066] +FileName= +WeatherIDs= +[WEATHER067] +FileName= +WeatherIDs= +[WEATHER068] +FileName= +WeatherIDs= +[WEATHER069] +FileName= +WeatherIDs= +[WEATHER070] +FileName= +WeatherIDs= +[WEATHER071] +FileName= +WeatherIDs= +[WEATHER072] +FileName= +WeatherIDs= +[WEATHER073] +FileName= +WeatherIDs= +[WEATHER074] +FileName= +WeatherIDs= +[WEATHER075] +FileName= +WeatherIDs= +[WEATHER076] +FileName= +WeatherIDs= +[WEATHER077] +FileName= +WeatherIDs= +[WEATHER078] +FileName= +WeatherIDs= +[WEATHER079] +FileName= +WeatherIDs= +[WEATHER080] +FileName= +WeatherIDs= +[WEATHER081] +FileName= +WeatherIDs= +[WEATHER082] +FileName= +WeatherIDs= +[WEATHER083] +FileName= +WeatherIDs= +[WEATHER084] +FileName= +WeatherIDs= +[WEATHER085] +FileName= +WeatherIDs= +[WEATHER086] +FileName= +WeatherIDs= +[WEATHER087] +FileName= +WeatherIDs= +[WEATHER088] +FileName= +WeatherIDs= +[WEATHER089] +FileName= +WeatherIDs= +[WEATHER090] +FileName= +WeatherIDs= +[WEATHER091] +FileName= +WeatherIDs= +[WEATHER092] +FileName= +WeatherIDs= +[WEATHER093] +FileName= +WeatherIDs= +[WEATHER094] +FileName= +WeatherIDs= +[WEATHER095] +FileName= +WeatherIDs= +[WEATHER096] +FileName= +WeatherIDs= +[WEATHER097] +FileName= +WeatherIDs= +[WEATHER098] +FileName= +WeatherIDs= +[WEATHER099] +FileName= +WeatherIDs= \ No newline at end of file diff --git a/enbseries/effect.txt.ini b/enbseries/effect.txt.ini new file mode 100644 index 0000000..aaa64a4 --- /dev/null +++ b/enbseries/effect.txt.ini @@ -0,0 +1,96 @@ +[EFFECT.TXT] +TECHNIQUE=0 +EnableFXAA=false +FXAASpanMax=3.999999 +FXAAReduceMul=16.0 +FXAAReduceMin=128.0 +EnableBorderBlur=true +BorderBlurSamplingRange=1.0 +BorderBlurPower=22.0 +BorderBlurCurve=1.5 +BorderBlurRadius=0.55 +BorderBlurSize=1 +EnableCrossBlur=true +CrossBlurSamplingRange=1.0 +CrossBlurSize=1 +EnableCompensate=true +CompensateFactor=0.19 +CompensatePower=1.05 +CompensateSaturation=0.3 +CompensateBump=0.0 +EnableGrading=true +GradingAddR=0.0 +GradingAddG=0.0 +GradingAddB=0.0 +GradingMulR=1.02 +GradingMulG=1.08 +GradingMulB=1.04 +GradingPowR=1.07 +GradingPowG=1.12 +GradingPowB=1.08 +GradingColR=0.04 +GradingColG=0.07 +GradingColB=0.59 +GradingColFactor=-0.24 +EnableSoftGrain=true +SoftGrainSpeed=2.679999 +SoftGrainIntensity=0.04 +SoftGrainSaturation=0.09 +SoftGrainPatterned=true +SoftGrainBlendfunc=1 +SoftGrainDeviation=0.05 +SoftGrainMagnification11=2.049997 +SoftGrainMagnification12=3.109994 +SoftGrainMagnification13=2.22 +SoftGrainMagnification21=4.249999 +SoftGrainMagnification22=0.419999 +SoftGrainMagnification23=6.290002 +SoftGrainPower=2.93 +EnableBlockGFX=false +BlockGFXResolutionW=1.0 +BlockGFXResolutionH=1.0 +BlockGFXNoScale=false +BlockGFXAspect=false +BlockGFXBorder=0.0 +BlockGFXpalette=5 +EnableDotMatrix=false +DotBlend=0.2 +DotSize=1 +EnableDirt=true +DirtFactor=0.03 +EnableCurvature=false +CurveChromaticAberration=0.03 +CurveZoom=49.999928 +CurveLens=0.0 +CurveLensCubic=0.0 +SoftGrainTwopass=true +SoftGrainMagnification1=1.250002 +SoftGrainMagnification2=0.639998 +SoftGrainMagnification3=0.350001 +DirtCoordFactor=0.09 +DirtLuminanceFactor=0.0 +DirtCoordMagnification=3.039998 +DirtLuminanceMagnification=1.0 +EnableBox=true +BoxHorizontal=1.5 +BoxVertical=1.0 +BoxSoften=0.02 +BoxAlpha=6.069999 +BlockGFXcgamode=0 +DarkEnable=true +DarkRadius=0.37 +DarkCurve=1.94 +DarkBump=0.79 +BlurEnable=true +BlurSample=2.25 +BlurLevel=1 +BlurPower=15.46 +BlurCurve=1.2 +BlurRadius=0.69 +EnableMud=true +MudLevel=3 +MudSample=16.32 +MudFactor=1.52 +MudPower=1.73 +MudSaturation=1.6 +MudBump=-0.32 diff --git a/enbseries/enbbloom.fx.ini b/enbseries/enbbloom.fx.ini new file mode 100644 index 0000000..598c291 --- /dev/null +++ b/enbseries/enbbloom.fx.ini @@ -0,0 +1,2 @@ +[ENBBLOOM.FX] +TECHNIQUE=0 diff --git a/enbseries/enbeffect.fx.ini b/enbseries/enbeffect.fx.ini new file mode 100644 index 0000000..ffc67f3 --- /dev/null +++ b/enbseries/enbeffect.fx.ini @@ -0,0 +1,23 @@ +[ENBEFFECT.FX] +TECHNIQUE=0 +EBrightnessV2Day=6.25 +EAdaptationMinV2Day=0.03 +EAdaptationMaxV2Day=0.93 +EToneMappingCurveV2Day=3.61 +EIntensityContrastV2Day=0.97 +EToneMappingOversaturationV2Day=15.990001 +EColorSaturationV2Day=1.01 +EBrightnessV2Night=3.77 +EAdaptationMinV2Night=1.14 +EAdaptationMaxV2Night=0.05 +EToneMappingCurveV2Night=3.26 +EIntensityContrastV2Night=0.94 +EToneMappingOversaturationV2Night=26.289999 +EColorSaturationV2Night=0.9 +EBrightnessV2Interior=10.27 +EAdaptationMinV2Interior=1.27 +EAdaptationMaxV2Interior=0.1 +EToneMappingCurveV2Interior=3.62 +EIntensityContrastV2Interior=0.99 +EToneMappingOversaturationV2Interior=15.94 +EColorSaturationV2Interior=1.09 diff --git a/enbseries/enbeffectprepass.fx.ini b/enbseries/enbeffectprepass.fx.ini new file mode 100644 index 0000000..3d9898c --- /dev/null +++ b/enbseries/enbeffectprepass.fx.ini @@ -0,0 +1,2 @@ +[ENBEFFECTPREPASS.FX] +TECHNIQUE=0 diff --git a/enbseries/enblens.fx.ini b/enbseries/enblens.fx.ini new file mode 100644 index 0000000..18ad05f --- /dev/null +++ b/enbseries/enblens.fx.ini @@ -0,0 +1,25 @@ +[ENBLENS.FX] +TECHNIQUE=0 +EnableLens=true +LensAspect=false +LensGhosts=3 +LensDistortion=0.85 +LensBaseScale=1.94 +LensBaseBias=-0.32 +LensDisplacement=0.79 +LensHalo=0.44 +LensHaloScale=0.44 +LensHaloBias=-0.74 +LensBasePower=6.33 +LensHaloPower=2.85 +LensMirrorScale=3.25 +LensMirrorBias=-0.33 +LensMirrorPower=0.67 +LensBaseSaturation=0.52 +LensHaloSaturation=0.67 +LensMirrorSaturation=0.74 +DirtFactor=0.42 +DirtPower=1.65 +DirtSample=8.0 +LensLevel=0 +LensSample=8.0 diff --git a/enbseries/enbsunsprite.fx.ini b/enbseries/enbsunsprite.fx.ini new file mode 100644 index 0000000..cf7763b --- /dev/null +++ b/enbseries/enbsunsprite.fx.ini @@ -0,0 +1,2 @@ +[ENBSUNSPRITE.FX] +TECHNIQUE=0 diff --git a/enbsunsprite.fx b/enbsunsprite.fx new file mode 100644 index 0000000..028f97a --- /dev/null +++ b/enbsunsprite.fx @@ -0,0 +1,735 @@ +// K ENB +// Multiple Passes Lenzes w_Individual Size and Color Control +// Code extensive modifications by KYO aka Oyama w/some help from Boris ;) +// Lenz Texture by OpethFeldt +// Copyright (c) 2007-2013 Boris Vorontsov +// Medium Hexagons + +//===================================================================================================== +// Internal parameters +//===================================================================================================== + +float ELenzIntensity=1.0; //[Global Intensity] +float LenzScaleFactor=0.288; //[Global Scale, will affect all lenzes] //1.0, 0.75, 0.66, 0.5, 0.25, 0.33, 0.322, so on + +float LenzFactorDraw=1.0; //[Allows for separated factors in case of additional Draw techniques, such as Draw2, ect...] + +float LenzContrastDraw=1.3; //[Contrast to clouds - More is weaker opacity compared to clouds] + +/** + * Separated Lenzes controls for Draw techniques : Offset, Scale, Scale Factor, Color RGB, Color Multiplier + * KYO : color balance will also act as a separate intensity control for each lenz + * Color : 1.0, 1.0, 1.0 is full intensity / opacity + * If color components are below 1.0, lenz is losing opacity + * You can counterbalance it by increasing f#_ColorMultiplier over 1.0 + * Fine tuning is balancing global intensity, RGB balance, multiplier + */ + +//Lenz #1 +#define f1_LenzOffset -0.8 //Position from Sun to Eye +#define f1_LenzScale 0.093 //Size of the Lenz Flare +#define f1_LenzFactor 1.0 //Multiplier for Size, in case 2 lenzes are sharing close offset a/o scale +#define f1_LenzColor float3(0.75, 0.75, 0.50) //Color in RGB (0.00 to 1.00) for the Lenz Flare +#define f1_ColorMultiplier 1.0 //Color Multiplier, in case RGB values are too low - Fine Tuning + +//Lenz #2 +#define f2_LenzOffset -0.54 +#define f2_LenzScale 0.066 +#define f2_LenzFactor 1.0 +#define f2_LenzColor float3(0.85, 0.65, 0.85) +#define f2_ColorMultiplier 1.2 + +//Lenz #3 +#define f3_LenzOffset -0.34 +#define f3_LenzScale 0.100 +#define f3_LenzFactor 1.0 +#define f3_LenzColor float3(1.0, 1.0, 1.0) +#define f3_ColorMultiplier 1.0 + +//Lenz #4 +#define f4_LenzOffset -0.14 +#define f4_LenzScale 0.099 +#define f4_LenzFactor 0.75 +#define f4_LenzColor float3(0.25, 1.0, 0.75) +#define f4_ColorMultiplier 1.0 + +//Lenz #5 +#define f5_LenzOffset -0.27 +#define f5_LenzScale 0.072 +#define f5_LenzFactor 1.0 +#define f5_LenzColor float3(0.3, 0.3, 0.25) +#define f5_ColorMultiplier 2.0 + +//Lenz #6 +#define f6_LenzOffset -0.3 +#define f6_LenzScale 0.115 +#define f6_LenzFactor 0.75 +#define f6_LenzColor float3(0.20, 0.30, 0.35) +#define f6_ColorMultiplier 1.2 + +//Lenz #7 +#define f7_LenzOffset -0.4 +#define f7_LenzScale 0.098 +#define f7_LenzFactor 1.0 +#define f7_LenzColor float3(1.0, 1.0, 1.0) +#define f7_ColorMultiplier 1.0 + +//Lenz #8 +#define f8_LenzOffset -0.2 +#define f8_LenzScale 0.081 +#define f8_LenzFactor 0.5 +#define f8_LenzColor float3(0.25, 0.95, 0.45) +#define f8_ColorMultiplier 1.8 + +//Lenz #9 +#define f9_LenzOffset -0.1 +#define f9_LenzScale 0.121 +#define f9_LenzFactor 0.85 +#define f9_LenzColor float3(1.0, 1.0, 1.0) +#define f9_ColorMultiplier 1.0 + +//Lenz #10 +#define f10_LenzOffset 0.0 +#define f10_LenzScale 0.111 +#define f10_LenzFactor 1.0 +#define f10_LenzColor float3(0.55, 0.55, 0.55) +#define f10_ColorMultiplier 1.0 + +//Lenz #11 +#define f11_LenzOffset 0.8 +#define f11_LenzScale 0.234 +#define f11_LenzFactor 1.11 +#define f11_LenzColor float3(0.35, 0.45, 0.62) +#define f11_ColorMultiplier 2.0 + +//Lenz #12 +#define f12_LenzOffset 0.9 +#define f12_LenzScale 0.144 +#define f12_LenzFactor 1.11 +#define f12_LenzColor float3(0.35, 0.35, 0.42) +#define f12_ColorMultiplier 1.0 + +//Lenz #13 +#define f13_LenzOffset 1.0 +#define f13_LenzScale 0.174 +#define f13_LenzFactor 1.11 +#define f13_LenzColor float3(0.35, 0.35, 0.42) +#define f13_ColorMultiplier 1.0 + +//Lenz #14 +#define f14_LenzOffset 0.42 +#define f14_LenzScale 0.064 +#define f14_LenzFactor 1.11 +#define f14_LenzColor float3(0.35, 0.35, 0.42) +#define f14_ColorMultiplier 1.0 + +//Lenz #15 +#define f15_LenzOffset 0.53 +#define f15_LenzScale 0.074 +#define f15_LenzFactor 1.11 +#define f15_LenzColor float3(0.35, 0.35, 0.42) +#define f15_ColorMultiplier 1.0 + +//Lenz #16 +#define f16_LenzOffset 0.65 +#define f16_LenzScale 0.094 +#define f16_LenzFactor 1.11 +#define f16_LenzColor float3(0.35, 0.35, 0.42) +#define f16_ColorMultiplier 1.0 + +//Lenz #17 +#define f17_LenzOffset 0.76 +#define f17_LenzScale 0.104 +#define f17_LenzFactor 1.11 +#define f17_LenzColor float3(0.35, 0.35, 0.42) +#define f17_ColorMultiplier 1.0 + +//Lenz #18 +#define f18_LenzOffset 0.9 +#define f18_LenzScale 0.114 +#define f18_LenzFactor 1.11 +#define f18_LenzColor float3(0.35, 0.35, 0.42) +#define f18_ColorMultiplier 1.0 + +//Lenz #19 +#define f19_LenzOffset 1.0 +#define f19_LenzScale 0.174 +#define f19_LenzFactor 1.11 +#define f19_LenzColor float3(0.35, 0.35, 0.42) +#define f19_ColorMultiplier 1.0 + +//Lenz #20 +#define f20_LenzOffset 1.2 +#define f20_LenzScale 0.224 +#define f20_LenzFactor 1.11 +#define f20_LenzColor float3(0.35, 0.35, 0.42) +#define f20_ColorMultiplier 1.0 + +//Lenz #21 +#define f21_LenzOffset 1.6 +#define f21_LenzScale 0.234 +#define f21_LenzFactor 1.11 +#define f21_LenzColor float3(0.35, 0.35, 0.42) +#define f21_ColorMultiplier 1.0 + +//Lenz #22 +#define f22_LenzOffset 1.9 +#define f22_LenzScale 0.064 +#define f22_LenzFactor 1.11 +#define f22_LenzColor float3(0.35, 0.35, 0.42) +#define f22_ColorMultiplier 1.0 + +//Add or Remove additional Lenzes controls here, as done above +//This being done, a/o remove passes of technique below + +//===================================================================================================== +// External parameters +//===================================================================================================== +//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=Width, y=1/Width, z=ScreenScaleY, w=1/ScreenScaleY +float4 ScreenSize; +//x=generic timer in range 0..1, period of 16777216 ms (4.6 hours), w=frame time elapsed (in seconds) +float4 Timer; +//xy=sun position on screen, w=visibility +float4 LightParameters; + +//textures +texture2D texColor; +texture2D texMask; + +sampler2D SamplerColor = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +sampler2D SamplerMask = sampler_state +{ + Texture = ; + MinFilter = LINEAR; + MagFilter = LINEAR; + MipFilter = NONE; + AddressU = Clamp; + AddressV = Clamp; + SRGBTexture=FALSE; + MaxMipLevel=0; + MipMapLodBias=0; +}; + +struct VS_OUTPUT_POST +{ + float4 vpos : POSITION; + float2 txcoord : TEXCOORD0; +}; + +struct VS_INPUT_POST +{ + float3 pos : POSITION; + float2 txcoord : TEXCOORD0; +}; + +/** + * Several sprites moving similar to lenz effect + * They are transformed in vertex shader and drawed separately for better performance + * Offset is set in passes of technique + */ + +VS_OUTPUT_POST VS_Draw(VS_INPUT_POST IN, uniform float offset, uniform float scale) +{ + VS_OUTPUT_POST OUT; + + float4 pos=float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0); + pos.y*=ScreenSize.z; + + //create own parameters instead of this, including uv offsets + float2 shift=LightParameters.xy * offset; + pos.xy=pos.xy * (scale * LenzScaleFactor) - shift; + + OUT.vpos=pos; + OUT.txcoord.xy=IN.txcoord.xy; + + return OUT; +} + +float4 PS_Draw(VS_OUTPUT_POST IN, float2 vPos : VPOS, uniform float3 colorfilter, uniform float colormultiplier) : COLOR +{ + float4 res; + float2 coord=IN.txcoord.xy; + + //read sun visibility as amount of effect + float sunmask=tex2D(SamplerMask, float2(0.5, 0.5)).x; + sunmask=pow(sunmask, LenzContrastDraw); //more contrast to clouds + clip(sunmask-0.02);//early exit if too low + + float4 origcolor=tex2D(SamplerColor, coord.xy); + sunmask*=LightParameters.w * (ELenzIntensity * LenzFactorDraw); + res.xyz=origcolor * sunmask; + + float clipper=dot(res.xyz, 0.333); + clip(clipper-0.0003);//skip draw if black + + res.xyz*=colorfilter * colormultiplier; + res.w=1.0; + return res; +} + +//------------------------------------------------------------------------------------------------------------------------- + +/** + * TECHNIQUES + */ + +technique Draw +{ + pass P0 + { + VertexShader = compile vs_3_0 VS_Draw(f1_LenzOffset, (f1_LenzScale * f1_LenzFactor)); //offset, scale, scale factor + PixelShader = compile ps_3_0 PS_Draw(f1_LenzColor, f1_ColorMultiplier); //Color RGB + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P1 + { + VertexShader = compile vs_3_0 VS_Draw(f2_LenzOffset, (f2_LenzScale * f2_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f2_LenzColor, f2_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P2 + { + VertexShader = compile vs_3_0 VS_Draw(f3_LenzOffset, (f3_LenzScale * f3_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f3_LenzColor, f3_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P3 + { + VertexShader = compile vs_3_0 VS_Draw(f4_LenzOffset, (f4_LenzScale * f4_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f4_LenzColor, f4_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P4 + { + VertexShader = compile vs_3_0 VS_Draw(f5_LenzOffset, (f5_LenzScale * f5_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f5_LenzColor, f5_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P5 + { + VertexShader = compile vs_3_0 VS_Draw(f6_LenzOffset, (f6_LenzScale * f6_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f6_LenzColor, f6_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P6 + { + VertexShader = compile vs_3_0 VS_Draw(f7_LenzOffset, (f7_LenzScale * f7_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f7_LenzColor, f7_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P7 + { + VertexShader = compile vs_3_0 VS_Draw(f8_LenzOffset, (f8_LenzScale * f8_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f8_LenzColor, f8_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P8 + { + VertexShader = compile vs_3_0 VS_Draw(f9_LenzOffset, (f9_LenzScale * f9_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f9_LenzColor, f9_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P9 + { + VertexShader = compile vs_3_0 VS_Draw(f10_LenzOffset, (f10_LenzScale * f10_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f10_LenzColor, f10_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P10 + { + VertexShader = compile vs_3_0 VS_Draw(f11_LenzOffset, (f11_LenzScale * f11_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f11_LenzColor, f11_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P11 + { + VertexShader = compile vs_3_0 VS_Draw(f11_LenzOffset, (f12_LenzScale * f12_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f12_LenzColor, f12_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P12 + { + VertexShader = compile vs_3_0 VS_Draw(f13_LenzOffset, (f13_LenzScale * f13_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f13_LenzColor, f13_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P13 + { + VertexShader = compile vs_3_0 VS_Draw(f14_LenzOffset, (f14_LenzScale * f14_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f14_LenzColor, f14_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P14 + { + VertexShader = compile vs_3_0 VS_Draw(f15_LenzOffset, (f15_LenzScale * f15_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f15_LenzColor, f15_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P15 + { + VertexShader = compile vs_3_0 VS_Draw(f16_LenzOffset, (f16_LenzScale * f16_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f16_LenzColor, f16_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P16 + { + VertexShader = compile vs_3_0 VS_Draw(f17_LenzOffset, (f17_LenzScale * f17_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f17_LenzColor, f17_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P17 + { + VertexShader = compile vs_3_0 VS_Draw(f18_LenzOffset, (f18_LenzScale * f18_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f18_LenzColor, f18_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P18 + { + VertexShader = compile vs_3_0 VS_Draw(f19_LenzOffset, (f19_LenzScale * f19_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f19_LenzColor, f19_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P19 + { + VertexShader = compile vs_3_0 VS_Draw(f20_LenzOffset, (f20_LenzScale * f20_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f20_LenzColor, f20_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P20 + { + VertexShader = compile vs_3_0 VS_Draw(f21_LenzOffset, (f21_LenzScale * f21_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f21_LenzColor, f21_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } + + pass P21 + { + VertexShader = compile vs_3_0 VS_Draw(f22_LenzOffset, (f22_LenzScale * f22_LenzFactor)); + PixelShader = compile ps_3_0 PS_Draw(f22_LenzColor, f22_ColorMultiplier); + + AlphaBlendEnable=TRUE; + SrcBlend=ONE; + DestBlend=ONE; + + ColorWriteEnable = ALPHA|RED|GREEN|BLUE; + DitherEnable=FALSE; + ZEnable=FALSE; + CullMode=NONE; + ALPHATESTENABLE=FALSE; + SEPARATEALPHABLENDENABLE=FALSE; + StencilEnable=FALSE; + FogEnable=FALSE; + SRGBWRITEENABLE=FALSE; + } +} +// KYO : and so on... \ No newline at end of file diff --git a/enbsunsprite.tga b/enbsunsprite.tga new file mode 100644 index 0000000..28c4d5f Binary files /dev/null and b/enbsunsprite.tga differ diff --git a/menbnoise1.png b/menbnoise1.png new file mode 100644 index 0000000..2d794f5 Binary files /dev/null and b/menbnoise1.png differ diff --git a/menbnoise2.png b/menbnoise2.png new file mode 100644 index 0000000..fb4bedf Binary files /dev/null and b/menbnoise2.png differ diff --git a/menbnoise3.png b/menbnoise3.png new file mode 100644 index 0000000..3e57ebb Binary files /dev/null and b/menbnoise3.png differ