790 lines
30 KiB
HLSL
790 lines
30 KiB
HLSL
////---------//
|
|
///**Flair**///
|
|
//---------////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//* Lens Flares are based on Blooming HDR Original Code
|
|
//* For Reshade 3.0+
|
|
//* ---------------------------------
|
|
//* Flair
|
|
//* Let's add some ------ to your images.
|
|
//* Flares
|
|
//* Due Diligence
|
|
//* Eye Adaptation
|
|
//* https://knarkowicz.wordpress.com/2016/01/09/automatic-exposure/ Search Ref. Temporal Adaptation
|
|
//* If I miss any please tell me.
|
|
//*
|
|
//* LICENSE
|
|
//* ============
|
|
//* Flare is licenses under: Attribution-NoDerivatives 4.0 International
|
|
//*
|
|
//* You are free to:
|
|
//* Share - copy and redistribute the material in any medium or format
|
|
//* for any purpose, even commercially.
|
|
//* The licensor cannot revoke these freedoms as long as you follow the license terms.
|
|
//* Under the following terms:
|
|
//* Attribution - You must give appropriate credit, provide a link to the license, and indicate if changes were made.
|
|
//* You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
|
|
//*
|
|
//* NoDerivatives - If you remix, transform, or build upon the material, you may not distribute the modified material.
|
|
//*
|
|
//* No additional restrictions - You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
|
|
//*
|
|
//* https://creativecommons.org/licenses/by-nd/4.0/
|
|
//*
|
|
//* Have fun,
|
|
//* Jose Negrete AKA BlueSkyDefender
|
|
//*
|
|
//* https://github.com/BlueSkyDefender/Depth3D
|
|
//* Special thanks to NVIDIA on compatibility with GeForce GPUs and feedback on shader development
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//Shared Texture for Blooming HDR or any other shader that want's to use it.
|
|
texture TexFlareShared { Width = BUFFER_WIDTH; Height = BUFFER_HEIGHT; Format = RGBA16F; };
|
|
|
|
//You can also make a text file named "DisableFlare.txt" to dissable this shader output and
|
|
//only use the Share Texture above in your your shader.
|
|
|
|
uniform int Flare_Type <
|
|
ui_type = "combo";
|
|
ui_items = "Star Full\0Star Half\0Cross +\0Cross x\0Flare +Skew\0Flare -Skew\0Flare Horizontal\0Flare Vertical\0";
|
|
ui_label = "Flare Type";
|
|
ui_category = "Flare Type";
|
|
> = 0;
|
|
|
|
uniform bool Auto_Flare_Intensity <
|
|
ui_label = "Auto Flare Intensity";
|
|
ui_tooltip = "This will enable the shader to adjust Flare Intensity automatically.\n"
|
|
"Auto Bloom Intensity will set Bloom Intensity below.";
|
|
ui_category = "Flare Adjustments";
|
|
> = false;
|
|
|
|
uniform float Flare_Clamp_A <
|
|
ui_type = "slider";
|
|
ui_min = 0.0; ui_max = 1.0;
|
|
ui_label = "Flare Brightness Threshold";
|
|
ui_tooltip = "Use this to set the color based brightness threshold for what is and what isn't allowed.\n"
|
|
"Number 1.0 is default.";
|
|
ui_category = "Flare Adjustments";
|
|
> = 1.0;
|
|
|
|
uniform float Flare_Clamp_B <
|
|
ui_type = "slider";
|
|
ui_min = 0.0; ui_max = 1.0;
|
|
ui_label = "Flare Max Brightness Cutoff";
|
|
ui_tooltip = "Use this to set the max cutoff point of the brightness things in the image.\n"
|
|
"Number 1.0 is default.";
|
|
ui_category = "Flare Adjustments";
|
|
> = 1.0;
|
|
|
|
uniform float Flare_Spread <
|
|
ui_type = "slider";
|
|
ui_min = -1.0; ui_max = 1.0; ui_step = 0.01;
|
|
ui_label = "Flare Spread";
|
|
ui_tooltip = "Use this to adjust Flare size & you can override this.\n"
|
|
"Number 0.5 is default.";
|
|
ui_category = "Flare Adjustments";
|
|
> = 0.5;
|
|
|
|
uniform float Flare_Power <
|
|
ui_type = "slider";
|
|
ui_min = 0.0; ui_max = 12.5; ui_step = 0.125;
|
|
ui_label = "Flare Intensity";
|
|
ui_tooltip = "Use this to set Flare Intensity for your content.\n"
|
|
"Number 1.0 is default.";
|
|
ui_category = "Flare Adjustments";
|
|
> = 1.0;
|
|
|
|
uniform float Flare_Saturation <
|
|
ui_type = "slider";
|
|
ui_min = 0.0; ui_max = 10.0; ui_step = 0.1;
|
|
ui_label = "Flare Saturation";
|
|
ui_tooltip = "Adjustment The amount to adjust the saturation of the flare color.\n"
|
|
"Number 1.0 is default.";
|
|
ui_category = "Flare Adjustments";
|
|
> = 5.0;
|
|
//User_Flare_Color needs Flare_Color_Map to be set to -1 and the rest uncommented.
|
|
uniform int Flare_Color_Map <
|
|
ui_type = "slider";
|
|
ui_min = -1; ui_max = 8;
|
|
ui_label = "Flare Color Map";
|
|
ui_tooltip = "Use this to set MIP levels for the color map used to se Flare Color.\n"
|
|
"This samples color in the general area to achieve this effect.\n"
|
|
"Number 4 is default & Zero is Off.";
|
|
ui_category = "Flare Adjustments";
|
|
> = 4;
|
|
|
|
uniform float3 User_Flare_Color <
|
|
ui_type = "color";
|
|
ui_min = 0.0; ui_max = 1.0;
|
|
ui_label = "Flare Color Adjust";
|
|
ui_tooltip = "Use this to set your own color settings.";
|
|
ui_category = "Flare Adjustments";
|
|
> = float3(1.0,1.0,1.0);
|
|
|
|
uniform float Flare_Localization <
|
|
ui_type = "slider";
|
|
ui_min = -1.0; ui_max = 1.0; ui_step = 0.1;
|
|
ui_label = "Flare Localization";
|
|
ui_tooltip = "This localizes flare to a user selected area.\n"
|
|
"Number Zero is default.";
|
|
ui_category = "Flare Adjustments";
|
|
> = 0.0;
|
|
|
|
uniform int CA_Type <
|
|
ui_type = "combo";
|
|
ui_items = "Off\0Type BD\0Type Box\0Type Hozi\0Type Verti\0";
|
|
ui_label = "Flare CA Type";
|
|
ui_category = "Flare Chromatic Aberration";
|
|
> = 1;
|
|
|
|
uniform float3 Flare_PBD <
|
|
ui_type = "slider";
|
|
ui_min = 0.0; ui_max = 1.0;
|
|
ui_label = "Flare CA Adjust";
|
|
ui_tooltip = "Use this to set chromatic aberration for your content.";
|
|
ui_category = "Flare Chromatic Aberration";
|
|
> = float3(1.0,0.5,0.0);
|
|
|
|
//Depth Map//
|
|
uniform int Depth_Map <
|
|
ui_type = "combo";
|
|
ui_items = "Normal\0Reversed\0";
|
|
ui_label = "Depth Map Adjustment";
|
|
ui_tooltip = "Linearization for the zBuffer also known as Depth Map.\n"
|
|
"DM0 is Z-Normal and DM1 is Z-Reversed.\n";
|
|
ui_category = "Depth Map Masking";
|
|
> = 0;
|
|
|
|
uniform float Depth_Map_Adjust <
|
|
ui_type = "drag";
|
|
ui_min = 0.25; ui_max = 250.0; ui_step = 0.25;
|
|
ui_label = "Depth Map Adjustment";
|
|
ui_tooltip = "This allows for you to adjust the DM precision.\n"
|
|
"Adjust this to keep it as low as possible.\n"
|
|
"Default is 1.5";
|
|
ui_category = "Depth Map Masking";
|
|
> = 1.5;
|
|
|
|
uniform bool Depth_Map_Flip <
|
|
ui_label = "Depth Map Flip";
|
|
ui_tooltip = "Flip the depth map if it is upside down.";
|
|
ui_category = "Depth Map Masking";
|
|
> = false;
|
|
|
|
uniform bool Mask_Sky <
|
|
ui_label = "Sky Mask";
|
|
ui_tooltip = "Mask Sky using depth";
|
|
ui_category = "Depth Map Masking";
|
|
> = false;
|
|
|
|
uniform bool Flair_Falloff <
|
|
ui_label = "Falloff";
|
|
ui_tooltip = "A depth mask is use to add a fall off distance";
|
|
ui_category = "Depth Map Masking";
|
|
> = false;
|
|
|
|
#if __RENDERER__ >= 0x20000 //Vulkan
|
|
#define Rend 1
|
|
#else
|
|
#define Rend 0
|
|
#endif
|
|
/////////////////////////////////////////////////////D3D Starts Here/////////////////////////////////////////////////////////////////
|
|
#define pix float2(BUFFER_RCP_WIDTH, BUFFER_RCP_HEIGHT)
|
|
uniform float timer < source = "timer"; >;
|
|
//Total amount of frames since the game started.
|
|
uniform uint framecount < source = "framecount"; >;
|
|
uniform float frametime < source = "frametime";>;
|
|
//Made Up Values that look nice not correct.
|
|
static const float OffsetA[25] = { 0.0, 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 13.0, 15.0, 17.0, 19.0, 21.0, 23.0, 25.0, 27.0, 29.0, 31.0, 33.0, 35.0, 37.0, 39.0, 41.0, 43.0, 45.0, 47.0 };
|
|
static const float OffsetB[25] = { 0.0, 2.0, 4.0, 6.0, 8.0,10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 30.0, 32.0, 34.0, 36.0, 38.0, 40.0, 42.0, 44.0, 46.0, 48.0 };
|
|
static const float OffsetC[25] = { 0.5, 1.5, 3.5, 5.5, 7.5, 9.5, 11.5, 13.5, 15.5, 17.5, 19.5, 21.5, 23.5, 25.5, 27.5, 29.5, 31.5, 33.5, 35.5, 37.5, 39.5, 41.5, 43.5, 45.5, 47.5 };
|
|
static const float OffsetD[25] = { 0.5, 2.5, 4.5, 6.5, 8.5,10.5, 12.5, 14.5, 16.5, 18.5, 20.5, 22.5, 24.5, 26.5, 28.5, 30.5, 32.5, 34.5, 36.5, 38.5, 40.5, 42.5, 44.5, 46.5, 48.5 };
|
|
static const float Weight[25] = { 0.10761,0.10306,0.09750, 0.09110,0.08409,0.07666,0.06903,0.06139,0.05394,0.04680,0.0401,0.0339,0.0284,0.0234,0.0191,0.0154,0.0122,0.0096,0.0074,0.0057,0.0043,0.0032,0.0024,0.0017,0.0012 };
|
|
#define FS Flare_Spread < 0 ? Flare_Spread * 4.0 : Flare_Spread * 2.2
|
|
#define Flare_Softness 0 //saturate(abs(Flare_Spread)) //Removed because of Opti
|
|
#define Alternate framecount % 2 == 0
|
|
//Eye Adaptation Set from 0 to 1
|
|
static const float Adapt_Seek = 0.5;//Use this to Adjust Eye Adaptation Speed
|
|
static const float Adapt_Adjust = 0.5;//Use this to Adjust Eye Seeking Radius for Average Brightness.
|
|
|
|
float lum(float3 RGB){ return dot(RGB, float3(0.2126, 0.7152, 0.0722) );}
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
texture TexDepthBuffer : DEPTH;
|
|
|
|
texture TexBackBuffer : COLOR;
|
|
|
|
sampler DepthBufferF
|
|
{
|
|
Texture = TexDepthBuffer;
|
|
};
|
|
|
|
sampler BackBufferF
|
|
{
|
|
Texture = TexBackBuffer;
|
|
};
|
|
|
|
texture texFlare { Width = BUFFER_WIDTH * 0.25; Height = BUFFER_HEIGHT * 0.25; Format = RGBA16f; };
|
|
|
|
sampler SamplerGlammor
|
|
{
|
|
Texture = texFlare;
|
|
};
|
|
|
|
texture TexBC { Width = BUFFER_WIDTH * 0.5; Height = BUFFER_HEIGHT * 0.5; Format = RGBA8; };
|
|
|
|
sampler SamplerBC
|
|
{
|
|
Texture = TexBC;
|
|
};
|
|
|
|
texture TexMBB { Width = BUFFER_WIDTH ; Height = BUFFER_HEIGHT ; Format = RGBA8; MipLevels = 8; };
|
|
|
|
sampler SamplerMBB
|
|
{
|
|
Texture = TexMBB;
|
|
MagFilter = POINT;
|
|
MinFilter = POINT;
|
|
MipFilter = POINT;
|
|
};
|
|
|
|
texture TexFlarePast { Width = BUFFER_WIDTH; Height = BUFFER_HEIGHT; Format = RGBA8; };
|
|
|
|
sampler SamplerPastFlare
|
|
{
|
|
Texture = TexFlarePast;
|
|
MagFilter = POINT;
|
|
MinFilter = POINT;
|
|
MipFilter = POINT;
|
|
};
|
|
|
|
void A0(float2 texcoord,float PosX,float PosY,inout float D, inout float E, inout float P, inout float T, inout float H, inout float III, inout float DD )
|
|
{
|
|
float PosXD = -0.035+PosX, offsetD = 0.001;D = all( abs(float2( texcoord.x -PosXD, texcoord.y-PosY)) < float2(0.0025,0.009));D -= all( abs(float2( texcoord.x -PosXD-offsetD, texcoord.y-PosY)) < float2(0.0025,0.007));
|
|
float PosXE = -0.028+PosX, offsetE = 0.0005;E = all( abs(float2( texcoord.x -PosXE, texcoord.y-PosY)) < float2(0.003,0.009));E -= all( abs(float2( texcoord.x -PosXE-offsetE, texcoord.y-PosY)) < float2(0.0025,0.007));E += all( abs(float2( texcoord.x -PosXE, texcoord.y-PosY)) < float2(0.003,0.001));
|
|
float PosXP = -0.0215+PosX, PosYP = -0.0025+PosY, offsetP = 0.001, offsetP1 = 0.002;P = all( abs(float2( texcoord.x -PosXP, texcoord.y-PosYP)) < float2(0.0025,0.009*0.775));P -= all( abs(float2( texcoord.x -PosXP-offsetP, texcoord.y-PosYP)) < float2(0.0025,0.007*0.680));P += all( abs(float2( texcoord.x -PosXP+offsetP1, texcoord.y-PosY)) < float2(0.0005,0.009));
|
|
float PosXT = -0.014+PosX, PosYT = -0.008+PosY;T = all( abs(float2( texcoord.x -PosXT, texcoord.y-PosYT)) < float2(0.003,0.001));T += all( abs(float2( texcoord.x -PosXT, texcoord.y-PosY)) < float2(0.000625,0.009));
|
|
float PosXH = -0.0072+PosX;H = all( abs(float2( texcoord.x -PosXH, texcoord.y-PosY)) < float2(0.002,0.001));H -= all( abs(float2( texcoord.x -PosXH, texcoord.y-PosY)) < float2(0.002,0.009));H += all( abs(float2( texcoord.x -PosXH, texcoord.y-PosY)) < float2(0.00325,0.009));
|
|
float offsetFive = 0.001, PosX3 = -0.001+PosX;III = all( abs(float2( texcoord.x -PosX3, texcoord.y-PosY)) < float2(0.002,0.009));III -= all( abs(float2( texcoord.x -PosX3 - offsetFive, texcoord.y-PosY)) < float2(0.003,0.007));III += all( abs(float2( texcoord.x -PosX3, texcoord.y-PosY)) < float2(0.002,0.001));
|
|
float PosXDD = 0.006+PosX, offsetDD = 0.001;DD = all( abs(float2( texcoord.x -PosXDD, texcoord.y-PosY)) < float2(0.0025,0.009));DD -= all( abs(float2( texcoord.x -PosXDD-offsetDD, texcoord.y-PosY)) < float2(0.0025,0.007));
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
texture texLumF {Width = 256; Height = 256; Format = R16F; MipLevels = 9;}; //Sample at 256x256 map only has nine mip levels; 0-1-2-3-4-5-6-7-8 : 256,128,64,32,16,8,4,2, and 1 (1x1).
|
|
|
|
sampler SamplerLumG
|
|
{
|
|
Texture = texLumF;
|
|
};
|
|
|
|
float LuminanceG(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target
|
|
{
|
|
float2 texXY = texcoord;
|
|
float2 midHV = (Adapt_Seek-1) * float2(BUFFER_WIDTH * 0.5,BUFFER_HEIGHT * 0.5) * pix;
|
|
texcoord = float2((texXY.x*Adapt_Seek)-midHV.x,(texXY.y*Adapt_Seek)-midHV.y);
|
|
return lum(tex2D(BackBufferF,texcoord).rgb);
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
texture texAvgLumF { Width = 256; Height = 256; Format = R16F; };
|
|
|
|
sampler SamplerAvgLumG
|
|
{
|
|
Texture = texAvgLumF;
|
|
};
|
|
|
|
texture TexAvgLumaLastF { Width = BUFFER_WIDTH; Height = BUFFER_HEIGHT; Format = R16F; };
|
|
|
|
sampler SamplerAvgLumaLastG
|
|
{
|
|
Texture = TexAvgLumaLastF;
|
|
};
|
|
|
|
float Average_LuminanceF(float4 pos : SV_Position, float2 texcoord : TEXCOORD) : SV_Target
|
|
{
|
|
float AA = (1-Adapt_Adjust) * 1000, L = tex2Dlod(SamplerLumG,float4(texcoord,0,11)).x, PL = tex2D(SamplerAvgLumaLastG, texcoord).x;
|
|
//Temporal Adaptation
|
|
return PL + (L - PL) * (1.0 - exp(-frametime/AA));
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
float2 DepthMap(float2 texcoord : TEXCOORD0)
|
|
{
|
|
if (Depth_Map_Flip)
|
|
texcoord.y = 1 - texcoord.y;
|
|
|
|
float zBuffer = tex2Dlod(DepthBufferF, float4(texcoord,0,0)).x,Raw; //Depth Buffer
|
|
|
|
//Conversions to linear space.....
|
|
//Near & Far Adjustment
|
|
float Far = 1.0, Near = 0.125/Depth_Map_Adjust,DA = Depth_Map_Adjust*2; //Division Depth Map Adjust - Near
|
|
|
|
float2 Z = float2( zBuffer, 1-zBuffer );
|
|
|
|
if (Depth_Map == 0)//DM0. Normal
|
|
{
|
|
zBuffer = Far * Near / (Far + Z.x * (Near - Far));
|
|
Raw = pow(abs(Z.x),DA);
|
|
}
|
|
else if (Depth_Map == 1)//DM1. Reverse
|
|
{
|
|
zBuffer = Far * Near / (Far + Z.y * (Near - Far));
|
|
Raw = pow(abs(Z.y),DA);
|
|
}
|
|
|
|
return saturate(float2(zBuffer,Raw));
|
|
}
|
|
|
|
float4 BB( float2 texcoord )
|
|
{
|
|
return tex2Dlod(BackBufferF, float4(texcoord,0,0)).rgba;
|
|
}
|
|
|
|
void ColorBB(float4 position : SV_Position, float2 texcoord : TEXCOORD, out float3 MBB : SV_Target)
|
|
{
|
|
MBB = BB( texcoord ).rgb;
|
|
}
|
|
|
|
float4 GBightColors( float2 texcoord )
|
|
{ float DM = smoothstep(0,1,DepthMap(texcoord).x);
|
|
//Forced Depth Masking
|
|
if(DM == 1)
|
|
DM = 1;
|
|
else
|
|
DM = 0;
|
|
|
|
if(!Mask_Sky)
|
|
DM = 0;
|
|
|
|
float4 CM = lerp(tex2Dlod(SamplerMBB,float4(texcoord,0,clamp(Flare_Color_Map,0,8))).rgba,0,DM);
|
|
float4 BC = lerp(BB(texcoord),0,DM);
|
|
// Check whether fragment output is higher than threshold,if so output as brightness color.
|
|
float I_A = lum(BC.rgb), I_B = 1-I_A;
|
|
I_A *= I_B >= 1-Flare_Clamp_B;//Trim from Top
|
|
BC.a = I_A > lerp(0.9,0.999,Flare_Clamp_A);// ? 1 : 0;
|
|
BC.rgb *= BC.a ;
|
|
|
|
if(Flare_Color_Map > 0)
|
|
BC.rgb = CM.rgb * BC.a;
|
|
else if(Flare_Color_Map == -1)
|
|
BC.rgb *= User_Flare_Color;
|
|
|
|
if(Flair_Falloff)
|
|
BC.rgb = lerp(BC.rgb,0.0,DepthMap(texcoord).y);
|
|
|
|
//Bloom Saturation
|
|
BC.rgb = lerp(lum(BC.rgb),BC.rgb,Flare_Saturation);
|
|
|
|
float2 Stored_TC = texcoord, FL;
|
|
if (Flare_Localization != 0)
|
|
{
|
|
Stored_TC *= 1.0 - Stored_TC;
|
|
|
|
float vignette = Stored_TC.x*Stored_TC.y*12.5;
|
|
|
|
if (Flare_Localization < 0)
|
|
FL = float2(0,abs(Flare_Localization));
|
|
else
|
|
FL = float2(abs(Flare_Localization),1);
|
|
|
|
vignette = 1-smoothstep(FL.x,FL.y,vignette);
|
|
|
|
if (Flare_Localization < 0)
|
|
vignette = 1-vignette;
|
|
|
|
BC.rgb = lerp(BC.rgb,0.0,vignette);
|
|
}
|
|
return float4(saturate(BC.rgb),BC.a);
|
|
}
|
|
|
|
void StoredBB(float4 position : SV_Position, float2 texcoord : TEXCOORD, out float3 BC : SV_Target)
|
|
{
|
|
BC = GBightColors( texcoord ).rgb;
|
|
}
|
|
#if !Rend
|
|
//Done this way to reduce TempRegisters for DX9 compatablity.
|
|
float3 Glammor(sampler2D Sample, float2 texcoord, float N, int Switch, float BBS)
|
|
{
|
|
float3 GBloom = Switch ? tex2D(Sample,texcoord).rgb : GBightColors(texcoord).rgb;
|
|
GBloom *= Weight[0];
|
|
[loop]
|
|
for(int i = 1; i < N; ++i)
|
|
{ float4 offset = float4(OffsetA[i] * pix.xy,OffsetB[i] * pix.xy);
|
|
if (Alternate)
|
|
offset = float4(OffsetC[i] * pix.xy,OffsetD[i] * pix.xy);
|
|
//+ & X
|
|
if(Flare_Type == 4 || Flare_Type == 5 || Flare_Type == 6 || Flare_Type == 7)
|
|
{
|
|
float4 XXZZ = float4( offset.x,-offset.x, offset.z,-offset.z);
|
|
float4 YYWW = float4( offset.y,-offset.y, offset.w,-offset.w);
|
|
if(Flare_Type == 5 || Flare_Type == 7)
|
|
XXZZ = Switch ? 0 : float4(-offset.x, offset.x,-offset.z, offset.z);
|
|
if(Flare_Type == 6)
|
|
YYWW = Switch ? 0 : float4( offset.y,-offset.y, offset.w,-offset.w);
|
|
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( XXZZ.x, YYWW.x) * BBS,0,0) ).rgb * Weight[i];
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( XXZZ.y, YYWW.y) * BBS,0,0) ).rgb * Weight[i];
|
|
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( XXZZ.z, YYWW.z) * BBS,0,0) ).rgb * Weight[i];
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( XXZZ.w, YYWW.w) * BBS,0,0) ).rgb * Weight[i];
|
|
}
|
|
else
|
|
{
|
|
float4 YYXX = Switch ? 0 : float4( offset.y,-offset.y,-offset.x, offset.x);
|
|
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( offset.x, YYXX.x) * BBS,0,0) ).rgb * Weight[i];
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2(-offset.x, YYXX.y) * BBS,0,0) ).rgb * Weight[i];
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( YYXX.z, offset.y) * BBS,0,0) ).rgb * Weight[i];
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( YYXX.w,-offset.y) * BBS,0,0) ).rgb * Weight[i];
|
|
|
|
float4 WWZZ = Switch ? 0 : float4( offset.w,-offset.w,-offset.z, offset.z);
|
|
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( offset.z, WWZZ.x) * BBS,0,0) ).rgb * Weight[i];
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2(-offset.z, WWZZ.y) * BBS,0,0) ).rgb * Weight[i];
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( WWZZ.z, offset.w) * BBS,0,0) ).rgb * Weight[i];
|
|
GBloom += tex2Dlod(Sample, float4(texcoord + float2( WWZZ.w,-offset.w) * BBS,0,0) ).rgb * Weight[i];
|
|
}
|
|
|
|
}
|
|
GBloom *= 0.5;
|
|
|
|
return GBloom;
|
|
}
|
|
|
|
float3 GlammorA(float2 texcoord )
|
|
{
|
|
float N, BBS = FS;
|
|
if(Flare_Type == 0 || Flare_Type == 1 || Flare_Type == 2 || Flare_Type == 6 || Flare_Type == 7)
|
|
N = int(lerp(5,25,abs(Flare_Spread)));
|
|
else if(Flare_Type == 3 || Flare_Type == 4 || Flare_Type == 5 )
|
|
N = 1;
|
|
|
|
return Glammor(SamplerBC, texcoord, N, 1, BBS);
|
|
}
|
|
|
|
float3 GlammorB(float2 texcoord )
|
|
{
|
|
float N, BBS = FS;
|
|
if(Flare_Type == 0 || Flare_Type == 1 || Flare_Type == 3 || Flare_Type == 4 || Flare_Type == 5 )
|
|
N = int(lerp(5,25,abs(Flare_Spread)));
|
|
else if(Flare_Type == 2 || Flare_Type == 6 || Flare_Type == 7 )
|
|
N = 1;
|
|
|
|
if(Flare_Type == 1)
|
|
BBS *= 0.5;
|
|
|
|
return Glammor(SamplerBC, texcoord, N, 0, BBS);
|
|
}
|
|
#else
|
|
float3 GlammorA(float2 texcoord )
|
|
{ float3 GBloom = tex2D(SamplerBC,texcoord).rgb;
|
|
float N, BBS = FS;
|
|
GBloom *= Weight[0];
|
|
if(Flare_Type == 0 || Flare_Type == 1 || Flare_Type == 2 || Flare_Type == 6 || Flare_Type == 7)
|
|
N = 25;
|
|
else if(Flare_Type == 3 || Flare_Type == 4 || Flare_Type == 5 )
|
|
N = 1;
|
|
|
|
[unroll]
|
|
for(int i = 1; i < N; ++i)
|
|
{ float4 offset = float4(OffsetA[i] * pix.xy,OffsetB[i] * pix.xy);
|
|
if (Alternate)
|
|
offset = float4(OffsetC[i] * pix.xy,OffsetD[i] * pix.xy);
|
|
//+
|
|
if(Flare_Type == 6)
|
|
{
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.x, 0) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.x, 0) * BBS ).rgb * Weight[i];
|
|
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.z, 0) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.z, 0) * BBS ).rgb * Weight[i];
|
|
}
|
|
else if(Flare_Type == 7)
|
|
{
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( 0, offset.y) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( 0,-offset.y) * BBS ).rgb * Weight[i];
|
|
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( 0, offset.w) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( 0,-offset.w) * BBS ).rgb * Weight[i];
|
|
}
|
|
else
|
|
{
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.x, 0) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.x, 0) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( 0, offset.y) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( 0,-offset.y) * BBS ).rgb * Weight[i];
|
|
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.z, 0) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.z, 0) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( 0, offset.w) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( 0,-offset.w) * BBS ).rgb * Weight[i];
|
|
}
|
|
}
|
|
GBloom *= 0.5;
|
|
|
|
return GBloom;
|
|
}
|
|
|
|
float3 GlammorB(float2 texcoord )
|
|
{ float3 GBloom = GBightColors(texcoord).rgb;
|
|
float N, BBS = FS;
|
|
GBloom *= Weight[0];
|
|
if(Flare_Type == 0 || Flare_Type == 1 || Flare_Type == 3 || Flare_Type == 4 || Flare_Type == 5 )
|
|
N = 25;
|
|
else if(Flare_Type == 2 || Flare_Type == 6 || Flare_Type == 7 )
|
|
N = 1;
|
|
|
|
if(Flare_Type == 1)
|
|
BBS *= 0.5;
|
|
|
|
[unroll]
|
|
for(int i = 1; i < N; ++i)
|
|
{ float4 offset = float4(OffsetA[i] * pix.xy,OffsetB[i] * pix.xy);
|
|
if (Alternate)
|
|
offset = float4(OffsetC[i] * pix.xy,OffsetD[i] * pix.xy);
|
|
//X
|
|
if(Flare_Type == 4)
|
|
{
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.x, offset.y) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.x,-offset.y) * BBS ).rgb * Weight[i];
|
|
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.z, offset.w) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.z,-offset.w) * BBS ).rgb * Weight[i];
|
|
}
|
|
else if(Flare_Type == 5)
|
|
{
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.x, offset.y) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.x,-offset.y) * BBS ).rgb * Weight[i];
|
|
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.z, offset.w) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.z,-offset.w) * BBS ).rgb * Weight[i];
|
|
}
|
|
else
|
|
{
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.x, offset.y) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.x,-offset.y) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.x, offset.y) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.x,-offset.y) * BBS ).rgb * Weight[i];
|
|
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.z, offset.w) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.z,-offset.w) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2(-offset.z, offset.w) * BBS ).rgb * Weight[i];
|
|
GBloom += tex2D(SamplerBC, texcoord + float2( offset.z,-offset.w) * BBS ).rgb * Weight[i];
|
|
}
|
|
}
|
|
GBloom *= 0.5;
|
|
|
|
return GBloom;
|
|
}
|
|
#endif
|
|
|
|
// Spread the blur a bit more.
|
|
void Glammor(float4 position : SV_Position, float2 texcoord : TEXCOORD, out float3 GBloom : SV_Target)
|
|
{ GBloom = 0;
|
|
float GI = Flare_Power, AL = smoothstep(0,1,1. - tex2D(SamplerAvgLumG,0.0).x);
|
|
if(Auto_Flare_Intensity)
|
|
GI *= AL;
|
|
GBloom = ( GlammorA(texcoord) + GlammorB(texcoord) ) * GI;
|
|
}
|
|
|
|
float2 BD(float2 p, float k1) //Polynomial Lens
|
|
{
|
|
if(!CA_Type == 1)
|
|
discard;
|
|
p *= 0.5 + 0.5;//Center
|
|
// Normalize the u,v coordinates in the range [-1;+1]
|
|
p = (2.0f * p - 1.0f) / 1.0f;
|
|
// Calculate l2 norm
|
|
float r2 = p.x*p.x + p.y*p.y;
|
|
float r4 = pow(r2,2);
|
|
// Forward transform
|
|
float x2 = p.x * (1.0 + k1 * r2);
|
|
float y2 = p.y * (1.0 + k1 * r2);
|
|
// De-normalize to the original range
|
|
p.x = (x2 + 1.0) * 1.0 / 2.0;
|
|
p.y = (y2 + 1.0) * 1.0 / 2.0;
|
|
|
|
return p;
|
|
}
|
|
|
|
float2 HVP(float2 texcoord, float k1)
|
|
{
|
|
if(!CA_Type == 2)
|
|
discard;
|
|
float X = k1;
|
|
float Y = k1;
|
|
float midW = (X - 1)*(BUFFER_WIDTH*0.5)*pix.x;
|
|
float midH = (Y - 1)*(BUFFER_HEIGHT*0.5)*pix.y;
|
|
|
|
return float2((texcoord.x*X)-midW,(texcoord.y*Y)-midH);
|
|
}
|
|
|
|
float2 HP(float2 texcoord, float k1)
|
|
{
|
|
if(!CA_Type == 3)
|
|
discard;
|
|
float X = k1;
|
|
float Y = 1;
|
|
float midW = (X - 1)*(BUFFER_WIDTH*0.5)*pix.x;
|
|
float midH = (Y - 1)*(BUFFER_HEIGHT*0.5)*pix.y;
|
|
|
|
return float2((texcoord.x*X)-midW,(texcoord.y*Y)-midH);
|
|
}
|
|
|
|
float2 VP(float2 texcoord, float k1)
|
|
{
|
|
if(!CA_Type == 4)
|
|
discard;
|
|
float X = 1;
|
|
float Y = k1;
|
|
float midW = (X - 1)*(BUFFER_WIDTH*0.5)*pix.x;
|
|
float midH = (Y - 1)*(BUFFER_HEIGHT*0.5)*pix.y;
|
|
|
|
return float2((texcoord.x*X)-midW,(texcoord.y*Y)-midH);
|
|
}
|
|
|
|
float3 CAFlare(float2 texcoord)
|
|
{
|
|
float2 uv_red, uv_green, uv_blue;
|
|
float DM, color_red, color_green, color_blue, K1_Red = Flare_PBD.x , K1_Green = Flare_PBD.y , K1_Blue = Flare_PBD.z ;
|
|
if(CA_Type == 1)
|
|
{
|
|
uv_red = BD(texcoord.xy,K1_Red * 0.03);
|
|
uv_green = BD(texcoord.xy,K1_Green * 0.03);
|
|
uv_blue = BD(texcoord.xy,K1_Blue * 0.03);
|
|
}
|
|
else if(CA_Type == 2)
|
|
{
|
|
uv_red = HVP(texcoord.xy,1-K1_Red * 0.025);
|
|
uv_green = HVP(texcoord.xy,1-K1_Green * 0.025);
|
|
uv_blue = HVP(texcoord.xy,1-K1_Blue * 0.025);
|
|
}
|
|
else if(CA_Type == 3)
|
|
{
|
|
uv_red = HP(texcoord.xy,1-K1_Red * 0.025);
|
|
uv_green = HP(texcoord.xy,1-K1_Green * 0.025);
|
|
uv_blue = HP(texcoord.xy,1-K1_Blue * 0.025);
|
|
}
|
|
else if(CA_Type == 4)
|
|
{
|
|
uv_red = VP(texcoord.xy,1-K1_Red * 0.025);
|
|
uv_green = VP(texcoord.xy,1-K1_Green * 0.025);
|
|
uv_blue = VP(texcoord.xy,1-K1_Blue * 0.025);
|
|
}
|
|
|
|
if(CA_Type > 0)
|
|
{
|
|
color_red = tex2Dlod(SamplerGlammor,float4(uv_red,0,Flare_Softness)).r;
|
|
color_green = tex2Dlod(SamplerGlammor,float4(uv_green,0,Flare_Softness)).g;
|
|
color_blue = tex2Dlod(SamplerGlammor,float4(uv_blue,0,Flare_Softness)).b;
|
|
}
|
|
else
|
|
{
|
|
color_red = tex2Dlod(SamplerGlammor,float4(texcoord,0,Flare_Softness)).r;
|
|
color_green = tex2Dlod(SamplerGlammor,float4(texcoord,0,Flare_Softness)).g;
|
|
color_blue = tex2Dlod(SamplerGlammor,float4(texcoord,0,Flare_Softness)).b;
|
|
}
|
|
|
|
return float3(color_red,color_green,color_blue);
|
|
}
|
|
|
|
void PS_StoreAvgLumaF(float4 position : SV_Position, float2 texcoord : TEXCOORD, out float Stored : SV_Target0, out float3 Shared : SV_Target1)
|
|
{
|
|
Stored = tex2D(SamplerAvgLumG,texcoord).x;
|
|
Shared = (CAFlare(texcoord) + tex2D(SamplerPastFlare,texcoord).rgb) ;
|
|
}
|
|
|
|
float3 ShaderGlammor(float2 texcoord)
|
|
{ float DM;
|
|
float3 Color = BB(texcoord).rgb, FBloom = (CAFlare(texcoord) + tex2D(SamplerPastFlare,texcoord).rgb) ;
|
|
//Gamma Correction
|
|
Color = pow(abs(Color),2.2);
|
|
|
|
//Bloom
|
|
Color = Color + FBloom;
|
|
|
|
Color = pow(abs(Color),rcp(2.2));
|
|
|
|
return Color;
|
|
}
|
|
|
|
void Past_Flare(float4 position : SV_Position, float2 texcoord : TEXCOORD, out float3 Stored : SV_Target)
|
|
{
|
|
Stored = CAFlare(texcoord);
|
|
}
|
|
|
|
void A1(float2 texcoord,float PosX,float PosY,inout float I, inout float N, inout float F, inout float O)
|
|
{
|
|
float PosXI = 0.0155+PosX, PosYI = 0.004+PosY, PosYII = 0.008+PosY;I = all( abs(float2( texcoord.x - PosXI, texcoord.y - PosY)) < float2(0.003,0.001));I += all( abs(float2( texcoord.x - PosXI, texcoord.y - PosYI)) < float2(0.000625,0.005));I += all( abs(float2( texcoord.x - PosXI, texcoord.y - PosYII)) < float2(0.003,0.001));
|
|
float PosXN = 0.0225+PosX, PosYN = 0.005+PosY,offsetN = -0.001;N = all( abs(float2( texcoord.x - PosXN, texcoord.y - PosYN)) < float2(0.002,0.004));N -= all( abs(float2( texcoord.x - PosXN, texcoord.y - PosYN - offsetN)) < float2(0.003,0.005));
|
|
float PosXF = 0.029+PosX, PosYF = 0.004+PosY, offsetF = 0.0005, offsetF1 = 0.001;F = all( abs(float2( texcoord.x -PosXF-offsetF, texcoord.y-PosYF-offsetF1)) < float2(0.002,0.004));F -= all( abs(float2( texcoord.x -PosXF, texcoord.y-PosYF)) < float2(0.0025,0.005));F += all( abs(float2( texcoord.x -PosXF, texcoord.y-PosYF)) < float2(0.0015,0.00075));
|
|
float PosXO = 0.035+PosX, PosYO = 0.004+PosY;O = all( abs(float2( texcoord.x -PosXO, texcoord.y-PosYO)) < float2(0.003,0.005));O -= all( abs(float2( texcoord.x -PosXO, texcoord.y-PosYO)) < float2(0.002,0.003));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////Watermark/////////////////////////////////////////////////////////////////////////
|
|
float4 OutF(float4 position : SV_Position, float2 texcoord : TEXCOORD) : SV_Target
|
|
{
|
|
float3 Color = ShaderGlammor(texcoord).rgb;
|
|
float PosX = 0.9525f*BUFFER_WIDTH*pix.x,PosY = 0.975f*BUFFER_HEIGHT*pix.y,A,B,C,D,E,F,G,H,I,J,K,L,PosXDot = 0.011+PosX, PosYDot = 0.008+PosY;L = all( abs(float2( texcoord.x -PosXDot, texcoord.y-PosYDot)) < float2(0.00075,0.0015));A0(texcoord,PosX,PosY,A,B,C,D,E,F,G );A1(texcoord,PosX,PosY,H,I,J,K);
|
|
return timer <= 12500 ? A+B+C+D+E+F+G+H+I+J+K+L ? 0.02 : float4(Color,1.) : float4(Color,1.);
|
|
}
|
|
///////////////////////////////////////////////////////////////////ReShade.fxh//////////////////////////////////////////////////////////////////////
|
|
void PostProcessVS(in uint id : SV_VertexID, out float4 position : SV_Position, out float2 texcoord : TEXCOORD)
|
|
{// Vertex shader generating a triangle covering the entire screen
|
|
texcoord.x = (id == 2) ? 2.0 : 0.0;
|
|
texcoord.y = (id == 1) ? 2.0 : 0.0;
|
|
position = float4(texcoord * float2(2.0, -2.0) + float2(-1.0, 1.0), 0.0, 1.0);
|
|
}//Using this to make it portable
|
|
//*Rendering passes*//
|
|
technique Flair
|
|
{
|
|
pass ColorMap
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = ColorBB;
|
|
RenderTarget = TexMBB;
|
|
}
|
|
pass Past
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = Past_Flare;
|
|
RenderTarget = TexFlarePast;
|
|
}
|
|
pass BrigthColors
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = StoredBB;
|
|
RenderTarget = TexBC;
|
|
}
|
|
pass Star
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = Glammor;
|
|
RenderTarget = texFlare;
|
|
}
|
|
pass Lum
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = LuminanceG;
|
|
RenderTarget = texLumF;
|
|
}
|
|
pass Avg_Lum
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = Average_LuminanceF;
|
|
RenderTarget = texAvgLumF;
|
|
}
|
|
pass StoreAvgLuma
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = PS_StoreAvgLumaF;
|
|
RenderTarget0 = TexAvgLumaLastF;
|
|
RenderTarget1 = TexFlareShared;
|
|
}
|
|
#if !exists "DisableFlare.txt"
|
|
pass FlareOut
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = OutF;
|
|
}
|
|
#endif
|
|
}
|