sgilissen/llamaplayer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Data: Remove license-incompatible shaders

Browse Source
This commit is contained in:
Stenzek
2024-09-01 20:01:34 +10:00
parent 486f410f43
commit 7df5764835
93 changed files with 47 additions and 31273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
data/resources/shaders/dolphinfx/bloom.glsl
View File

@@ -1,238 +0,0 @@
/*===============================================================================*\
|######################## [Dolphin FX Suite 2.20] #######################|
|########################## By Asmodean ##########################|
|| ||
|| 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. (C)2015 ||
|| ||
|#################################################################################|
\*===============================================================================*/
// Sourced from https://raw.githubusercontent.com/Asmodean-/dolphin/89d640cd557189bb5f921fc219150c74c39bdc55/Data/Sys/Shaders/DolphinFX.glsl with modifications.
/*
[configuration]
[OptionRangeInteger]
GUIName = BloomType
OptionName = A_BLOOM_TYPE
MinValue = 0
MaxValue = 5
StepAmount = 1
DefaultValue = 0
[OptionRangeFloat]
GUIName = BloomStrength
OptionName = B_BLOOM_STRENGTH
MinValue = 0.000
MaxValue = 1.000
StepAmount = 0.001
DefaultValue = 0.220
[OptionRangeFloat]
GUIName = BlendStrength
OptionName = C_BLEND_STRENGTH
MinValue = 0.000
MaxValue = 1.200
StepAmount = 0.010
DefaultValue = 1.000
[OptionRangeFloat]
GUIName = BloomDefocus
OptionName = D_B_DEFOCUS
MinValue = 1.000
MaxValue = 4.000
StepAmount = 0.100
DefaultValue = 2.000
[OptionRangeFloat]
GUIName = BloomWidth
OptionName = D_BLOOM_WIDTH
MinValue = 1.000
MaxValue = 8.000
StepAmount = 0.100
DefaultValue = 3.200
[OptionRangeFloat]
GUIName = BloomReds
OptionName = E_BLOOM_REDS
MinValue = 0.000
MaxValue = 0.500
StepAmount = 0.001
DefaultValue = 0.020
[OptionRangeFloat]
GUIName = BloomGreens
OptionName = F_BLOOM_GREENS
MinValue = 0.000
MaxValue = 0.500
StepAmount = 0.001
DefaultValue = 0.010
[OptionRangeFloat]
GUIName = BloomBlues
OptionName = G_BLOOM_BLUES
MinValue = 0.000
MaxValue = 0.500
StepAmount = 0.001
DefaultValue = 0.010
[/configuration]
*/
//Average relative luminance
CONSTANT float3 lumCoeff = float3(0.2126729, 0.7151522, 0.0721750);
float AvgLuminance(float3 color)
{
return sqrt(
(color.x * color.x * lumCoeff.x) +
(color.y * color.y * lumCoeff.y) +
(color.z * color.z * lumCoeff.z));
}
float smootherstep(float a, float b, float x)
{
x = saturate((x - a) / (b - a));
return x*x*x*(x*(x * 6.0 - 15.0) + 10.0);
}
float3 BlendAddLight(float3 bloom, float3 blend)
{
return saturate(bloom + blend);
}
float3 BlendScreen(float3 bloom, float3 blend)
{
return (bloom + blend) - (bloom * blend);
}
float3 BlendAddGlow(float3 bloom, float3 blend)
{
float glow = smootherstep(0.0, 1.0, AvgLuminance(bloom));
return lerp(saturate(bloom + blend),
(blend + blend) - (blend * blend), glow);
}
float3 BlendGlow(float3 bloom, float3 blend)
{
float glow = smootherstep(0.0, 1.0, AvgLuminance(bloom));
return lerp((bloom + blend) - (bloom * blend),
(blend + blend) - (blend * blend), glow);
}
float3 BlendLuma(float3 bloom, float3 blend)
{
float lumavg = smootherstep(0.0, 1.0, AvgLuminance(bloom + blend));
return lerp((bloom * blend), (1.0 -
((1.0 - bloom) * (1.0 - blend))), lumavg);
}
float3 BlendOverlay(float3 bloom, float3 blend)
{
float3 overlay = step(0.5, bloom);
return lerp((bloom * blend * 2.0), (1.0 - (2.0 *
(1.0 - bloom) * (1.0 - blend))), overlay);
}
float3 BloomCorrection(float3 color)
{
float3 bloom = color;
bloom.r = 2.0 / 3.0 * (1.0 - (bloom.r * bloom.r));
bloom.g = 2.0 / 3.0 * (1.0 - (bloom.g * bloom.g));
bloom.b = 2.0 / 3.0 * (1.0 - (bloom.b * bloom.b));
bloom.r = saturate(color.r + GetOption(E_BLOOM_REDS) * bloom.r);
bloom.g = saturate(color.g + GetOption(F_BLOOM_GREENS) * bloom.g);
bloom.b = saturate(color.b + GetOption(G_BLOOM_BLUES) * bloom.b);
color = saturate(bloom);
return color;
}
float4 PyramidFilter(float2 texcoord, float2 width)
{
float4 X = SampleLocation(texcoord + float2(0.5, 0.5) * width);
float4 Y = SampleLocation(texcoord + float2(-0.5, 0.5) * width);
float4 Z = SampleLocation(texcoord + float2(0.5, -0.5) * width);
float4 W = SampleLocation(texcoord + float2(-0.5, -0.5) * width);
return (X + Y + Z + W) / 4.0;
}
float3 Blend(float3 bloom, float3 blend)
{
if (GetOption(A_BLOOM_TYPE) == 0) { return BlendGlow(bloom, blend); }
else if (GetOption(A_BLOOM_TYPE) == 1) { return BlendAddGlow(bloom, blend); }
else if (GetOption(A_BLOOM_TYPE) == 2) { return BlendAddLight(bloom, blend); }
else if (GetOption(A_BLOOM_TYPE) == 3) { return BlendScreen(bloom, blend); }
else if (GetOption(A_BLOOM_TYPE) == 4) { return BlendLuma(bloom, blend); }
else /*if (GetOption(A_BLOOM_TYPE) == 5) */ { return BlendOverlay(bloom, blend); }
}
void main()
{
float4 color = Sample();
float2 texcoord = GetCoordinates();
float2 pixelSize = GetInvResolution();
float anflare = 4.0;
float2 defocus = float2(GetOption(D_B_DEFOCUS), GetOption(D_B_DEFOCUS));
float4 bloom = PyramidFilter(texcoord, pixelSize * defocus);
float2 dx = float2(pixelSize.x * GetOption(D_BLOOM_WIDTH), 0.0);
float2 dy = float2(0.0, pixelSize.y * GetOption(D_BLOOM_WIDTH));
float2 mdx = mul(dx, 2.0);
float2 mdy = mul(dy, 2.0);
float4 blend = bloom * 0.22520613262190495;
blend += 0.002589001911021066 * SampleLocation(texcoord - mdx + mdy);
blend += 0.010778807494659370 * SampleLocation(texcoord - dx + mdy);
blend += 0.024146616900339800 * SampleLocation(texcoord + mdy);
blend += 0.010778807494659370 * SampleLocation(texcoord + dx + mdy);
blend += 0.002589001911021066 * SampleLocation(texcoord + mdx + mdy);
blend += 0.010778807494659370 * SampleLocation(texcoord - mdx + dy);
blend += 0.044875475183061630 * SampleLocation(texcoord - dx + dy);
blend += 0.100529757860782610 * SampleLocation(texcoord + dy);
blend += 0.044875475183061630 * SampleLocation(texcoord + dx + dy);
blend += 0.010778807494659370 * SampleLocation(texcoord + mdx + dy);
blend += 0.024146616900339800 * SampleLocation(texcoord - mdx);
blend += 0.100529757860782610 * SampleLocation(texcoord - dx);
blend += 0.100529757860782610 * SampleLocation(texcoord + dx);
blend += 0.024146616900339800 * SampleLocation(texcoord + mdx);
blend += 0.010778807494659370 * SampleLocation(texcoord - mdx - dy);
blend += 0.044875475183061630 * SampleLocation(texcoord - dx - dy);
blend += 0.100529757860782610 * SampleLocation(texcoord - dy);
blend += 0.044875475183061630 * SampleLocation(texcoord + dx - dy);
blend += 0.010778807494659370 * SampleLocation(texcoord + mdx - dy);
blend += 0.002589001911021066 * SampleLocation(texcoord - mdx - mdy);
blend += 0.010778807494659370 * SampleLocation(texcoord - dx - mdy);
blend += 0.024146616900339800 * SampleLocation(texcoord - mdy);
blend += 0.010778807494659370 * SampleLocation(texcoord + dx - mdy);
blend += 0.002589001911021066 * SampleLocation(texcoord + mdx - mdy);
blend = lerp(color, blend, GetOption(C_BLEND_STRENGTH));
bloom.xyz = Blend(bloom.xyz, blend.xyz);
bloom.xyz = BloomCorrection(bloom.xyz);
color.a = AvgLuminance(color.xyz);
bloom.a = AvgLuminance(bloom.xyz);
bloom.a *= anflare;
SetOutput(lerp(color, bloom, GetOption(B_BLOOM_STRENGTH)));
}

