diff --git a/data/resources/shaders/reshade/Shaders/anti-aliasing/aa-shader-4.0.fx b/data/resources/shaders/reshade/Shaders/anti-aliasing/aa-shader-4.0.fx new file mode 100644 index 000000000..b0a77ce2a --- /dev/null +++ b/data/resources/shaders/reshade/Shaders/anti-aliasing/aa-shader-4.0.fx @@ -0,0 +1,104 @@ +#include "ReShade.fxh" + +/* + Copyright (C) 2016 guest(r) - guest.r@gmail.com + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +*/ + +uniform float2 NormalizedNativePixelSize < source = "normalized_native_pixel_size"; >; + +sampler2D sBackBuffer{Texture=ReShade::BackBufferTex;AddressU=CLAMP;AddressV=CLAMP;AddressW=CLAMP;MagFilter=POINT;MinFilter=POINT;}; + +static const float3 dt = float3(1.0,1.0,1.0); + +float3 texture2d(sampler2D tex, float2 coord, float4 yx) { + + float3 s00 = tex2D(tex, coord + yx.zw).xyz; + float3 s20 = tex2D(tex, coord + yx.xw).xyz; + float3 s22 = tex2D(tex, coord + yx.xy).xyz; + float3 s02 = tex2D(tex, coord + yx.zy).xyz; + + float m1=dot(abs(s00-s22),dt)+0.001; + float m2=dot(abs(s02-s20),dt)+0.001; + + return 0.5*(m2*(s00+s22)+m1*(s02+s20))/(m1+m2); +} + + + +float4 PS_aa_shader_40(float4 vpos: SV_Position, float2 vTexCoord : TEXCOORD0) : SV_Target +{ + // Calculating texel coordinates + float2 size = 4.0 / NormalizedNativePixelSize; + float2 inv_size = 1.0 / size; + + float4 yx = float4(inv_size, -inv_size); + + float2 OGL2Pos = vTexCoord * size; + + float2 fp = frac(OGL2Pos); + float2 dx = float2(inv_size.x,0.0); + float2 dy = float2(0.0, inv_size.y); + float2 g1 = float2(inv_size.x,inv_size.y); + float2 g2 = float2(-inv_size.x,inv_size.y); + + float2 pC4 = floor(OGL2Pos) * 1.0001 * inv_size; + + // Reading the texels + float3 C1 = texture2d(sBackBuffer, pC4 - dy, yx); + float3 C0 = texture2d(sBackBuffer, pC4 - g1, yx); + float3 C2 = texture2d(sBackBuffer, pC4 - g2, yx); + float3 C3 = texture2d(sBackBuffer, pC4 - dx, yx); + float3 C4 = texture2d(sBackBuffer, pC4 , yx); + float3 C5 = texture2d(sBackBuffer, pC4 + dx, yx); + float3 C6 = texture2d(sBackBuffer, pC4 + g2, yx); + float3 C7 = texture2d(sBackBuffer, pC4 + dy, yx); + float3 C8 = texture2d(sBackBuffer, pC4 + g1, yx); + + float3 ul, ur, dl, dr; + float m1, m2; + + m1 = dot(abs(C0-C4),dt)+0.001; + m2 = dot(abs(C1-C3),dt)+0.001; + ul = (m2*(C0+C4)+m1*(C1+C3))/(m1+m2); + + m1 = dot(abs(C1-C5),dt)+0.001; + m2 = dot(abs(C2-C4),dt)+0.001; + ur = (m2*(C1+C5)+m1*(C2+C4))/(m1+m2); + + m1 = dot(abs(C3-C7),dt)+0.001; + m2 = dot(abs(C6-C4),dt)+0.001; + dl = (m2*(C3+C7)+m1*(C6+C4))/(m1+m2); + + m1 = dot(abs(C4-C8),dt)+0.001; + m2 = dot(abs(C5-C7),dt)+0.001; + dr = (m2*(C4+C8)+m1*(C5+C7))/(m1+m2); + + float3 c11 = 0.5*((dr*fp.x+dl*(1-fp.x))*fp.y+(ur*fp.x+ul*(1-fp.x))*(1-fp.y) ); + + return float4(c11, 1.0); +} + + + +technique aa_shader_40 +{ + pass + { + VertexShader = PostProcessVS; + PixelShader = PS_aa_shader_40; + } +} diff --git a/data/resources/shaders/reshade/Shaders/anti-aliasing/fxaa.fx b/data/resources/shaders/reshade/Shaders/anti-aliasing/fxaa.fx new file mode 100644 index 000000000..2b2244d72 --- /dev/null +++ b/data/resources/shaders/reshade/Shaders/anti-aliasing/fxaa.fx @@ -0,0 +1,271 @@ +#include "ReShade.fxh" + + +/** + * @license + * Copyright (c) 2011 NVIDIA Corporation. All rights reserved. + * + * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED + * *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS + * OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT,IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA + * OR ITS SUPPLIERS BE LIABLE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT, OR + * CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS + * OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY + * OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, + * EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + */ + +/* +FXAA_PRESET - Choose compile-in knob preset 0-5. +------------------------------------------------------------------------------ +FXAA_EDGE_THRESHOLD - The minimum amount of local contrast required + to apply algorithm. + 1.0/3.0 - too little + 1.0/4.0 - good start + 1.0/8.0 - applies to more edges + 1.0/16.0 - overkill +------------------------------------------------------------------------------ +FXAA_EDGE_THRESHOLD_MIN - Trims the algorithm from processing darks. + Perf optimization. + 1.0/32.0 - visible limit (smaller isn't visible) + 1.0/16.0 - good compromise + 1.0/12.0 - upper limit (seeing artifacts) +------------------------------------------------------------------------------ +FXAA_SEARCH_STEPS - Maximum number of search steps for end of span. +------------------------------------------------------------------------------ +FXAA_SEARCH_THRESHOLD - Controls when to stop searching. + 1.0/4.0 - seems to be the best quality wise +------------------------------------------------------------------------------ +FXAA_SUBPIX_TRIM - Controls sub-pixel aliasing removal. + 1.0/2.0 - low removal + 1.0/3.0 - medium removal + 1.0/4.0 - default removal + 1.0/8.0 - high removal + 0.0 - complete removal +------------------------------------------------------------------------------ +FXAA_SUBPIX_CAP - Insures fine detail is not completely removed. + This is important for the transition of sub-pixel detail, + like fences and wires. + 3.0/4.0 - default (medium amount of filtering) + 7.0/8.0 - high amount of filtering + 1.0 - no capping of sub-pixel aliasing removal +*/ + + +uniform float2 BufferToViewportRatio < source = "buffer_to_viewport_ratio"; >; +uniform float2 ViewportSize < source = "viewportsize"; >; + +sampler2D sBackBuffer{Texture=ReShade::BackBufferTex;AddressU=CLAMP;AddressV=CLAMP;AddressW=CLAMP;MagFilter=LINEAR;MinFilter=LINEAR;}; + + +#ifndef FXAA_PRESET + #define FXAA_PRESET 6 +#endif +#if (FXAA_PRESET == 3) + #define FXAA_EDGE_THRESHOLD (1.0/8.0) + #define FXAA_EDGE_THRESHOLD_MIN (1.0/16.0) + #define FXAA_SEARCH_STEPS 16 + #define FXAA_SEARCH_THRESHOLD (1.0/4.0) + #define FXAA_SUBPIX_CAP (3.0/4.0) + #define FXAA_SUBPIX_TRIM (1.0/4.0) +#endif +#if (FXAA_PRESET == 4) + #define FXAA_EDGE_THRESHOLD (1.0/8.0) + #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) + #define FXAA_SEARCH_STEPS 24 + #define FXAA_SEARCH_THRESHOLD (1.0/4.0) + #define FXAA_SUBPIX_CAP (3.0/4.0) + #define FXAA_SUBPIX_TRIM (1.0/4.0) +#endif +#if (FXAA_PRESET == 5) + #define FXAA_EDGE_THRESHOLD (1.0/8.0) + #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) + #define FXAA_SEARCH_STEPS 32 + #define FXAA_SEARCH_THRESHOLD (1.0/4.0) + #define FXAA_SUBPIX_CAP (3.0/4.0) + #define FXAA_SUBPIX_TRIM (1.0/4.0) +#endif +#if (FXAA_PRESET == 6) + #define FXAA_EDGE_THRESHOLD (1.0/8.0) + #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) + #define FXAA_SEARCH_STEPS 32 + #define FXAA_SEARCH_THRESHOLD (1.0/4.0) + #define FXAA_SUBPIX_CAP (1.0) + #define FXAA_SUBPIX_TRIM (0.0) +#endif + +#define FXAA_SUBPIX_TRIM_SCALE (1.0/(1.0 - FXAA_SUBPIX_TRIM)) + +// Return the luma, the estimation of luminance from rgb inputs. +// This approximates luma using one FMA instruction, +// skipping normalization and tossing out blue. +// FxaaLuma() will range 0.0 to 2.963210702. +float FxaaLuma(float3 rgb) { + return rgb.y * (0.587/0.299) + rgb.x; +} + +float3 FxaaLerp3(float3 a, float3 b, float amountOfA) { + return (-float3(amountOfA, amountOfA, amountOfA) * b) + ((a * float3(amountOfA, amountOfA, amountOfA)) + b); +} + +float4 FxaaTexOff(sampler2D tex, float2 pos, int2 off, float2 rcpFrame) { + float x = pos.x + float(off.x) * rcpFrame.x; + float y = pos.y + float(off.y) * rcpFrame.y; + return tex2D(tex, float2(x, y)); +} + +// pos is the output of FxaaVertexShader interpolated across screen. +// xy -> actual texture position {0.0 to 1.0} +// rcpFrame should be a uniform equal to {1.0/frameWidth, 1.0/frameHeight} +float3 FxaaPixelShader(float2 pos, sampler2D tex, float2 rcpFrame) +{ + float3 rgbN = FxaaTexOff(tex, pos.xy, int2( 0,-1), rcpFrame).xyz; + float3 rgbW = FxaaTexOff(tex, pos.xy, int2(-1, 0), rcpFrame).xyz; + float3 rgbM = FxaaTexOff(tex, pos.xy, int2( 0, 0), rcpFrame).xyz; + float3 rgbE = FxaaTexOff(tex, pos.xy, int2( 1, 0), rcpFrame).xyz; + float3 rgbS = FxaaTexOff(tex, pos.xy, int2( 0, 1), rcpFrame).xyz; + + float lumaN = FxaaLuma(rgbN); + float lumaW = FxaaLuma(rgbW); + float lumaM = FxaaLuma(rgbM); + float lumaE = FxaaLuma(rgbE); + float lumaS = FxaaLuma(rgbS); + float rangeMin = min(lumaM, min(min(lumaN, lumaW), min(lumaS, lumaE))); + float rangeMax = max(lumaM, max(max(lumaN, lumaW), max(lumaS, lumaE))); + + float range = rangeMax - rangeMin; + if(range < max(FXAA_EDGE_THRESHOLD_MIN, rangeMax * FXAA_EDGE_THRESHOLD)) + { + return rgbM; + } + + float3 rgbL = rgbN + rgbW + rgbM + rgbE + rgbS; + + float lumaL = (lumaN + lumaW + lumaE + lumaS) * 0.25; + float rangeL = abs(lumaL - lumaM); + float blendL = max(0.0, (rangeL / range) - FXAA_SUBPIX_TRIM) * FXAA_SUBPIX_TRIM_SCALE; + blendL = min(FXAA_SUBPIX_CAP, blendL); + + float3 rgbNW = FxaaTexOff(tex, pos.xy, int2(-1,-1), rcpFrame).xyz; + float3 rgbNE = FxaaTexOff(tex, pos.xy, int2( 1,-1), rcpFrame).xyz; + float3 rgbSW = FxaaTexOff(tex, pos.xy, int2(-1, 1), rcpFrame).xyz; + float3 rgbSE = FxaaTexOff(tex, pos.xy, int2( 1, 1), rcpFrame).xyz; + rgbL += (rgbNW + rgbNE + rgbSW + rgbSE); + rgbL *= (1.0/float3(9.0, 9.0, 9.0)); + + float lumaNW = FxaaLuma(rgbNW); + float lumaNE = FxaaLuma(rgbNE); + float lumaSW = FxaaLuma(rgbSW); + float lumaSE = FxaaLuma(rgbSE); + + float edgeVert = + abs((0.25 * lumaNW) + (-0.5 * lumaN) + (0.25 * lumaNE)) + + abs((0.50 * lumaW ) + (-1.0 * lumaM) + (0.50 * lumaE )) + + abs((0.25 * lumaSW) + (-0.5 * lumaS) + (0.25 * lumaSE)); + float edgeHorz = + abs((0.25 * lumaNW) + (-0.5 * lumaW) + (0.25 * lumaSW)) + + abs((0.50 * lumaN ) + (-1.0 * lumaM) + (0.50 * lumaS )) + + abs((0.25 * lumaNE) + (-0.5 * lumaE) + (0.25 * lumaSE)); + + bool horzSpan = edgeHorz >= edgeVert; + float lengthSign = horzSpan ? -rcpFrame.y : -rcpFrame.x; + + if(!horzSpan) + { + lumaN = lumaW; + lumaS = lumaE; + } + + float gradientN = abs(lumaN - lumaM); + float gradientS = abs(lumaS - lumaM); + lumaN = (lumaN + lumaM) * 0.5; + lumaS = (lumaS + lumaM) * 0.5; + + if (gradientN < gradientS) + { + lumaN = lumaS; + lumaN = lumaS; + gradientN = gradientS; + lengthSign *= -1.0; + } + + float2 posN; + posN.x = pos.x + (horzSpan ? 0.0 : lengthSign * 0.5); + posN.y = pos.y + (horzSpan ? lengthSign * 0.5 : 0.0); + + gradientN *= FXAA_SEARCH_THRESHOLD; + + float2 posP = posN; + float2 offNP = horzSpan ? float2(rcpFrame.x, 0.0) : float2(0.0, rcpFrame.y); + float lumaEndN = lumaN; + float lumaEndP = lumaN; + bool doneN = false; + bool doneP = false; + posN += offNP * float2(-1.0, -1.0); + posP += offNP * float2( 1.0, 1.0); + + for(int i = 0; i < FXAA_SEARCH_STEPS; i++) { + if(!doneN) + { + lumaEndN = FxaaLuma(tex2D(tex, posN.xy).xyz); + } + if(!doneP) + { + lumaEndP = FxaaLuma(tex2D(tex, posP.xy).xyz); + } + + doneN = doneN || (abs(lumaEndN - lumaN) >= gradientN); + doneP = doneP || (abs(lumaEndP - lumaN) >= gradientN); + + if(doneN && doneP) + { + break; + } + if(!doneN) + { + posN -= offNP; + } + if(!doneP) + { + posP += offNP; + } + } + + float dstN = horzSpan ? pos.x - posN.x : pos.y - posN.y; + float dstP = horzSpan ? posP.x - pos.x : posP.y - pos.y; + bool directionN = dstN < dstP; + lumaEndN = directionN ? lumaEndN : lumaEndP; + + if(((lumaM - lumaN) < 0.0) == ((lumaEndN - lumaN) < 0.0)) + { + lengthSign = 0.0; + } + + + float spanLength = (dstP + dstN); + dstN = directionN ? dstN : dstP; + float subPixelOffset = (0.5 + (dstN * (-1.0/spanLength))) * lengthSign; + float3 rgbF = tex2D(tex, float2( + pos.x + (horzSpan ? 0.0 : subPixelOffset), + pos.y + (horzSpan ? subPixelOffset : 0.0))).xyz; + return FxaaLerp3(rgbL, rgbF, blendL); +} + +float4 PS_FXAA(float4 vpos: SV_Position, float2 vTexCoord : TEXCOORD0) : SV_Target +{ + float3 color = FxaaPixelShader(vTexCoord, sBackBuffer, 1.0 / (ViewportSize*BufferToViewportRatio)); + + return float4(color, 1.0); +} + + + +technique FXAA +{ + pass + { + VertexShader = PostProcessVS; + PixelShader = PS_FXAA; + } +} diff --git a/data/resources/shaders/reshade/Shaders/crt/crt-geom.fx b/data/resources/shaders/reshade/Shaders/crt/crt-geom.fx index a1d050ef0..01f159c25 100644 --- a/data/resources/shaders/reshade/Shaders/crt/crt-geom.fx +++ b/data/resources/shaders/reshade/Shaders/crt/crt-geom.fx @@ -183,6 +183,7 @@ uniform float2 NormalizedNativePixelSize < source = "normalized_native_pixel_siz uniform float UpscaleMultiplier < source = "upscale_multiplier"; >; uniform float2 ViewportSize < source = "viewportsize"; >; +sampler2D sBackBuffer{Texture=ReShade::BackBufferTex;AddressU=BORDER;AddressV=BORDER;AddressW=BORDER;MagFilter=POINT;MinFilter=POINT;}; // Comment the next line to disable interpolation in linear gamma (and // gain speed). @@ -199,9 +200,9 @@ uniform float2 ViewportSize < source = "viewportsize"; >; #define PI 3.141592653589 #ifdef LINEAR_PROCESSING -# define TEX2D(c) pow(tex2D(ReShade::BackBuffer, (c)), float4(CRTgamma,CRTgamma,CRTgamma,CRTgamma)) +# define TEX2D(c) pow(tex2D(sBackBuffer, (c)), float4(CRTgamma,CRTgamma,CRTgamma,CRTgamma)) #else -# define TEX2D(c) tex2D(ReShade::BackBuffer, (c)) +# define TEX2D(c) tex2D(sBackBuffer, (c)) #endif // aspect ratio diff --git a/data/resources/shaders/reshade/Shaders/denoisers/bilateral.fx b/data/resources/shaders/reshade/Shaders/denoisers/bilateral.fx new file mode 100644 index 000000000..6063dba0e --- /dev/null +++ b/data/resources/shaders/reshade/Shaders/denoisers/bilateral.fx @@ -0,0 +1,166 @@ +#include "ReShade.fxh" + +/* + Bilateral - Smart + + Copyright (C) 2024 guest(r) + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ + + +uniform float FRANGE < + ui_type = "drag"; + ui_min = 1.0; + ui_max = 10.0; + ui_step = 1.0; + ui_label = "Filter Range"; +> = 5.0; + +uniform float FBSMOOTH < + ui_type = "drag"; + ui_min = 0.05; + ui_max = 1.0; + ui_step = 0.025; + ui_label = "Filter Base Smoothing"; +> = 0.3; + +uniform float FSIGMA < + ui_type = "drag"; + ui_min = 0.15; + ui_max = 1.5; + ui_step = 0.05; + ui_label = "Filter Strength"; +> = 1.0; + +uniform float2 NormalizedNativePixelSize < source = "normalized_native_pixel_size"; >; +uniform float2 BufferToViewportRatio < source = "buffer_to_viewport_ratio"; >; +uniform float2 ViewportSize < source = "viewportsize"; >; + +sampler2D sBackBuffer{Texture=ReShade::BackBufferTex;AddressU=CLAMP;AddressV=CLAMP;AddressW=CLAMP;MagFilter=POINT;MinFilter=POINT;}; + +texture2D tBilateral_P0{Width=BUFFER_WIDTH;Height=BUFFER_HEIGHT;Format=RGBA8;}; +sampler2D sBilateral_P0{Texture=tBilateral_P0;AddressU=CLAMP;AddressV=CLAMP;AddressW=CLAMP;MagFilter=POINT;MinFilter=POINT;}; + +#define FSIGMA1 (1.0/FSIGMA) + +#define COMPAT_TEXTURE(c,d) tex2D(c,d) + +float wt(float3 A, float3 B) +{ + return clamp(FBSMOOTH - 2.33*dot(abs(A-B),1.0.xxx)/(dot(A+B,1.0.xxx)+1.0), 0.0, 0.25); +} + + +float getw(float x, float3 c, float3 p) +{ + float y = pow(max(1.0-x,0.0), FSIGMA1); + float d = wt(c,p); + return y*d; +} + + + +float4 PS_Bilateral_X(float4 position: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target +{ + float4 SourceSize = float4((ViewportSize*BufferToViewportRatio), 1.0/(ViewportSize*BufferToViewportRatio)); +// float4 SourceSize = float4(1.0/NormalizedNativePixelSize, NormalizedNativePixelSize); + float2 pos = vTexCoord * SourceSize.xy; + float f = 0.5-frac(pos.x); + float2 tex = floor(pos)*SourceSize.zw + 0.5*SourceSize.zw; + float2 dx = float2(SourceSize.z, 0.0); + + float w, fp; + float wsum = 0.0; + float3 pixel; + float FPR = FRANGE; + float FPR1 = 1.0/FPR; + float LOOPSIZE = FPR; + float x = -FPR; + + float3 comp = COMPAT_TEXTURE(sBackBuffer, tex).rgb; + float3 color = 0.0.xxx; + + do + { + pixel = COMPAT_TEXTURE(sBackBuffer, tex + x*dx).rgb; + fp = min(abs(x+f),FPR)*FPR1; + w = getw(fp,comp,pixel); + color = color + w * pixel; + wsum = wsum + w; + + x = x + 1.0; + + } while (x <= LOOPSIZE); + + color = color / wsum; + + return float4(color, 1.0); +} + + +float4 PS_Bilateral_Y(float4 position: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target +{ + float4 SourceSize = float4((ViewportSize*BufferToViewportRatio), 1.0/(ViewportSize*BufferToViewportRatio)); + float2 pos = vTexCoord * SourceSize.xy; + float f = 0.5-frac(pos.y); + float2 tex = floor(pos)*SourceSize.zw + 0.5*SourceSize.zw; + float2 dy = float2(0.0, SourceSize.w); + + float w, fp; + float wsum = 0.0; + float3 pixel; + float FPR = FRANGE; + float FPR1 = 1.0/FPR; + float LOOPSIZE = FPR; + float y = -FPR; + + float3 comp = COMPAT_TEXTURE(sBilateral_P0, tex).rgb; + float3 color = 0.0.xxx; + + do + { + pixel = COMPAT_TEXTURE(sBilateral_P0, tex + y*dy).rgb; + fp = min(abs(y+f),FPR)*FPR1; + w = getw(fp,comp,pixel); + color = color + w * pixel; + wsum = wsum + w; + + y = y + 1.0; + + } while (y <= LOOPSIZE); + + color = color / wsum; + + return float4(color, 1.0); +} + +technique Bilateral +{ + + pass + { + VertexShader = PostProcessVS; + PixelShader = PS_Bilateral_X; + RenderTarget = tBilateral_P0; + } + pass + { + VertexShader = PostProcessVS; + PixelShader = PS_Bilateral_Y; + } + +} diff --git a/data/resources/shaders/reshade/Shaders/edge-smoothing/super-xbr.fx b/data/resources/shaders/reshade/Shaders/edge-smoothing/super-xbr.fx index 561263ada..72402560a 100644 --- a/data/resources/shaders/reshade/Shaders/edge-smoothing/super-xbr.fx +++ b/data/resources/shaders/reshade/Shaders/edge-smoothing/super-xbr.fx @@ -32,7 +32,7 @@ uniform float XBR_EDGE_STR_P0 < ui_min = 0.0; ui_max = 5.0; ui_step = 0.5; - ui_label = "Xbr - Edge Strength p0"; + ui_label = "Xbr - Edge Strength"; > = 5.0; uniform float XBR_WEIGHT < @@ -76,7 +76,7 @@ uniform float2 BufferToViewportRatio < source = "buffer_to_viewport_ratio"; >; uniform float2 NormalizedNativePixelSize < source = "normalized_native_pixel_size"; >; texture2D tBackBufferY{Width=BUFFER_WIDTH;Height=BUFFER_HEIGHT;Format=RGBA8;}; -sampler2D sBackBufferY{Texture=tBackBufferY;AddressU=BORDER;AddressV=BORDER;AddressW=BORDER;MagFilter=POINT;MinFilter=POINT;}; +sampler2D sBackBufferY{Texture=tBackBufferY;AddressU=CLAMP;AddressV=CLAMP;AddressW=CLAMP;MagFilter=POINT;MinFilter=POINT;}; texture2D tSuper_xBR_P0 < pooled = true; > {Width=BUFFER_WIDTH;Height=BUFFER_HEIGHT;Format=RGBA8;}; sampler2D sSuper_xBR_P0{Texture=tSuper_xBR_P0;AddressU=CLAMP;AddressV=CLAMP;AddressW=CLAMP;MagFilter=POINT;MinFilter=POINT;}; @@ -87,8 +87,11 @@ sampler2D sSuper_xBR_P1{Texture=tSuper_xBR_P1;AddressU=CLAMP;AddressV=CLAMP;Addr texture2D tSuper_xBR_P2 < pooled = true; > {Width=BUFFER_WIDTH;Height=BUFFER_HEIGHT;Format=RGBA8;}; sampler2D sSuper_xBR_P2{Texture=tSuper_xBR_P2;AddressU=CLAMP;AddressV=CLAMP;AddressW=CLAMP;MagFilter=POINT;MinFilter=POINT;}; -#define Y float3(.2126,.7152,.0722) +#define weight1 (XBR_WEIGHT*1.29633/10.0) +#define weight2 (XBR_WEIGHT*1.75068/10.0/2.0) +#define limits (XBR_EDGE_STR_P0+0.000001) +static const float3 Y = float3(.2126,.7152,.0722); static const float wp0[6] = {2.0, 1.0, -1.0, 4.0, -1.0, 1.0}; static const float wp1[6] = {1.0, 0.0, 0.0, 0.0, 0.0, 0.0}; static const float wp2[6] = {0.0, 0.0, 0.0, 1.0, 0.0, 0.0}; @@ -153,15 +156,11 @@ float3 super_xbr(float wp[6], float4 P0, float4 B, float4 C, float4 P1, float4 /* Calc edgeness in horizontal/vertical directions. */ float hv_edge = (hv_wd(wp, f, i, e, h, c, i5, b, h5) - hv_wd(wp, e, f, h, i, d, f4, g, i4)); - float limits = XBR_EDGE_STR_P0 + 0.000001; float edge_strength = smoothstep(0.0, limits, abs(d_edge)); float4 w1, w2; float3 c3, c4; - float weight1 = (XBR_WEIGHT*1.29633/10.0); - float weight2 = (XBR_WEIGHT*1.75068/10.0/2.0); - /* Filter weights. Two taps only. */ w1 = float4(-weight1, weight1+0.50, weight1+0.50, -weight1); w2 = float4(-weight2, weight2+0.25, weight2+0.25, -weight2); @@ -183,7 +182,7 @@ float3 super_xbr(float wp[6], float4 P0, float4 B, float4 C, float4 P1, float4 return color; } -float4 BackBufferY(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target +float4 PS_BackBufferY(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target { float3 color = tex2D(ReShade::BackBuffer, vTexCoord.xy).rgb; @@ -191,7 +190,7 @@ float4 BackBufferY(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Ta } -float4 Super_xBR_P0(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target +float4 PS_Super_xBR_P0(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target { float2 ps = NormalizedNativePixelSize; @@ -223,7 +222,7 @@ float4 Super_xBR_P0(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_T -float4 Super_xBR_P1(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target +float4 PS_Super_xBR_P1(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target { float2 ps = NormalizedNativePixelSize; @@ -266,7 +265,7 @@ float4 Super_xBR_P1(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_T } -float4 Super_xBR_P2(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target +float4 PS_Super_xBR_P2(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target { float2 ps = 0.5*NormalizedNativePixelSize; @@ -325,7 +324,7 @@ float4 resampler(float4 x) } -float4 Jinc2(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target +float4 PS_Jinc2(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target { float2 ps = 0.5*NormalizedNativePixelSize; @@ -391,33 +390,33 @@ float4 Jinc2(float4 pos: SV_Position, float2 vTexCoord : TEXCOORD) : SV_Target technique Super_xBR { - pass PS_BackBufferY + pass { VertexShader = PostProcessVS; - PixelShader = BackBufferY; + PixelShader = PS_BackBufferY; RenderTarget = tBackBufferY; } - pass PS_Super_xBR_P0 + pass { VertexShader = PostProcessVS; - PixelShader = Super_xBR_P0; + PixelShader = PS_Super_xBR_P0; RenderTarget = tSuper_xBR_P0; } - pass PS_Super_xBR_P1 + pass { VertexShader = PostProcessVS; - PixelShader = Super_xBR_P1; + PixelShader = PS_Super_xBR_P1; RenderTarget = tSuper_xBR_P1; } - pass PS_Super_xBR_P2 + pass { VertexShader = PostProcessVS; - PixelShader = Super_xBR_P2; + PixelShader = PS_Super_xBR_P2; RenderTarget = tSuper_xBR_P2; } - pass PS_Jinc2 + pass { VertexShader = PostProcessVS; - PixelShader = Jinc2; + PixelShader = PS_Jinc2; } } diff --git a/data/resources/shaders/reshade/Shaders/interpolation/bicubic.fx b/data/resources/shaders/reshade/Shaders/interpolation/bicubic.fx index a650d4548..5da8a1f2e 100644 --- a/data/resources/shaders/reshade/Shaders/interpolation/bicubic.fx +++ b/data/resources/shaders/reshade/Shaders/interpolation/bicubic.fx @@ -86,7 +86,7 @@ float3 bicubic_ar(float fp, float3 C0, float3 C1, float3 C2, float3 C3) } -float4 Bicubic_X(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target +float4 PS_Bicubic_X(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target { // Both dimensions are unfiltered, so it looks for lores pixels. float2 ps = NormalizedNativePixelSize; @@ -106,7 +106,7 @@ float4 Bicubic_X(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target } -float4 Bicubic_Y(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target +float4 PS_Bicubic_Y(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target { // One must be careful here. Horizontal dimension is already filtered, so it looks for x in hires. float2 ps = float2(1.0/(ViewportSize.x*BufferToViewportRatio.x), NormalizedNativePixelSize.y); @@ -128,16 +128,16 @@ float4 Bicubic_Y(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target technique Bicubic { - pass PS_Bicubic_X + pass { VertexShader = PostProcessVS; - PixelShader = Bicubic_X; + PixelShader = PS_Bicubic_X; RenderTarget = tBicubic_P0; } - pass PS_Bicubic_Y + pass { VertexShader = PostProcessVS; - PixelShader = Bicubic_Y; + PixelShader = PS_Bicubic_Y; } } diff --git a/data/resources/shaders/reshade/Shaders/interpolation/lanczos3.fx b/data/resources/shaders/reshade/Shaders/interpolation/lanczos3.fx index ed23a11b5..af8275e0f 100644 --- a/data/resources/shaders/reshade/Shaders/interpolation/lanczos3.fx +++ b/data/resources/shaders/reshade/Shaders/interpolation/lanczos3.fx @@ -79,7 +79,7 @@ float3 lanczos3ar(float fp, float3 C0, float3 C1, float3 C2, float3 C3, float3 C } -float4 Lanczos3_X(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target +float4 PS_Lanczos3_X(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target { // Both dimensions are unfiltered, so it looks for lores pixels. float2 ps = NormalizedNativePixelSize; @@ -103,7 +103,7 @@ float4 Lanczos3_X(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target } -float4 Lanczos3_Y(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target +float4 PS_Lanczos3_Y(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target { // One must be careful here. Horizontal dimension is already filtered, so it looks for x in hires. float2 ps = float2(1.0/(ViewportSize.x*BufferToViewportRatio.x), NormalizedNativePixelSize.y); @@ -129,16 +129,16 @@ float4 Lanczos3_Y(float4 pos: SV_Position, float2 uv_tx : TEXCOORD) : SV_Target technique Lanczos3 { - pass PS_Lanczos3_X + pass { VertexShader = PostProcessVS; - PixelShader = Lanczos3_X; + PixelShader = PS_Lanczos3_X; RenderTarget = tLanczos3_P0; } - pass PS_Lanczos3_Y + pass { VertexShader = PostProcessVS; - PixelShader = Lanczos3_Y; + PixelShader = PS_Lanczos3_Y; } } diff --git a/data/resources/shaders/reshade/Shaders/misc/geom.fx b/data/resources/shaders/reshade/Shaders/misc/geom.fx index 3cda0a313..df4e6aa0d 100644 --- a/data/resources/shaders/reshade/Shaders/misc/geom.fx +++ b/data/resources/shaders/reshade/Shaders/misc/geom.fx @@ -141,6 +141,8 @@ uniform float2 BufferViewportRatio < source = "buffer_to_viewport_ratio"; >; uniform float2 NormalizedNativePixelSize < source = "normalized_native_pixel_size"; >; uniform float2 ViewportSize < source = "viewportsize"; >; +sampler2D sBackBuffer{Texture=ReShade::BackBufferTex;AddressU=BORDER;AddressV=BORDER;AddressW=BORDER;MagFilter=LINEAR;MinFilter=LINEAR;}; + // Comment the next line to disable interpolation in linear gamma (and // gain speed). #define LINEAR_PROCESSING @@ -156,9 +158,9 @@ uniform float2 ViewportSize < source = "viewportsize"; >; #define PI 3.141592653589 #ifdef LINEAR_PROCESSING -# define TEX2D(c) pow(tex2D(ReShade::BackBuffer, (c)), float4(geom_target_gamma,geom_target_gamma,geom_target_gamma,geom_target_gamma)) +# define TEX2D(c) pow(tex2D(sBackBuffer, (c)), float4(geom_target_gamma,geom_target_gamma,geom_target_gamma,geom_target_gamma)) #else -# define TEX2D(c) tex2D(ReShade::BackBuffer, (c)) +# define TEX2D(c) tex2D(sBackBuffer, (c)) #endif // aspect ratio