Duckstation/data/resources/shaders/reshade/Shaders/CRTLottes2.fx

446 lines
11 KiB
HLSL
Raw Normal View History

#include "ReShade.fxh"
//
// PUBLIC DOMAIN CRT STYLED SCAN-LINE SHADER
//
// by Timothy Lottes
//
// This is more along the style of a really good CGA arcade monitor.
// With RGB inputs instead of NTSC.
// The shadow mask example has the mask rotated 90 degrees for less chromatic aberration.
//
// Left it unoptimized to show the theory behind the algorithm.
//
// It is an example what I personally would want as a display option for pixel art games.
// Please take and use, change, or whatever.
//
#ifndef CRTS_DEBUG
#define CRTS_DEBUG 0
#endif
#ifndef CRTS_2_TAP
#define CRTS_2_TAP 0
#endif
uniform bool CRTS_WARP <
ui_type = "boolean";
ui_label = "Enable Warping [CRT Lottes 2.0]";
> = true;
uniform float CRTS_WARP_X <
ui_type = "drag";
ui_min = 0.0;
ui_max = 512.0;
ui_label = "CRT Warping X [CRT Lottes 2.0]";
> = 64.0;
uniform float CRTS_WARP_Y <
ui_type = "drag";
ui_min = 0.0;
ui_max = 512.0;
ui_label = "CRT Warping Y [CRT Lottes 2.0]";
> = 48.0;
uniform bool CRTS_TONE <
ui_type = "boolean";
ui_label = "Enable CRT Tonemapping [CRT Lottes 2.0]";
> = true;
uniform bool CRTS_CONTRAST <
ui_type = "boolean";
ui_label = "Enable CRT Contrast [CRT Lottes 2.0]";
> = false;
uniform bool CRTS_SATURATION <
ui_type = "boolean";
ui_label = "Enable CRT Saturation [CRT Lottes 2.0]";
> = false;
uniform int CRTS_MASK_TYPE <
ui_type = "combo";
ui_items = "None\0Aperture Grille\0Aperture Grille (Lite)\0Shadow Mask\0";
ui_label = "Mask Type [CRT Lottes 2.0]";
> = 2;
//--------------------------------------------------------------
// Scanline thinness
// 0.50 = fused scanlines
// 0.70 = recommended default
// 1.00 = thinner scanlines (too thin)
uniform float INPUT_THIN <
ui_type = "drag";
ui_min = 0.5;
ui_max = 1.0;
ui_label = "Scanlines Thinnes [CRT Lottes 2.0]";
> = 0.70;
//--------------------------------------------------------------
// Horizonal scan blur
// -3.0 = pixely
// -2.5 = default
// -2.0 = smooth
// -1.0 = too blurry
uniform float INPUT_BLUR <
ui_type = "drag";
ui_min = -3.0;
ui_max = 0.0;
ui_label = "Horizontal Scan Blur [CRT Lottes 2.0]";
> = -2.5;
//--------------------------------------------------------------
// Shadow mask effect, ranges from,
// 0.25 = large amount of mask (not recommended, too dark)
// 0.50 = recommended default
// 1.00 = no shadow mask
uniform float INPUT_MASK <
ui_type = "drag";
ui_min = 0.0;
ui_max = 1.0;
ui_label = "Shadow Mask Intensity [CRT Lottes 2.0]";
> = 0.5;
//--------------------------------------------------------------
uniform int INPUT_X <
ui_type = "drag";
ui_min = 1;
ui_max = BUFFER_WIDTH;
ui_label = "Resolution Width [CRT Lottes 2.0]";
> = 640;
uniform int INPUT_Y <
ui_type = "drag";
ui_min = 1;
ui_max = BUFFER_HEIGHT;
ui_label = "Resolution Height [CRT Lottes 2.0]";
> = 480;
//--------------------------------------------------------------
// Setup the function which returns input image color
void ToLinear(inout float3 color)
{
float3 c1 = color.rgb / 12.92;
float3 c2 = pow((color.rgb + 0.055)/1.055, 2.4);
color.r = (color.r <= 0.04045) ? c1.r : c2.r;
color.g = (color.g <= 0.04045) ? c1.g : c2.g;
color.b = (color.b <= 0.04045) ? c1.b : c2.b;
}
void ToSRGB(inout float3 color)
{
float3 c1 = color.rgb * 12.92;
float3 c2 = 1.055 * pow(color.rgb, 0.4166) - 0.055;
color.r = (color.r < 0.0031308) ? c1.r : c2.r;
color.g = (color.g < 0.0031308) ? c1.g : c2.g;
color.b = (color.b < 0.0031308) ? c1.b : c2.b;
}
float3 CrtsFetch(float2 uv)
{
float3 color = tex2D(ReShade::BackBuffer, uv).rgb;
ToLinear(color);
return color;
}
float4 CrtsTone(
float contrast,
float saturation,
float thin,
float mask)
{
mask = INPUT_MASK;
if (CRTS_MASK_TYPE <= 0){
mask=1.0;
}
if(CRTS_MASK_TYPE == 2){
mask=0.5+INPUT_MASK*0.5;
}
float4 ret;
float midOut=0.18/((1.5-thin)*(0.5*mask+0.5));
float pMidIn=pow(0.18,contrast);
ret.x=contrast;
ret.y=((-pMidIn)+midOut)/((1.0-pMidIn)*midOut);
ret.z=((-pMidIn)*midOut+pMidIn)/(midOut*(-pMidIn)+midOut);
ret.w=contrast+saturation;
return ret;
}
float3 CrtsMask(float2 pos,float dark)
{
if (CRTS_MASK_TYPE == 1){
float3 m=dark;
float x=frac(pos.x*(1.0/3.0));
if(x<(1.0/3.0))m.r=1.0;
else if(x<(2.0/3.0))m.g=1.0;
else m.b=1.0;
return m;
} else if (CRTS_MASK_TYPE == 2){
float3 m=1.0;
float x=frac(pos.x*(1.0/3.0));
if(x<(1.0/3.0))m.r=dark;
else if(x<(2.0/3.0))m.g=dark;
else m.b=dark;
return m;
} else if(CRTS_MASK_TYPE <= 0){
return 1.0;
} else if(CRTS_MASK_TYPE >= 3){
pos.x+=pos.y*3.0;
float3 m=dark;
float x=frac(pos.x*(1.0/6.0));
if(x<(1.0/3.0))m.r=1.0;
else if(x<(2.0/3.0))m.g=1.0;
else m.b=1.0;
return m;
} else {
return 0.0;
}
}
float3 CrtsFilter(
//--------------------------------------------------------------
// SV_POSITION, fragCoord.xy
float2 ipos,
//--------------------------------------------------------------
// inputSize / outputSize (in pixels)
float2 inputSizeDivOutputSize,
//--------------------------------------------------------------
// 0.5 * inputSize (in pixels)
float2 halfInputSize,
//--------------------------------------------------------------
// 1.0 / inputSize (in pixels)
float2 rcpInputSize,
//--------------------------------------------------------------
// 1.0 / outputSize (in pixels)
float2 rcpOutputSize,
//--------------------------------------------------------------
// 2.0 / outputSize (in pixels)
float2 twoDivOutputSize,
//--------------------------------------------------------------
// inputSize.y
float inputHeight,
//--------------------------------------------------------------
// Warp scanlines but not phosphor mask
// 0.0 = no warp
// 1.0/64.0 = light warping
// 1.0/32.0 = more warping
// Want x and y warping to be different (based on aspect)
float2 warp,
//--------------------------------------------------------------
// Scanline thinness
// 0.50 = fused scanlines
// 0.70 = recommended default
// 1.00 = thinner scanlines (too thin)
// Shared with CrtsTone() function
float thin,
//--------------------------------------------------------------
// Horizonal scan blur
// -3.0 = pixely
// -2.5 = default
// -2.0 = smooth
// -1.0 = too blurry
float blur,
//--------------------------------------------------------------
// Shadow mask effect, ranges from,
// 0.25 = large amount of mask (not recommended, too dark)
// 0.50 = recommended default
// 1.00 = no shadow mask
// Shared with CrtsTone() function
float mask,
//--------------------------------------------------------------
// Tonal curve parameters generated by CrtsTone()
float4 tone
//--------------------------------------------------------------
){
//--------------------------------------------------------------
#if (CRTS_DEBUG == 1)
float2 uv=ipos*rcpOutputSize;
// Show second half processed, and first half un-processed
if(uv.x<0.5)
{
// Force nearest to get squares
uv*=1.0/rcpInputSize;
uv=floor(uv)+float2(0.5,0.5);
uv*=rcpInputSize;
float3 color=CrtsFetch(uv);
return color;
}
#endif
float2 pos;
float vin;
if (CRTS_WARP){
// Convert to {-1 to 1} range
pos=ipos*twoDivOutputSize-float2(1.0,1.0);
// Distort pushes image outside {-1 to 1} range
pos*=float2(1.0+(pos.y*pos.y)*warp.x,1.0+(pos.x*pos.x)*warp.y);
// TODO: Vignette needs optimization
vin=1.0-((1.0-saturate(pos.x*pos.x))*(1.0-saturate(pos.y*pos.y)));
vin=saturate((-vin)*inputHeight+inputHeight);
// Leave in {0 to inputSize}
pos=pos*halfInputSize+halfInputSize;
} else {
pos=ipos*inputSizeDivOutputSize;
}
// Snap to center of first scanline
float y0=floor(pos.y-0.5)+0.5;
#if (CRTS_2_TAP == 1)
// Using Inigo's "Improved Texture Interpolation"
// http://iquilezles.org/www/articles/texture/texture.htm
pos.x+=0.5;
float xi=floor(pos.x);
float xf=pos.x-xi;
xf=xf*xf*xf*(xf*(xf*6.0-15.0)+10.0);
float x0=xi+xf-0.5;
float2 p=float2(x0*rcpInputSize.x,y0*rcpInputSize.y);
// Coordinate adjusted bilinear fetch from 2 nearest scanlines
float3 colA=CrtsFetch(p);
p.y+=rcpInputSize.y;
float3 colB=CrtsFetch(p);
#else
// Snap to center of one of four pixels
float x0=floor(pos.x-1.5)+0.5;
// Inital UV position
float2 p=float2(x0*rcpInputSize.x,y0*rcpInputSize.y);
// Fetch 4 nearest texels from 2 nearest scanlines
float3 colA0=CrtsFetch(p);
p.x+=rcpInputSize.x;
float3 colA1=CrtsFetch(p);
p.x+=rcpInputSize.x;
float3 colA2=CrtsFetch(p);
p.x+=rcpInputSize.x;
float3 colA3=CrtsFetch(p);
p.y+=rcpInputSize.y;
float3 colB3=CrtsFetch(p);
p.x-=rcpInputSize.x;
float3 colB2=CrtsFetch(p);
p.x-=rcpInputSize.x;
float3 colB1=CrtsFetch(p);
p.x-=rcpInputSize.x;
float3 colB0=CrtsFetch(p);
#endif
// Vertical filter
// Scanline intensity is using sine wave
// Easy filter window and integral used later in exposure
float off=pos.y-y0;
float pi2=6.28318530717958;
float hlf=0.5;
float scanA=cos(min(0.5, off *thin )*pi2)*hlf+hlf;
float scanB=cos(min(0.5,(-off)*thin+thin)*pi2)*hlf+hlf;
#if (CRTS_2_TAP == 1)
if (CRTS_WARP){
// Get rid of wrong pixels on edge
scanA*=vin;
scanB*=vin;
}
// Apply vertical filter
float3 color=(colA*scanA)+(colB*scanB);
#else
// Horizontal kernel is simple gaussian filter
float off0=pos.x-x0;
float off1=off0-1.0;
float off2=off0-2.0;
float off3=off0-3.0;
float pix0=exp2(blur*off0*off0);
float pix1=exp2(blur*off1*off1);
float pix2=exp2(blur*off2*off2);
float pix3=exp2(blur*off3*off3);
float pixT=rcp(pix0+pix1+pix2+pix3);
if (CRTS_WARP){
// Get rid of wrong pixels on edge
pixT*=vin;
}
scanA*=pixT;
scanB*=pixT;
// Apply horizontal and vertical filters
float3 color=
(colA0*pix0+colA1*pix1+colA2*pix2+colA3*pix3)*scanA +
(colB0*pix0+colB1*pix1+colB2*pix2+colB3*pix3)*scanB;
#endif
// Apply phosphor mask
color*=CrtsMask(ipos,mask);
// Optional color processing
if (CRTS_TONE){
// Tonal control, start by protecting from /0
float peak=max(1.0/(256.0*65536.0),max(color.r,max(color.g,color.b)));
// Compute the ratios of {R,G,B}
float3 ratio=color*rcp(peak);
// Apply tonal curve to peak value
if (CRTS_CONTRAST){
peak=pow(peak,tone.x);
}
peak=peak*rcp(peak*tone.y+tone.z);
// Apply saturation
if (CRTS_SATURATION){
ratio=pow(ratio,float3(tone.w,tone.w,tone.w));
}
// Reconstruct color
return ratio*peak;
} else {
return color;
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void PS_CRTLottes2018(float4 vpos : SV_Position, float2 texcoord : TEXCOORD, out float4 color : SV_Target0)
{
color = tex2D(ReShade::BackBuffer, texcoord.xy);
color.rgb=CrtsFilter(
vpos.xy,
float2(INPUT_X,INPUT_Y)/ReShade::ScreenSize.xy,
float2(INPUT_X,INPUT_Y)*0.5,
1.0/float2(INPUT_X,INPUT_Y),
1.0/ReShade::ScreenSize.xy,
2.0/ReShade::ScreenSize.xy,
INPUT_Y,
float2(1.0/CRTS_WARP_X,1.0/CRTS_WARP_Y),
INPUT_THIN,
INPUT_BLUR,
INPUT_MASK,
CrtsTone(1.0,0.0,INPUT_THIN,INPUT_MASK));
ToSRGB(color.rgb);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
technique CRTLottes2018
{
pass
{
VertexShader = PostProcessVS;
PixelShader = PS_CRTLottes2018;
}
}