174
data/resources/shaders/dolphinfx/celshading.glsl
View File

@@ -1,174 +0,0 @@
/*===============================================================================*\
|######################## [Dolphin FX Suite 2.20] #######################|
|########################## By Asmodean ##########################|
|| ||
|| 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. (C)2015 ||
|| ||
|#################################################################################|
\*===============================================================================*/
// Sourced from https://raw.githubusercontent.com/Asmodean-/dolphin/89d640cd557189bb5f921fc219150c74c39bdc55/Data/Sys/Shaders/DolphinFX.glsl with modifications.
/*
[configuration]
[OptionRangeFloat]
GUIName = EdgeStrength
OptionName = A_EDGE_STRENGTH
MinValue = 0.00
MaxValue = 4.00
StepAmount = 0.01
DefaultValue = 1.00
[OptionRangeFloat]
GUIName = EdgeFilter
OptionName = B_EDGE_FILTER
MinValue = 0.25
MaxValue = 1.00
StepAmount = 0.01
DefaultValue = 0.60
[OptionRangeFloat]
GUIName = EdgeThickness
OptionName = C_EDGE_THICKNESS
MinValue = 0.25
MaxValue = 2.00
StepAmount = 0.01
DefaultValue = 1.00
[OptionRangeInteger]
GUIName = PaletteType
OptionName = D_PALETTE_TYPE
MinValue = 0
MaxValue = 2
StepAmount = 1
DefaultValue = 1
[OptionRangeInteger]
GUIName = UseYuvLuma
OptionName = E_YUV_LUMA
MinValue = 0
MaxValue = 1
StepAmount = 1
DefaultValue = 0
[OptionRangeInteger]
GUIName = ColourRounding
OptionName = G_COLOR_ROUNDING
MinValue = 0
MaxValue = 1
StepAmount = 1
DefaultValue = 1
[/configuration]
*/
//Average relative luminance
CONSTANT float3 lumCoeff = float3(0.2126729, 0.7151522, 0.0721750);
float AvgLuminance(float3 color)
{
return sqrt(
(color.x * color.x * lumCoeff.x) +
(color.y * color.y * lumCoeff.y) +
(color.z * color.z * lumCoeff.z));
}
float3 YUVtoRGB(float3 YUV)
{
const float3x3 m = float3x3(
1.000, 0.000, 1.28033,
1.000,-0.21482,-0.38059,
1.000, 2.12798, 0.000 );
return mul(m, YUV);
}
float3 RGBtoYUV(float3 RGB)
{
const float3x3 m = float3x3(
0.2126, 0.7152, 0.0722,
-0.09991,-0.33609, 0.436,
0.615, -0.55861, -0.05639 );
return mul(m, RGB);
}
void main()
{
float4 color = Sample();
float2 texcoord = GetCoordinates();
float2 pixelSize = GetInvResolution();
float2 texSize = GetResolution();
float3 yuv;
float3 sum = color.rgb;
const int NUM = 9;
const float2 RoundingOffset = float2(0.25, 0.25);
const float3 thresholds = float3(9.0, 8.0, 6.0);
float lum[NUM];
float3 col[NUM];
float2 set[NUM] = BEGIN_ARRAY(float2, NUM)
float2(-0.0078125, -0.0078125),
float2(0.00, -0.0078125),
float2(0.0078125, -0.0078125),
float2(-0.0078125, 0.00),
float2(0.00, 0.00),
float2(0.0078125, 0.00),
float2(-0.0078125, 0.0078125),
float2(0.00, 0.0078125),
float2(0.0078125, 0.0078125) END_ARRAY;
for (int i = 0; i < NUM; i++)
{
col[i] = SampleLocation(texcoord + set[i] * RoundingOffset).rgb;
if (GetOption(G_COLOR_ROUNDING) == 1) {
col[i].r = round(col[i].r * thresholds.r) / thresholds.r;
col[i].g = round(col[i].g * thresholds.g) / thresholds.g;
col[i].b = round(col[i].b * thresholds.b) / thresholds.b; }
lum[i] = AvgLuminance(col[i].xyz);
yuv = RGBtoYUV(col[i]);
if (GetOption(E_YUV_LUMA) == 0)
{ yuv.r = round(yuv.r * thresholds.r) / thresholds.r; }
else
{ yuv.r = saturate(round(yuv.r * lum[i]) / thresholds.r + lum[i]); }
yuv = YUVtoRGB(yuv);
sum += yuv;
}
float3 shadedColor = (sum / NUM);
float2 pixel = float2((1.0/texSize.x) * GetOption(C_EDGE_THICKNESS),
(1.0/texSize.y) * GetOption(C_EDGE_THICKNESS));
float edgeX = dot(SampleLocation(texcoord + pixel).rgb, lumCoeff);
edgeX = dot(float4(SampleLocation(texcoord - pixel).rgb, edgeX), float4(lumCoeff, -1.0));
float edgeY = dot(SampleLocation(texcoord + float2(pixel.x, -pixel.y)).rgb, lumCoeff);
edgeY = dot(float4(SampleLocation(texcoord + float2(-pixel.x, pixel.y)).rgb, edgeY), float4(lumCoeff, -1.0));
float edge = dot(float2(edgeX, edgeY), float2(edgeX, edgeY));
if (GetOption(D_PALETTE_TYPE) == 0)
{ color.rgb = lerp(color.rgb, color.rgb + pow(edge, GetOption(B_EDGE_FILTER)) * -GetOption(A_EDGE_STRENGTH), GetOption(A_EDGE_STRENGTH)); }
else if (GetOption(D_PALETTE_TYPE) == 1)
{ color.rgb = lerp(color.rgb + pow(edge, GetOption(B_EDGE_FILTER)) * -GetOption(A_EDGE_STRENGTH), shadedColor, 0.25); }
else if (GetOption(D_PALETTE_TYPE) == 2)
{ color.rgb = lerp(shadedColor + edge * -GetOption(A_EDGE_STRENGTH), pow(edge, GetOption(B_EDGE_FILTER)) * -GetOption(A_EDGE_STRENGTH) + color.rgb, 0.50); }
color.a = AvgLuminance(color.rgb);
SetOutput(saturate(color));
}

