mirror of
https://github.com/RetroDECK/Duckstation.git
synced 2024-11-26 23:55:40 +00:00
9189588554
- Add crt-geom, super-xbr, geom, multi-LUT, deblur-luma, bicubic and lanczos3. All .fx shaders; - Added some LUTs.
556 lines
13 KiB
HLSL
556 lines
13 KiB
HLSL
#include "ReShade.fxh"
|
|
|
|
|
|
// DariusG presents
|
|
|
|
// 'crt-Cyclon'
|
|
|
|
// Why? Because it's speedy!
|
|
|
|
// A super-fast shader based on the magnificent crt-Geom, optimized for full speed
|
|
// on a Xiaomi Note 3 Pro cellphone (around 170(?) gflops gpu or so)
|
|
|
|
// This shader uses parts from:
|
|
// crt-Geom (scanlines)
|
|
// Quillez (main filter)
|
|
// Grade (some primaries)
|
|
// Dogway's inverse Gamma
|
|
// Masks-slot-color handling, tricks etc are mine.
|
|
|
|
// 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.
|
|
|
|
|
|
|
|
uniform float SCANLINE <
|
|
ui_type = "drag";
|
|
ui_min = 0.2;
|
|
ui_max = 0.6;
|
|
ui_step = 0.05;
|
|
ui_label = "Scanline Weight";
|
|
> = 0.3;
|
|
|
|
uniform float INTERLACE <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Interlacing On/Off";
|
|
> = 1.0;
|
|
|
|
uniform float bogus_msk <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 0.0;
|
|
ui_step = 0.0;
|
|
ui_label = " [ MASK SETTINGS ] ";
|
|
> = 0.0;
|
|
|
|
uniform float M_TYPE <
|
|
ui_type = "drag";
|
|
ui_min = -1.0;
|
|
ui_max = 1.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Mask Type: -1:None, 0:CGWG, 1:RGB";
|
|
> = 1.0;
|
|
|
|
uniform float MSIZE <
|
|
ui_type = "drag";
|
|
ui_min = 1.0;
|
|
ui_max = 2.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Mask Size";
|
|
> = 1.0;
|
|
|
|
uniform float SLOT <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Slot Mask On/Off";
|
|
> = 1.0;
|
|
|
|
uniform float SLOTW <
|
|
ui_type = "drag";
|
|
ui_min = 2.0;
|
|
ui_max = 3.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Slot Mask Width";
|
|
> = 3.0;
|
|
|
|
uniform float BGR <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Subpixels BGR/RGB";
|
|
> = 0.0;
|
|
|
|
uniform float Maskl <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 0.05;
|
|
ui_label = "Mask Brightness Dark";
|
|
> = 0.3;
|
|
|
|
uniform float Maskh <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 0.05;
|
|
ui_label = "Mask Brightness Bright";
|
|
> = 0.75;
|
|
|
|
uniform float bogus_geom <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 0.0;
|
|
ui_step = 0.0;
|
|
ui_label = " [ GEOMETRY SETTINGS ] ";
|
|
> = 0.0;
|
|
|
|
uniform float bzl <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Bezel On/Off";
|
|
> = 1.0;
|
|
|
|
uniform float ambient <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 0.05;
|
|
ui_label = "Ambient Light";
|
|
> = 0.40;
|
|
|
|
uniform float zoomx <
|
|
ui_type = "drag";
|
|
ui_min = -1.0;
|
|
ui_max = 1.0;
|
|
ui_step = 0.005;
|
|
ui_label = "Zoom Image X";
|
|
> = 0.0;
|
|
|
|
uniform float zoomy <
|
|
ui_type = "drag";
|
|
ui_min = -1.0;
|
|
ui_max = 1.0;
|
|
ui_step = 0.005;
|
|
ui_label = "Zoom Image Y";
|
|
> = 0.0;
|
|
|
|
uniform float centerx <
|
|
ui_type = "drag";
|
|
ui_min = -5.0;
|
|
ui_max = 5.0;
|
|
ui_step = 0.0;
|
|
ui_label = "Image Center X";
|
|
> = 0.0;
|
|
|
|
uniform float centery <
|
|
ui_type = "drag";
|
|
ui_min = -5.0;
|
|
ui_max = 5.0;
|
|
ui_step = 0.05;
|
|
ui_label = "Image Center Y";
|
|
> = 0.0;
|
|
|
|
uniform float WARPX <
|
|
ui_type = "drag";
|
|
ui_min = 0.00;
|
|
ui_max = 0.25;
|
|
ui_step = 0.01;
|
|
ui_label = "Curvature Horizontal";
|
|
> = 0.02;
|
|
|
|
uniform float WARPY <
|
|
ui_type = "drag";
|
|
ui_min = 0.00;
|
|
ui_max = 0.25;
|
|
ui_step = 0.01;
|
|
ui_label = "Curvature Vertical";
|
|
> = 0.01;
|
|
|
|
uniform float vig <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Vignette On/Off";
|
|
> = 1.0;
|
|
|
|
uniform float bogus_col <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 0.0;
|
|
ui_step = 0.0;
|
|
ui_label = " [ COLOR SETTINGS ] ";
|
|
> = 0.0;
|
|
|
|
uniform float BR_DEP <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 0.333;
|
|
ui_step = 0.01;
|
|
ui_label = "Scan/Mask Brightness Dependence";
|
|
> = 0.2;
|
|
|
|
uniform float c_space <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 3.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Color Space: sRGB,PAL,NTSC-U,NTSC-J";
|
|
> = 0.0;
|
|
|
|
uniform float EXT_GAMMA <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 1.0;
|
|
ui_label = "External Gamma In (Glow etc)";
|
|
> = 0.0;
|
|
|
|
uniform float SATURATION <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 2.0;
|
|
ui_step = 0.05;
|
|
ui_label = "Saturation";
|
|
> = 1.0;
|
|
|
|
uniform float BRIGHTNESS_ <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 2.0;
|
|
ui_step = 0.01;
|
|
ui_label = "Brightness, Sega fix:1.06";
|
|
> = 1.0;
|
|
|
|
uniform float BLACK <
|
|
ui_type = "drag";
|
|
ui_min = -0.20;
|
|
ui_max = 0.20;
|
|
ui_step = 0.0;
|
|
ui_label = "Black Level";
|
|
> = 0.0;
|
|
|
|
uniform float RG <
|
|
ui_type = "drag";
|
|
ui_min = -0.25;
|
|
ui_max = 0.25;
|
|
ui_step = 0.01;
|
|
ui_label = "Green <-to-> Red Hue";
|
|
> = 0.0;
|
|
|
|
uniform float RB <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = -0.25;
|
|
ui_step = 0.2;
|
|
ui_label = "Blue <-to-> Red Hue";
|
|
> = 0.0;
|
|
|
|
uniform float GB <
|
|
ui_type = "drag";
|
|
ui_min = -0.25;
|
|
ui_max = 0.25;
|
|
ui_step = 0.01;
|
|
ui_label = "Blue <-to-> Green Hue";
|
|
> = 0.0;
|
|
|
|
uniform float bogus_con <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 0.0;
|
|
ui_step = 0.0;
|
|
ui_label = " [ CONVERGENCE SETTINGS ] ";
|
|
> = 0.0;
|
|
|
|
uniform float C_STR <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 0.5;
|
|
ui_step = 0.05;
|
|
ui_label = "Convergence Overall Strength";
|
|
> = 0.0;
|
|
|
|
uniform float CONV_R <
|
|
ui_type = "drag";
|
|
ui_min = -1.0;
|
|
ui_max = 1.0;
|
|
ui_step = 0.05;
|
|
ui_label = "Convergence Red X-Axis";
|
|
> = 0.0;
|
|
|
|
uniform float CONV_G <
|
|
ui_type = "drag";
|
|
ui_min = -1.0;
|
|
ui_max = 1.0;
|
|
ui_step = 0.05;
|
|
ui_label = "Convergence Green X-axis";
|
|
> = 0.0;
|
|
|
|
uniform float CONV_B <
|
|
ui_type = "drag";
|
|
ui_min = -1.0;
|
|
ui_max = 1.0;
|
|
ui_step = 0.05;
|
|
ui_label = "Convergence Blue X-Axis";
|
|
> = 0.0;
|
|
|
|
uniform float POTATO <
|
|
ui_type = "drag";
|
|
ui_min = 0.0;
|
|
ui_max = 1.0;
|
|
ui_step = 1.0;
|
|
ui_label = "Potato Boost(Simple Gamma, adjust Mask)";
|
|
> = 0.0;
|
|
|
|
|
|
#define blck ((1.0)/(1.0-BLACK))
|
|
#define pi 3.1415926535897932384626433
|
|
|
|
uniform float2 BufferViewportRatio < source = "buffer_to_viewport_ratio"; >;
|
|
uniform float2 InternalPixelSize < source = "internal_pixel_size"; >;
|
|
uniform float2 NativePixelSize < source = "native_pixel_size"; >;
|
|
uniform float2 NormalizedInternalPixelSize < source = "normalized_internal_pixel_size"; >;
|
|
uniform float2 NormalizedNativePixelSize < source = "normalized_native_pixel_size"; >;
|
|
uniform float UpscaleMultiplier < source = "upscale_multiplier"; >;
|
|
uniform float2 ViewportSize < source = "viewportsize"; >;
|
|
|
|
|
|
uniform int FrameCount < source = "framecount"; >;
|
|
texture tBezel < source = "crt-cyclon/bezel.png"; >
|
|
{
|
|
Width = BUFFER_WIDTH;
|
|
Height = BUFFER_HEIGHT;
|
|
MipLevels = 1;
|
|
};
|
|
|
|
sampler sBezel { Texture = tBezel; AddressU = BORDER; AddressV = BORDER; MinFilter = LINEAR; MagFilter = LINEAR;};
|
|
|
|
float3 Mask(float2 pos, float CGWG)
|
|
{
|
|
float3 mask = float3(CGWG,CGWG,CGWG);
|
|
|
|
|
|
if (M_TYPE == 0.0){
|
|
|
|
if (POTATO == 1.0) { float pot = (1.0-CGWG)*sin(pos.x*pi)+CGWG; return float3(pot,pot,pot); }
|
|
else{
|
|
float m = frac(pos.x*0.5);
|
|
|
|
if (m<0.5) mask.rb = float2(1.0,1.0);
|
|
else mask.g = 1.0;
|
|
|
|
return mask;
|
|
}
|
|
}
|
|
|
|
if (M_TYPE == 1.0){
|
|
|
|
if (POTATO == 1.0) { float pot = (1.0-CGWG)*sin(pos.x*pi*0.6667)+CGWG; return float3(pot,pot,pot );}
|
|
else{
|
|
float m = frac(pos.x*0.3333);
|
|
|
|
if (m<0.3333) mask.rgb = (BGR == 0.0) ? float3(mask.r, mask.g, 1.0) : float3(1.0, mask.g, mask.b);
|
|
else if (m<0.6666) mask.g = 1.0;
|
|
else mask.rgb = (BGR == 0.0) ? float3(1.0, mask.g, mask.b) : float3(mask.r, mask.g, 1.0);
|
|
return mask;
|
|
}
|
|
}
|
|
else return float3(1.0,1.0,1.0);
|
|
|
|
}
|
|
|
|
float scanlineWeights(float distance, float3 color, float x)
|
|
{
|
|
// "wid" controls the width of the scanline beam, for each RGB
|
|
// channel The "weights" lines basically specify the formula
|
|
// that gives you the profile of the beam, i.e. the intensity as
|
|
// a function of distance from the vertical center of the
|
|
// scanline. In this case, it is gaussian if width=2, and
|
|
// becomes nongaussian for larger widths. Ideally this should
|
|
// be normalized so that the integral across the beam is
|
|
// independent of its width. That is, for a narrower beam
|
|
// "weights" should have a higher peak at the center of the
|
|
// scanline than for a wider beam.
|
|
float wid = SCANLINE + 0.15 * dot(color, float3(0.25-0.8*x, 0.25-0.8*x, 0.25-0.8*x)); //0.8 vignette strength
|
|
float weights = distance / wid;
|
|
return 0.4 * exp(-weights * weights ) / wid;
|
|
}
|
|
|
|
#define pwr float3(1.0/((-1.0*SCANLINE+1.0)*(-0.8*CGWG+1.0))-1.2,1.0/((-1.0*SCANLINE+1.0)*(-0.8*CGWG+1.0))-1.2,1.0/((-1.0*SCANLINE+1.0)*(-0.8*CGWG+1.0))-1.2)
|
|
// Returns gamma corrected output, compensated for scanline+mask embedded gamma
|
|
float3 inv_gamma(float3 col, float3 power)
|
|
{
|
|
float3 cir = col-1.0;
|
|
cir *= cir;
|
|
col = lerp(sqrt(col),sqrt(1.0-cir),power);
|
|
return col;
|
|
}
|
|
|
|
// standard 6500k
|
|
static const float3x3 PAL = float3x3(
|
|
1.0740 , -0.0574 , -0.0119 ,
|
|
0.0384 , 0.9699 , -0.0059 ,
|
|
-0.0079 , 0.0204 , 0.9884 );
|
|
|
|
// standard 6500k
|
|
static const float3x3 NTSC = float3x3(
|
|
0.9318 , 0.0412 , 0.0217 ,
|
|
0.0135 , 0.9711 , 0.0148 ,
|
|
0.0055 , -0.0143 , 1.0085 );
|
|
|
|
// standard 8500k
|
|
static const float3x3 NTSC_J = float3x3(
|
|
0.9501 , -0.0431 , 0.0857 ,
|
|
0.0265 , 0.9278 , 0.0432 ,
|
|
0.0011 , -0.0206 , 1.3153 );
|
|
|
|
float3 slot(float2 pos)
|
|
{
|
|
float h = frac(pos.x/SLOTW);
|
|
float v = frac(pos.y);
|
|
|
|
float odd;
|
|
if (v<0.5) odd = 0.0; else odd = 1.0;
|
|
|
|
if (odd == 0.0)
|
|
{if (h<0.5) return float3(0.5,0.5,0.5); else return float3(1.5,1.5,1.5);}
|
|
|
|
else if (odd == 1.0)
|
|
{if (h<0.5) return float3(1.5,1.5,1.5); else return float3(0.5,0.5,0.5);}
|
|
}
|
|
|
|
float2 Warp(float2 pos)
|
|
{
|
|
pos = pos*2.0-1.0;
|
|
pos *= float2(1.0+pos.y*pos.y*WARPX, 1.0+pos.x*pos.x*WARPY);
|
|
pos = pos*0.5+0.5;
|
|
|
|
return pos;
|
|
}
|
|
|
|
uniform float2 BufferHeight < source = "bufferheight"; >;
|
|
|
|
float4 CRT_CYCLON_PS(float4 vpos: SV_Position, float2 vTexCoord : TEXCOORD0) : SV_Target
|
|
{
|
|
float4 SourceSize = float4(1.0 / (NormalizedInternalPixelSize * UpscaleMultiplier), NormalizedInternalPixelSize * UpscaleMultiplier);
|
|
float2 OutputSize = ViewportSize;
|
|
float2 scale = BufferViewportRatio.xy;
|
|
float2 warpcoords = (vTexCoord-float2(0.5,0.5)) * BufferViewportRatio + float2(0.5,0.5);
|
|
|
|
// Hue matrix inside main() to avoid GLES error
|
|
float3x3 hue = float3x3(
|
|
1.0, -RG, -RB,
|
|
RG, 1.0, -GB,
|
|
RB, GB, 1.0
|
|
);
|
|
// zoom in and center screen for bezel
|
|
float2 pos = Warp((vTexCoord*float2(1.0-zoomx,1.0-zoomy)-float2(centerx,centery)/100.0));
|
|
float4 bez = float4(0.0,0.0,0.0,0.0);
|
|
// if (bzl == 1.0) bez = tex2D(sBezel,vTexCoord*SourceSize.xy/OriginalSize.xy*0.97+float2(0.015,0.015));
|
|
// if (bzl == 1.0) bez = tex2D(sBezel,vTexCoord*scale*0.97+float2(0.015,0.015));
|
|
if (bzl == 1.0) bez = tex2D(sBezel,warpcoords*0.97+float2(0.015,0.015)); // This fix Bezel to adjust to Game's aspect ratio.
|
|
|
|
bez.rgb = lerp(bez.rgb, float3(ambient,ambient,ambient),0.5);
|
|
|
|
float2 bpos = pos;
|
|
float2 ps = SourceSize.zw;
|
|
float2 dx = float2(ps.x,0.0);
|
|
// Quilez
|
|
float2 ogl2 = pos*SourceSize.xy;
|
|
float2 i = floor(pos*SourceSize.xy) + 0.5;
|
|
float f = ogl2.y - i.y;
|
|
pos.y = (i.y + 4.0*f*f*f)*ps.y; // smooth
|
|
pos.x = lerp(pos.x, i.x*ps.x, 0.2);
|
|
|
|
// Convergence
|
|
float3 res0 = tex2D(ReShade::BackBuffer,pos).rgb;
|
|
float resr = tex2D(ReShade::BackBuffer,pos + dx*CONV_R).r;
|
|
float resb = tex2D(ReShade::BackBuffer,pos + dx*CONV_B).b;
|
|
float resg = tex2D(ReShade::BackBuffer,pos + dx*CONV_G).g;
|
|
|
|
float3 res = float3( res0.r*(1.0-C_STR) + resr*C_STR,
|
|
res0.g*(1.0-C_STR) + resg*C_STR,
|
|
res0.b*(1.0-C_STR) + resb*C_STR
|
|
);
|
|
// Vignette
|
|
float x = 0.0;
|
|
if (vig == 1.0){
|
|
x = vTexCoord.x*scale.x-0.5;
|
|
// x = vTexCoord.x-0.5;
|
|
x = x*x;}
|
|
|
|
float l = dot(float3(BR_DEP,BR_DEP,BR_DEP),res);
|
|
|
|
// Color Spaces
|
|
if(EXT_GAMMA != 1.0) res *= res;
|
|
if (c_space != 0.0) {
|
|
if (c_space == 1.0) res = mul(PAL,res);
|
|
if (c_space == 2.0) res = mul(NTSC,res);
|
|
if (c_space == 3.0) res = mul(NTSC_J,res);
|
|
// Apply CRT-like luminances
|
|
res /= float3(0.24,0.69,0.07);
|
|
res *= float3(0.29,0.6,0.11);
|
|
res = clamp(res,0.0,1.0);
|
|
}
|
|
float s = frac(bpos.y*SourceSize.y-0.5);
|
|
// handle interlacing
|
|
if (SourceSize.y > 400.0)
|
|
{
|
|
s = frac(bpos.y*SourceSize.y/2.0-0.5);
|
|
// if (INTERLACE == 1.0) s = mod(float(FrameCount),2.0) < 1.0 ? s: s+0.5;
|
|
if (INTERLACE == 1.0) s = (float(FrameCount) % 2.0) < 1.0 ? s: s+0.5;
|
|
}
|
|
// Calculate CRT-Geom scanlines weight and apply
|
|
float weight = scanlineWeights(s, res, x);
|
|
float weight2 = scanlineWeights(1.0-s, res, x);
|
|
res *= weight + weight2;
|
|
|
|
// Masks
|
|
float2 xy = vTexCoord*OutputSize.xy*scale/MSIZE;
|
|
// float2 xy = vTexCoord*OutputSize.xy/MSIZE;
|
|
float CGWG = lerp(Maskl, Maskh, l);
|
|
res *= Mask(xy, CGWG);
|
|
// Apply slot mask on top of Trinitron-like mask
|
|
if (SLOT == 1.0) res *= lerp(slot(xy/2.0),float3(1.0,1.0,1.0),CGWG);
|
|
|
|
if (POTATO == 0.0) res = inv_gamma(res,pwr);
|
|
else {res = sqrt(res); res *= lerp(1.3,1.1,l);}
|
|
|
|
// Saturation
|
|
float lum = dot(float3(0.29,0.60,0.11),res);
|
|
res = lerp(float3(lum,lum,lum),res,SATURATION);
|
|
|
|
// Brightness, Hue and Black Level
|
|
res *= BRIGHTNESS_;
|
|
res = mul(hue,res);
|
|
res -= float3(BLACK,BLACK,BLACK);
|
|
res *= blck;
|
|
// Apply bezel code, adapted from New-Pixie
|
|
if (bzl >0.0)
|
|
res.rgb = lerp(res.rgb, lerp(max(res.rgb, 0.0), pow( abs(bez.rgb), float3( 1.4,1.4,1.4 ) ), bez.w * bez.w), float3( 1.0,1.0,1.0 ) );
|
|
|
|
|
|
return float4(res, 1.0);
|
|
}
|
|
|
|
|
|
|
|
technique CRT_CYCLON
|
|
{
|
|
pass PS_CRT_CYCLON
|
|
{
|
|
VertexShader = PostProcessVS;
|
|
PixelShader = CRT_CYCLON_PS;
|
|
}
|
|
}
|