277
data/resources/shaders/dolphinfx/crt/CRT-EASYMODE.glsl
View File

@@ -1,277 +0,0 @@
// CRT Shader by EasyMode
// License: GPL
// A flat CRT shader ideally for 1080p or higher displays.
// Recommended Settings:
// Video
// - Aspect Ratio: 4:3
// - Integer Scale: Off
// Shader
// - Filter: Nearest
// - Scale: Don't Care
// Example RGB Mask Parameter Settings:
// Aperture Grille (Default)
// - Dot Width: 1
// - Dot Height: 1
// - Stagger: 0
// Lottes' Shadow Mask
// - Dot Width: 2
// - Dot Height: 1
// - Stagger: 3
/*
[configuration]
[OptionRangeFloat]
GUIName = Sharpness Horizontal
OptionName = SHARPNESS_H
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 0.5
[OptionRangeFloat]
GUIName = Sharpness Vertical
OptionName = SHARPNESS_V
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 1.0
[OptionRangeFloat]
GUIName = Mask Strength
OptionName = MASK_STRENGTH
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.01
DefaultValue = 0.3
[OptionRangeFloat]
GUIName = Mask Dot Width
OptionName = MASK_DOT_WIDTH
MinValue = 1.0
MaxValue = 100.0
StepAmount = 1.0
DefaultValue = 1.0
[OptionRangeFloat]
GUIName = Mask Dot Height
OptionName = MASK_DOT_HEIGHT
MinValue = 1.0
MaxValue = 100.0
StepAmount = 1.0
DefaultValue = 1.0
[OptionRangeFloat]
GUIName = Mask Stagger
OptionName = MASK_STAGGER
MinValue = 0.0
MaxValue = 100.0
StepAmount = 1.0
DefaultValue = 0.0
[OptionRangeFloat]
GUIName = Mask Size
OptionName = MASK_SIZE
MinValue = 1.0
MaxValue = 100.0
StepAmount = 1.0
DefaultValue = 1.0
[OptionRangeFloat]
GUIName = Scanline Strength
OptionName = SCANLINE_STRENGTH
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 1.0
[OptionRangeFloat]
GUIName = Scanline Beam Width Min.
OptionName = SCANLINE_BEAM_WIDTH_MIN
MinValue = 0.5
MaxValue = 5.0
StepAmount = 0.5
DefaultValue = 1.5
[OptionRangeFloat]
GUIName = Scanline Beam Width Max.
OptionName = SCANLINE_BEAM_WIDTH_MAX
MinValue = 0.5
MaxValue = 5.0
StepAmount = 0.5
DefaultValue = 1.5
[OptionRangeFloat]
GUIName = Scanline Brightness Min.
OptionName = SCANLINE_BRIGHT_MIN
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 0.35
[OptionRangeFloat]
GUIName = Scanline Brightness Max.
OptionName = SCANLINE_BRIGHT_MAX
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 0.65
[OptionRangeFloat]
GUIName = Scanline Cutoff
OptionName = SCANLINE_CUTOFF
MinValue = 1.0
MaxValue = 1000.0
StepAmount = 1.0
DefaultValue = 400.0
[OptionRangeFloat]
GUIName = Gamma Input
OptionName = GAMMA_INPUT
MinValue = 0.1
MaxValue = 5.0
StepAmount = 0.1
DefaultValue = 2.0
[OptionRangeFloat]
GUIName = Gamma Output
OptionName = GAMMA_OUTPUT
MinValue = 0.1
MaxValue = 5.0
StepAmount = 0.1
DefaultValue = 1.8
[OptionRangeFloat]
GUIName = Brightness Boost
OptionName = BRIGHT_BOOST
MinValue = 1.0
MaxValue = 2.0
StepAmount = 0.01
DefaultValue = 1.2
[OptionRangeFloat]
GUIName = Dilation
OptionName = DILATION
MinValue = 0.0
MaxValue = 1.0
StepAmount = 1.0
DefaultValue = 1.0
[/configuration]
*/
#define FIX(c) max(abs(c), 1e-5)
#define PI 3.141592653589
#define TEX2D(c) dilate(SampleLocation(c))
// Set to 0 to use linear filter and gain speed
#define ENABLE_LANCZOS 1
vec4 dilate(vec4 col)
{
vec4 x = mix(vec4(1.0), col, GetOption(DILATION));
return col * x;
}
float curve_distance(float x, float sharp)
{
/*
apply half-circle s-curve to distance for sharper (more pixelated) interpolation
single line formula for Graph Toy:
0.5 - sqrt(0.25 - (x - step(0.5, x)) * (x - step(0.5, x))) * sign(0.5 - x)
*/
float x_step = step(0.5, x);
float curve = 0.5 - sqrt(0.25 - (x - x_step) * (x - x_step)) * sign(0.5 - x);
return mix(x, curve, sharp);
}
mat4x4 get_color_matrix(vec2 co, vec2 dx)
{
return mat4x4(TEX2D(co - dx), TEX2D(co), TEX2D(co + dx), TEX2D(co + 2.0 * dx));
}
vec3 filter_lanczos(vec4 coeffs, mat4x4 color_matrix)
{
vec4 col = color_matrix * coeffs;
vec4 sample_min = min(color_matrix[1], color_matrix[2]);
vec4 sample_max = max(color_matrix[1], color_matrix[2]);
col = clamp(col, sample_min, sample_max);
return col.rgb;
}
void main()
{
vec2 vTexCoord = GetCoordinates();
vec2 nativeSize = 1.0 / GetInvNativePixelSize();
vec4 SourceSize = vec4(nativeSize, 1.0/nativeSize);
vec2 dx = vec2(SourceSize.z, 0.0);
vec2 dy = vec2(0.0, SourceSize.w);
vec2 pix_co = vTexCoord * SourceSize.xy - vec2(0.5, 0.5);
vec2 tex_co = (floor(pix_co) + vec2(0.5, 0.5)) * SourceSize.zw;
vec2 dist = fract(pix_co);
float curve_x;
vec3 col, col2;
#if ENABLE_LANCZOS
curve_x = curve_distance(dist.x, GetOption(SHARPNESS_H) * GetOption(SHARPNESS_H));
vec4 coeffs = PI * vec4(1.0 + curve_x, curve_x, 1.0 - curve_x, 2.0 - curve_x);
coeffs = FIX(coeffs);
coeffs = 2.0 * sin(coeffs) * sin(coeffs * 0.5) / (coeffs * coeffs);
coeffs /= dot(coeffs, vec4(1.0));
col = filter_lanczos(coeffs, get_color_matrix(tex_co, dx));
col2 = filter_lanczos(coeffs, get_color_matrix(tex_co + dy, dx));
#else
curve_x = curve_distance(dist.x, GetOption(SHARPNESS_H));
col = mix(TEX2D(tex_co).rgb, TEX2D(tex_co + dx).rgb, curve_x);
col2 = mix(TEX2D(tex_co + dy).rgb, TEX2D(tex_co + dx + dy).rgb, curve_x);
#endif
col = mix(col, col2, curve_distance(dist.y, GetOption(SHARPNESS_V)));
col = pow(col, vec3(GetOption(GAMMA_INPUT) / (GetOption(DILATION) + 1.0)));
float luma = dot(vec3(0.2126, 0.7152, 0.0722), col);
float bright = (max(col.r, max(col.g, col.b)) + luma) * 0.5;
float scan_bright = clamp(bright, GetOption(SCANLINE_BRIGHT_MIN), GetOption(SCANLINE_BRIGHT_MAX));
float scan_beam = clamp(bright * GetOption(SCANLINE_BEAM_WIDTH_MAX), GetOption(SCANLINE_BEAM_WIDTH_MIN), GetOption(SCANLINE_BEAM_WIDTH_MAX));
float scan_weight = 1.0 - pow(cos(vTexCoord.y * 2.0 * PI * SourceSize.y) * 0.5 + 0.5, scan_beam) * GetOption(SCANLINE_STRENGTH);
float mask = 1.0 - GetOption(MASK_STRENGTH);
vec2 mod_fac = floor(vTexCoord * GetWindowSize().xy * SourceSize.xy / (SourceSize.xy * vec2(GetOption(MASK_SIZE), GetOption(MASK_DOT_HEIGHT) * GetOption(MASK_SIZE))));
int dot_no = int(mod((mod_fac.x + mod(mod_fac.y, 2.0) * GetOption(MASK_STAGGER)) / GetOption(MASK_DOT_WIDTH), 3.0));
vec3 mask_weight;
if (dot_no == 0) mask_weight = vec3(1.0, mask, mask);
else if (dot_no == 1) mask_weight = vec3(mask, 1.0, mask);
else mask_weight = vec3(mask, mask, 1.0);
if (SourceSize.y >= GetOption(SCANLINE_CUTOFF))
scan_weight = 1.0;
col2 = col.rgb;
col *= vec3(scan_weight);
col = mix(col, col2, scan_bright);
col *= mask_weight;
col = pow(col, vec3(1.0 / GetOption(GAMMA_OUTPUT)));
SetOutput(vec4(col * GetOption(BRIGHT_BOOST), 1.0));
}

180
data/resources/shaders/dolphinfx/crt/ZFAST-CRT-COMPOSITE.glsl
View File

@@ -1,180 +0,0 @@
// zfast_crt - A very simple CRT shader.
// Copyright (C) 2017 Greg Hogan (SoltanGris42)
// edited by metallic 77.
// ported to slang by gregoricavichioli & hunterk.
// ported to dolphinfx by Hyllian.
// 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.
/*
[configuration]
[OptionRangeFloat]
GUIName = Curvature
OptionName = Curvature
MinValue = 0.0
MaxValue = 1.0
StepAmount = 1.0
DefaultValue = 1.0
[OptionRangeFloat]
GUIName = Convergence X-Axis
OptionName = blurx
MinValue = -1.0
MaxValue = 2.0
StepAmount = 0.05
DefaultValue = 0.85
[OptionRangeFloat]
GUIName = Convergence Y-Axis
OptionName = blury
MinValue = -1.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = -0.10
[OptionRangeFloat]
GUIName = Scanline Amount (Low)
OptionName = HIGHSCANAMOUNT1
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 0.4
[OptionRangeFloat]
GUIName = Scanline Amount (High)
OptionName = HIGHSCANAMOUNT2
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 0.3
[OptionRangeFloat]
GUIName = Mask Type
OptionName = TYPE
MinValue = 0.0
MaxValue = 1.0
StepAmount = 1.0
DefaultValue = 0.0
[OptionRangeFloat]
GUIName = Mask Effect Amount
OptionName = MASK_DARK
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 0.3
[OptionRangeFloat]
GUIName = Mask/Scanline Fade
OptionName = MASK_FADE
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.05
DefaultValue = 0.7
[OptionRangeFloat]
GUIName = Saturation
OptionName = sat
MinValue = 0.0
MaxValue = 3.0
StepAmount = 0.05
DefaultValue = 1.0
[OptionRangeFloat]
GUIName = Flicker
OptionName = FLICK
MinValue = 0.0
MaxValue = 50.0
StepAmount = 1.0
DefaultValue = 10.0
[/configuration]
*/
#define pi 3.14159
#define blur_y GetOption(blury)/(SourceSize.y*2.0)
#define blur_x GetOption(blurx)/(SourceSize.x*2.0)
#define iTimer (float(GetTime())*2.0)
#define flicker GetOption(FLICK)/1000.0
// Distortion of scanlines, and end of screen alpha.
vec2 Warp(vec2 pos)
{
pos = pos*2.0-1.0;
pos *= vec2(1.0 + (pos.y*pos.y)*0.03, 1.0 + (pos.x*pos.x)*0.05);
return pos*0.5 + 0.5;
}
void main()
{
vec2 vTexCoord = GetCoordinates();
vec2 texSize = 1.0 / GetInvNativePixelSize();
vec4 SourceSize = vec4(texSize, 1.0 / texSize);
float maskFade = 0.3333*GetOption(MASK_FADE);
float omega = 2.0*pi*SourceSize.y;
vec2 pos,corn;
if (GetOption(Curvature) == 1.0)
{
pos = Warp(vTexCoord.xy);
corn = min(pos,vec2(1.0)-pos); // This is used to mask the rounded
corn.x = 0.00001/corn.x; // corners later on
}
else pos = vTexCoord;
float OGL2Pos = pos.y*SourceSize.y;
float cent = floor(OGL2Pos)+0.5;
float ycoord = cent*SourceSize.w;
ycoord = mix(pos.y,ycoord,0.6);
pos = vec2(pos.x,ycoord);
vec3 sample1 = sin(iTimer)*flicker + SampleLocation(vec2(pos.x + blur_x, pos.y - blur_y)).rgb;
vec3 sample2 = 0.5*SampleLocation(pos).rgb;
vec3 sample3 = sin(iTimer)*flicker + SampleLocation(vec2(pos.x - blur_x, pos.y + blur_y)).rgb;
vec3 colour = vec3 (sample1.r*0.5 + sample2.r,
sample1.g*0.25 + sample2.g + sample3.g*0.25,
sample2.b + sample3.b*0.5);
vec3 interl = colour;
vec3 lumweight=vec3(0.22,0.71,0.07);
float lumsat = dot(colour,lumweight);
vec3 graycolour = vec3(lumsat);
colour = vec3(mix(graycolour,colour.rgb,sat));
float SCANAMOUNT = mix(GetOption(HIGHSCANAMOUNT1),GetOption(HIGHSCANAMOUNT2),max(max(colour.r,colour.g),colour.b));
if (SourceSize.y > 400.0) {
colour ;
}
else {
colour *= SCANAMOUNT * sin(fract(OGL2Pos)*3.14159)+1.0-SCANAMOUNT;
colour *= SCANAMOUNT * sin(fract(1.0-OGL2Pos)*3.14159)+1.0-SCANAMOUNT;
colour *= SCANAMOUNT * sin(fract(1.0+OGL2Pos)*3.14159)+1.0-SCANAMOUNT;
}
float steps; if (GetOption(TYPE) == 0.0) steps = 0.5; else steps = 0.3333;
float whichmask = fract(vTexCoord.x*GetWindowSize().x*steps);
float mask = 1.0 + float(whichmask < steps) * (-GetOption(MASK_DARK));
colour.rgb = mix(mask*colour, colour, dot(colour.rgb,vec3(maskFade)));
if (GetOption(Curvature) == 1.0 && corn.y < corn.x || GetOption(Curvature) == 1.0 && corn.x < 0.00001 )
colour = vec3(0.0);
SetOutput(vec4(colour.rgb, 1.0));
}

144
data/resources/shaders/dolphinfx/interpolation/JINC2.glsl
View File

@@ -1,144 +0,0 @@
// Hyllian's jinc windowed-jinc 2-lobe with anti-ringing Shader
// Copyright (C) 2011-2024 Hyllian - sergiogdb@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.
/*
[configuration]
[OptionRangeFloat]
GUIName = Window Sinc Param
OptionName = JINC2_WINDOW_SINC
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.01
DefaultValue = 0.50
[OptionRangeFloat]
GUIName = Sinc Param
OptionName = JINC2_SINC
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.01
DefaultValue = 0.88
[OptionRangeFloat]
GUIName = Anti-ringing Strength
OptionName = JINC2_AR_STRENGTH
MinValue = 0.0
MaxValue = 1.0
StepAmount = 0.1
DefaultValue = 0.5
[/configuration]
*/
#define halfpi 1.5707963267948966192313216916398
#define pi 3.1415926535897932384626433832795
#define wa (JINC2_WINDOW_SINC*pi)
#define wb (JINC2_SINC*pi)
// Calculates the distance between two points
float d(vec2 pt1, vec2 pt2)
{
vec2 v = pt2 - pt1;
return sqrt(dot(v,v));
}
vec3 min4(vec3 a, vec3 b, vec3 c, vec3 d)
{
return min(a, min(b, min(c, d)));
}
vec3 max4(vec3 a, vec3 b, vec3 c, vec3 d)
{
return max(a, max(b, max(c, d)));
}
vec4 resampler(vec4 x)
{
vec4 res;
res.x = (x.x==0.0) ? wa*wb : sin(x.x*wa)*sin(x.x*wb)/(x.x*x.x);
res.y = (x.y==0.0) ? wa*wb : sin(x.y*wa)*sin(x.y*wb)/(x.y*x.y);
res.z = (x.z==0.0) ? wa*wb : sin(x.z*wa)*sin(x.z*wb)/(x.z*x.z);
res.w = (x.w==0.0) ? wa*wb : sin(x.w*wa)*sin(x.w*wb)/(x.w*x.w);
return res;
}
void main()
{
vec2 SourceSize = 1.0 / GetInvNativePixelSize();
vec2 invSourceSize = 1.0 / SourceSize;
vec2 vTexCoord = GetCoordinates();
vec3 color;
mat4x4 weights;
vec2 dx = vec2(1.0, 0.0);
vec2 dy = vec2(0.0, 1.0);
vec2 pc = vTexCoord*SourceSize;
vec2 tc = (floor(pc-vec2(0.5,0.5))+vec2(0.5,0.5));
weights[0] = resampler(vec4(d(pc, tc -dx -dy), d(pc, tc -dy), d(pc, tc +dx -dy), d(pc, tc+2.0*dx -dy)));
weights[1] = resampler(vec4(d(pc, tc -dx ), d(pc, tc ), d(pc, tc +dx ), d(pc, tc+2.0*dx )));
weights[2] = resampler(vec4(d(pc, tc -dx +dy), d(pc, tc +dy), d(pc, tc +dx +dy), d(pc, tc+2.0*dx +dy)));
weights[3] = resampler(vec4(d(pc, tc -dx+2.0*dy), d(pc, tc +2.0*dy), d(pc, tc +dx+2.0*dy), d(pc, tc+2.0*dx+2.0*dy)));
dx = dx * invSourceSize;
dy = dy * invSourceSize;
tc = tc * invSourceSize;
// reading the texels
vec3 c00 = SampleLocation(tc -dx -dy).xyz;
vec3 c10 = SampleLocation(tc -dy).xyz;
vec3 c20 = SampleLocation(tc +dx -dy).xyz;
vec3 c30 = SampleLocation(tc+2.0*dx -dy).xyz;
vec3 c01 = SampleLocation(tc -dx ).xyz;
vec3 c11 = SampleLocation(tc ).xyz;
vec3 c21 = SampleLocation(tc +dx ).xyz;
vec3 c31 = SampleLocation(tc+2.0*dx ).xyz;
vec3 c02 = SampleLocation(tc -dx +dy).xyz;
vec3 c12 = SampleLocation(tc +dy).xyz;
vec3 c22 = SampleLocation(tc +dx +dy).xyz;
vec3 c32 = SampleLocation(tc+2.0*dx +dy).xyz;
vec3 c03 = SampleLocation(tc -dx+2.0*dy).xyz;
vec3 c13 = SampleLocation(tc +2.0*dy).xyz;
vec3 c23 = SampleLocation(tc +dx+2.0*dy).xyz;
vec3 c33 = SampleLocation(tc+2.0*dx+2.0*dy).xyz;
// Get min/max samples
vec3 min_sample = min4(c11, c21, c12, c22);
vec3 max_sample = max4(c11, c21, c12, c22);
color = mat4x3(c00, c10, c20, c30) * weights[0];
color+= mat4x3(c01, c11, c21, c31) * weights[1];
color+= mat4x3(c02, c12, c22, c32) * weights[2];
color+= mat4x3(c03, c13, c23, c33) * weights[3];
color = color/(dot(weights * vec4(1.0), vec4(1.0)));
// Anti-ringing
vec3 aux = color;
color = clamp(color, min_sample, max_sample);
color = mix(aux, color, JINC2_AR_STRENGTH);
// final sum and weight normalization
SetOutput(vec4(color, 1.0));
}

120
data/resources/shaders/dolphinfx/scanlines.glsl
View File

@@ -1,120 +0,0 @@
/*===============================================================================*\
|######################## [Dolphin FX Suite 2.20] #######################|
|########################## By Asmodean ##########################|
|| ||
|| 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. (C)2015 ||
|| ||
|#################################################################################|
\*===============================================================================*/
// Sourced from https://raw.githubusercontent.com/Asmodean-/dolphin/89d640cd557189bb5f921fc219150c74c39bdc55/Data/Sys/Shaders/DolphinFX.glsl with modifications.
/*
[configuration]
[OptionRangeInteger]
GUIName = ScanlineType
OptionName = A_SCANLINE_TYPE
MinValue = 0
MaxValue = 2
StepAmount = 1
DefaultValue = 0
[OptionRangeFloat]
GUIName = ScanlineIntensity
OptionName = B_SCANLINE_INTENSITY
MinValue = 0.15
MaxValue = 0.30
StepAmount = 0.01
DefaultValue = 0.18
[OptionRangeFloat]
GUIName = ScanlineThickness
OptionName = B_SCANLINE_THICKNESS
MinValue = 0.20
MaxValue = 0.80
StepAmount = 0.01
DefaultValue = 0.50
[OptionRangeFloat]
GUIName = ScanlineBrightness
OptionName = B_SCANLINE_BRIGHTNESS
MinValue = 0.50
MaxValue = 2.00
StepAmount = 0.01
DefaultValue = 1.10
[OptionRangeFloat]
GUIName = ScanlineSpacing
OptionName = B_SCANLINE_SPACING
MinValue = 0.10
MaxValue = 0.99
StepAmount = 0.01
DefaultValue = 0.25
[/configuration]
*/
//Average relative luminance
CONSTANT float3 lumCoeff = float3(0.2126729, 0.7151522, 0.0721750);
float AvgLuminance(float3 color)
{
return sqrt(
(color.x * color.x * lumCoeff.x) +
(color.y * color.y * lumCoeff.y) +
(color.z * color.z * lumCoeff.z));
}
void main()
{
float4 color = Sample();
float4 intensity = float4(0.0, 0.0, 0.0, 0.0);
if (GetOption(A_SCANLINE_TYPE) == 0) { //X coord scanlines
if (fract(gl_FragCoord.y * GetOption(B_SCANLINE_SPACING)) > GetOption(B_SCANLINE_THICKNESS))
{
intensity = float4(0.0, 0.0, 0.0, 0.0);
}
else
{
intensity = smoothstep(0.2, GetOption(B_SCANLINE_BRIGHTNESS), color) +
normalize(float4(color.xyz, AvgLuminance(color.xyz)));
} }
else if (GetOption(A_SCANLINE_TYPE) == 1) { //Y coord scanlines
if (fract(gl_FragCoord.x * GetOption(B_SCANLINE_SPACING)) > GetOption(B_SCANLINE_THICKNESS))
{
intensity = float4(0.0, 0.0, 0.0, 0.0);
}
else
{
intensity = smoothstep(0.2, GetOption(B_SCANLINE_BRIGHTNESS), color) +
normalize(float4(color.xyz, AvgLuminance(color.xyz)));
} }
else if (GetOption(A_SCANLINE_TYPE) == 2) { //XY coord scanlines
if (fract(gl_FragCoord.x * GetOption(B_SCANLINE_SPACING)) > GetOption(B_SCANLINE_THICKNESS) &&
fract(gl_FragCoord.y * GetOption(B_SCANLINE_SPACING)) > GetOption(B_SCANLINE_THICKNESS))
{
intensity = float4(0.0, 0.0, 0.0, 0.0);
}
else
{
intensity = smoothstep(0.2, GetOption(B_SCANLINE_BRIGHTNESS), color) +
normalize(float4(color.xyz, AvgLuminance(color.xyz)));
} }
float level = (4.0-GetCoordinates().x) * GetOption(B_SCANLINE_INTENSITY);
color = intensity * (0.5 - level) + color * 1.1;
SetOutput(saturate(color));
}