alex/slang-shaders
1
0
Fork 0
mirror of https://github.com/italicsjenga/slang-shaders.git synced 2024-11-29 19:01:31 +11:00
Code Issues Packages Projects Releases Wiki Activity

Some MAD optimizations.

Browse source 
Style nits: Replaced tabs with spaces, 4-space tabs, 80 char general
limit, etc.
This commit is contained in:
Arzed Five 2016-07-20 22:50:07 +01:00
parent 95fce03925
commit 18a6182b0d
5 changed files with 334 additions and 253 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

101
handheld/gameboy/shader-files/gb-pass0.slang
View file

@ -15,11 +15,17 @@ layout(std140, set = 0, binding = 0) uniform UBO
vec4 OriginalHistorySize7; vec4 OriginalHistorySize7;
} global; } global;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//config // // Config //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#define baseline_alpha 0.10 //the alpha value of dots in their "off" state, does not affect the border region of the screen - [0, 1]
#define response_time 0.333 //simulate response time, higher values result in longer color transition periods - [0, 1] // The alpha value of dots in their "off" state
// Does not affect the border region of the screen - [0, 1]
#define baseline_alpha 0.10
// Simulate response time
// Higher values result in longer color transition periods - [0, 1]
#define response_time 0.333
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// // // //
@ -42,44 +48,46 @@ layout(std140, set = 0, binding = 0) uniform UBO
// // // //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Vertex shader //
//vertex shader // ////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma stage vertex #pragma stage vertex
layout(location = 0) in vec4 Position; layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord; layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord; layout(location = 0) out vec2 vTexCoord;
layout(location = 1) out vec2 tex;
layout(location = 2) out vec2 dot_size; layout(location = 2) out vec2 dot_size;
layout(location = 3) out vec2 one_texel; layout(location = 3) out vec2 one_texel;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//vertex definitions // // Vertex definitions //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#define video_scale floor(global.OutputSize.y / global.SourceSize.y) //largest integer scale of input video that will fit in the current output (y axis would typically be limiting on widescreens)
#define scaled_video_out (global.SourceSize.xy * vec2(video_scale)) //size of the scaled video // Largest integer scale of input video that will fit in the current output (y axis would typically be limiting on widescreens)
#define half_pixel (vec2(0.5) / global.OutputSize.xy) //it's... half a pixel #define video_scale floor(global.OutputSize.y / global.SourceSize.y)
// Size of the scaled video
#define scaled_video_out (global.SourceSize.xy * vec2(video_scale))
//it's... half a pixel
#define half_pixel (vec2(0.5) / global.OutputSize.xy)
void main() void main()
{ {
// Remaps position to integer scaled output
gl_Position = global.MVP * Position / vec4( vec2(global.OutputSize.xy / scaled_video_out), 1.0, 1.0 ); gl_Position = global.MVP * Position / vec4( vec2(global.OutputSize.xy / scaled_video_out), 1.0, 1.0 );
vTexCoord = TexCoord + half_pixel; vTexCoord = TexCoord + half_pixel;
tex = floor(global.OriginalHistorySize1.xy * vTexCoord); dot_size = global.SourceSize.zw;
tex = (tex + 0.5) * global.OriginalHistorySize1.zw;
dot_size = 1.0 / global.SourceSize.xy;
one_texel = 1.0 / (global.SourceSize.xy * video_scale); one_texel = 1.0 / (global.SourceSize.xy * video_scale);
} }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//fragment shader // // Fragment shader //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#pragma stage fragment #pragma stage fragment
layout(location = 0) in vec2 vTexCoord; layout(location = 0) in vec2 vTexCoord;
layout(location = 1) in vec2 tex;
layout(location = 2) in vec2 dot_size; layout(location = 2) in vec2 dot_size;
layout(location = 3) in vec2 one_texel; layout(location = 3) in vec2 one_texel;
layout(location = 0) out vec4 FragColor; layout(location = 0) out vec4 FragColor;
@ -92,36 +100,35 @@ layout(set = 0, binding = 7) uniform sampler2D OriginalHistory5;
layout(set = 0, binding = 8) uniform sampler2D OriginalHistory6; layout(set = 0, binding = 8) uniform sampler2D OriginalHistory6;
layout(set = 0, binding = 9) uniform sampler2D OriginalHistory7; layout(set = 0, binding = 9) uniform sampler2D OriginalHistory7;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//fragment definitions // //fragment definitions //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#define foreground_color vec3(0.11, 0.4141, 0.41) //tex2D(COLOR_PALETTE, fixed2(0.75, 0.5)).rgb //hardcoded to look up the foreground color from the right half of the palette image #define foreground_color vec3(0.11, 0.4141, 0.41) //tex2D(COLOR_PALETTE, fixed2(0.75, 0.5)).rgb //hardcoded to look up the foreground color from the right half of the palette image
//#define rgb_to_alpha(rgb) ( ((rgb.r + rgb.g + rgb.b) / 3.0) + (is_on_dot * vec2(baseline_alpha), 1.0) ) //averages rgb values (allows it to work with color games), modified for contrast and base alpha //#define rgb_to_alpha(rgb) ( ((rgb.r + rgb.g + rgb.b) / 3.0) + (is_on_dot * vec2(baseline_alpha), 1.0) ) //averages rgb values (allows it to work with color games), modified for contrast and base alpha
//frame sampling definitions // Frame sampling definitions
#define curr_rgb abs(1.0 - texture(Source, vTexCoord).rgb) #define curr_rgb abs(1.0 - texture(Source, vTexCoord).rgb)
#define prev0_rgb abs(1.0 - texture(OriginalHistory1, tex).rgb) #define prev0_rgb abs(1.0 - texture(OriginalHistory1, vTexCoord).rgb)
#define prev1_rgb abs(1.0 - texture(OriginalHistory2, tex).rgb) #define prev1_rgb abs(1.0 - texture(OriginalHistory2, vTexCoord).rgb)
#define prev2_rgb abs(1.0 - texture(OriginalHistory3, tex).rgb) #define prev2_rgb abs(1.0 - texture(OriginalHistory3, vTexCoord).rgb)
#define prev3_rgb abs(1.0 - texture(OriginalHistory4, tex).rgb) #define prev3_rgb abs(1.0 - texture(OriginalHistory4, vTexCoord).rgb)
#define prev4_rgb abs(1.0 - texture(OriginalHistory5, tex).rgb) #define prev4_rgb abs(1.0 - texture(OriginalHistory5, vTexCoord).rgb)
#define prev5_rgb abs(1.0 - texture(OriginalHistory6, tex).rgb) #define prev5_rgb abs(1.0 - texture(OriginalHistory6, vTexCoord).rgb)
#define prev6_rgb abs(1.0 - texture(OriginalHistory7, tex).rgb) #define prev6_rgb abs(1.0 - texture(OriginalHistory7, vTexCoord).rgb)
void main() void main()
{ {
//determine if the corrent texel lies on a dot or in the space between dots // Determine if the corrent texel lies on a dot or in the space between dots
float is_on_dot; float is_on_dot;
if ( mod(vTexCoord.x, dot_size.x) > one_texel.x && mod(vTexCoord.y, dot_size.y) > one_texel.y ) if ( mod(vTexCoord.x, dot_size.x) > one_texel.x && mod(vTexCoord.y, dot_size.y) > one_texel.y )
{is_on_dot = 1.0;} is_on_dot = 1.0;
else else
{is_on_dot = 0.0;} is_on_dot = 0.0;
//sample color from the current and previous frames, apply response time modifier // Sample color from the current and previous frames, apply response time modifier
//response time effect implmented through an exponential dropoff algorithm // Response time effect implmented through an exponential dropoff algorithm
vec3 input_rgb = curr_rgb; vec3 input_rgb = curr_rgb;
input_rgb += (prev0_rgb - input_rgb) * response_time; input_rgb += (prev0_rgb - input_rgb) * response_time;
input_rgb += (prev1_rgb - input_rgb) * pow(response_time, 2.0); input_rgb += (prev1_rgb - input_rgb) * pow(response_time, 2.0);
@ -131,14 +138,16 @@ vec3 input_rgb = curr_rgb;
input_rgb += (prev5_rgb - input_rgb) * pow(response_time, 6.0); input_rgb += (prev5_rgb - input_rgb) * pow(response_time, 6.0);
input_rgb += (prev6_rgb - input_rgb) * pow(response_time, 7.0); input_rgb += (prev6_rgb - input_rgb) * pow(response_time, 7.0);
vec2 rgb_to_alpha = vec2((input_rgb.r + input_rgb.g + input_rgb.b) / 3.0) + (is_on_dot * baseline_alpha); float rgb_to_alpha = (input_rgb.r + input_rgb.g + input_rgb.b) / 3.0 + (is_on_dot * baseline_alpha);
//apply foreground color and assign alpha value // Apply foreground color and assign alpha value
vec4 out_color = vec4(foreground_color, rgb_to_alpha); //apply the foreground color to all texels (the color will be modified by alpha later) and assign alpha based on rgb input // Apply the foreground color to all texels -
// the color will be modified by alpha later - and assign alpha based on rgb input
vec4 out_color = vec4(foreground_color, rgb_to_alpha);
//overlay the matrix // Overlay the matrix
out_color.a *= is_on_dot; //if the fragment is not on a dot, set its alpha value to 0 // If the fragment is not on a dot, set its alpha value to 0
out_color.a *= is_on_dot;
//return fragment color FragColor = out_color;
FragColor = vec4(out_color);
} }

68
handheld/gameboy/shader-files/gb-pass1.slang
View file

@ -8,11 +8,16 @@ layout(std140, set = 0, binding = 0) uniform UBO
vec4 SourceSize; vec4 SourceSize;
} global; } global;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//config // // Config //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#define blending_mode 0 //0 - only the space between dots is blending, 1 - all texels are blended
#define adjacent_texel_alpha_blending 0.1755 //the amount of alpha swapped between neighboring texels // 0 - only the space between dots is blending
// 1 - all texels are blended
#define blending_mode 0
// The amount of alpha swapped between neighboring texels
#define adjacent_texel_alpha_blending 0.1755
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// // // //
@ -35,9 +40,9 @@ layout(std140, set = 0, binding = 0) uniform UBO
// // // //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//vertex shader // // Vertex shader //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#pragma stage vertex #pragma stage vertex
layout(location = 0) in vec4 Position; layout(location = 0) in vec4 Position;
@ -55,19 +60,19 @@ void main()
{ {
gl_Position = global.MVP * Position; gl_Position = global.MVP * Position;
vTexCoord = TexCoord; vTexCoord = TexCoord;
texel = 1.0 / global.SourceSize.xy;
blur_coords_up = vTexCoord + vec2(0.0, texel.y); texel = global.SourceSize.zw;
blur_coords_down = vTexCoord + vec2(0.0, -texel.y); blur_coords_down = vTexCoord + vec2(0.0, texel.y);
blur_coords_up = vTexCoord + vec2(0.0, -texel.y);
blur_coords_right = vTexCoord + vec2(texel.x, 0.0); blur_coords_right = vTexCoord + vec2(texel.x, 0.0);
blur_coords_left = vTexCoord + vec2(-texel.x, 0.0); blur_coords_left = vTexCoord + vec2(-texel.x, 0.0);
blur_coords_lower_bound = vec2(0.0); blur_coords_lower_bound = vec2(0.0);
blur_coords_upper_bound = texel * (global.OutputSize.xy - vec2(2.0)); blur_coords_upper_bound = texel * (global.OutputSize.xy - vec2(2.0));
} }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//fragment shader // // Fragment shader //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#pragma stage fragment #pragma stage fragment
layout(location = 0) in vec2 vTexCoord; layout(location = 0) in vec2 vTexCoord;
@ -81,40 +86,43 @@ layout(location = 7) in vec2 blur_coords_upper_bound;
layout(location = 0) out vec4 FragColor; layout(location = 0) out vec4 FragColor;
layout(set = 0, binding = 2) uniform sampler2D Source; layout(set = 0, binding = 2) uniform sampler2D Source;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//fragment definitions // // Fragment definitions //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//#define blending_modifier(color) clamp((color.a == 0) + blending_mode, 0.0, 1.0) //#define blending_modifier(color) clamp((color.a == 0) + blending_mode, 0.0, 1.0)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//fragment functions //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void main() void main()
{ {
//sample the input textures // A simple blur technique that softens harsh color transitions
// Specialized to only blur alpha values and limited to only blurring texels
// lying in the spaces between two or more texels
// Sample the input textures
vec4 out_color = texture(Source, vTexCoord).rgba; vec4 out_color = texture(Source, vTexCoord).rgba;
//clamp the blur coords to the input texture size so it doesn't attempt to sample off the texture (it'll retrieve float4(0.0) and darken the edges otherwise) // Clamp the blur coords to the input texture size so it doesn't attempt to sample off the texture (it'll retrieve float4(0.0) and darken the edges otherwise)
vec2 blur_coords_up_clamped = clamp(blur_coords_up, blur_coords_lower_bound, blur_coords_upper_bound); vec2 blur_coords_up_clamped = clamp(blur_coords_up, blur_coords_lower_bound, blur_coords_upper_bound);
vec2 blur_coords_down_clamped = clamp(blur_coords_down, blur_coords_lower_bound, blur_coords_upper_bound); vec2 blur_coords_down_clamped = clamp(blur_coords_down, blur_coords_lower_bound, blur_coords_upper_bound);
vec2 blur_coords_right_clamped = clamp(blur_coords_right, blur_coords_lower_bound, blur_coords_upper_bound); vec2 blur_coords_right_clamped = clamp(blur_coords_right, blur_coords_lower_bound, blur_coords_upper_bound);
vec2 blur_coords_left_clamped = clamp(blur_coords_left, blur_coords_lower_bound, blur_coords_upper_bound); vec2 blur_coords_left_clamped = clamp(blur_coords_left, blur_coords_lower_bound, blur_coords_upper_bound);
//sample adjacent texels based on the coordinates above //Sample adjacent texels based on the coordinates above
vec4 adjacent_texel_1 = texture(Source, blur_coords_up_clamped).rgba; vec4 adjacent_texel_1 = texture(Source, blur_coords_up_clamped).rgba;
vec4 adjacent_texel_2 = texture(Source, blur_coords_down_clamped).rgba; vec4 adjacent_texel_2 = texture(Source, blur_coords_down_clamped).rgba;
vec4 adjacent_texel_3 = texture(Source, blur_coords_right_clamped).rgba; vec4 adjacent_texel_3 = texture(Source, blur_coords_right_clamped).rgba;
vec4 adjacent_texel_4 = texture(Source, blur_coords_left_clamped).rgba; vec4 adjacent_texel_4 = texture(Source, blur_coords_left_clamped).rgba;
//sum the alpha differences between neighboring texels, apply modifiers, then subtract the result from the current fragment alpha value // Sum the alpha differences between neighboring texels, apply modifiers, then subtract the result from the current fragment alpha value
out_color.a -= ( (out_color.a - adjacent_texel_1.a) + out_color.a -=
(
(out_color.a - adjacent_texel_1.a) +
(out_color.a - adjacent_texel_2.a) + (out_color.a - adjacent_texel_2.a) +
(out_color.a - adjacent_texel_3.a) + (out_color.a - adjacent_texel_3.a) +
(out_color.a - adjacent_texel_4.a) ) * adjacent_texel_alpha_blending; (out_color.a - adjacent_texel_4.a)
) * adjacent_texel_alpha_blending;
out_color.a *= clamp((0.0) + blending_mode, 0.0, 1.0); out_color.a *= clamp((0.0) + blending_mode, 0.0, 1.0);
//return FragColor = out_color;
FragColor = vec4(out_color);
} }

82
handheld/gameboy/shader-files/gb-pass2.slang
View file

@ -41,7 +41,8 @@ void main()
{ {
gl_Position = global.MVP * Position; gl_Position = global.MVP * Position;
vTexCoord = TexCoord; vTexCoord = TexCoord;
texel = 1.0 / global.SourceSize.xy;
texel = global.SourceSize.zw;
lower_bound = vec2(0.0); lower_bound = vec2(0.0);
upper_bound = vec2(texel * (global.OutputSize.xy - 1.0)); upper_bound = vec2(texel * (global.OutputSize.xy - 1.0));
} }
@ -54,48 +55,59 @@ layout(location = 3) in vec2 upper_bound;
layout(location = 0) out vec4 FragColor; layout(location = 0) out vec4 FragColor;
layout(set = 0, binding = 2) uniform sampler2D Source; layout(set = 0, binding = 2) uniform sampler2D Source;
//sigma = 4.0, normalized for 5 pixel offset sigma = 4.0, normalized for 4 pixel offset /*
//Raw Gaussian weights: Raw Gaussian weights: sigma = 4.0, normalized for 5 pixel offset sigma = 4.0, normalized for 4 pixel offset
// 0.09973561222190091607086808117254 @position0 0.09973561222190091607086808117254 @position0 Raw Gaussian weights: Raw Gaussian weights:
// 0.09666707205829167156101677393475 @position1 0.09666707205829167156101677393475 @position1 0.09973561222190091607086808117254 @position0 0.09973561222190091607086808117254 @position0
// 0.08801637626376240452162358324964 @position2 0.08801637626376240452162358324964 @position2 0.09666707205829167156101677393475 @position1 0.09666707205829167156101677393475 @position1
// 0.07528440407628116669052257071979 @position3 0.07528440407628116669052257071979 @position3 0.08801637626376240452162358324964 @position2 0.08801637626376240452162358324964 @position2
// 0.06049272702308815188099267447364 @position4 0.06049272702308815188099267447364 @position4 0.07528440407628116669052257071979 @position3 0.07528440407628116669052257071979 @position3
// 0.04566231462789672460813692086928 @position5 0.06049272702308815188099267447364 @position4 0.06049272702308815188099267447364 @position4
// 0.04566231462789672460813692086928 @position5
//sum [p0 + 2(p1 + p2 + p3 + p4 + p5)]: sum [p0 + 2(p1 + p2 + p3 + p4)]:
// 0.83198140032054115459545312766674 0.74065677106474770537917928592818
//
//Normalizing factor [1 / sum]: Normalizing factor [1 / sum]:
// 1.2019499469756482251051310195171 1.350153052084338115052273748029
//
//Normalized Gaussian weights: Normalized Gaussian weights:
// 0.11987721382169761913280166382392 @position0 0.13465834124289953661305802732548 @position0
// 0.11618898213475484076479592086597 @position1 0.13051534237555914090930704141833 @position1
// 0.10579127878321792515352079488329 @position2 0.11883557904592230273554609080014 @position2
// 0.09048808548757942339961181362524 @position3 0.10164546793794160274995705611009 @position3
// 0.07270923003781316665844409497651 @position4 0.08167444001912718529866079800870 @position4
// 0.05488381664578583445722654373702 @position5
sum [p0 + 2(p1 + p2 + p3 + p4 + p5)]: sum [p0 + 2(p1 + p2 + p3 + p4)]:
0.83198140032054115459545312766674 0.74065677106474770537917928592818
Normalizing factor [1 / sum]: Normalizing factor [1 / sum]:
1.2019499469756482251051310195171 1.350153052084338115052273748029
Normalized Gaussian weights: Normalized Gaussian weights:
0.11987721382169761913280166382392 @position0 0.13465834124289953661305802732548 @position0
0.11618898213475484076479592086597 @position1 0.13051534237555914090930704141833 @position1
0.10579127878321792515352079488329 @position2 0.11883557904592230273554609080014 @position2
0.09048808548757942339961181362524 @position3 0.10164546793794160274995705611009 @position3
0.07270923003781316665844409497651 @position4 0.08167444001912718529866079800870 @position4
0.05488381664578583445722654373702 @position5
*/
void main() void main()
{ {
//define offsets and weights - change this for both the X and Y passes if you change the sigma value or number of texels sampled // Define offsets and weights - change this for both the X and Y passes if you change the sigma value or number of texels sampled
float offsets[5] = float[](0.0, 1.0, 2.0, 3.0, 4.0); float offsets[5] = float[](0.0, 1.0, 2.0, 3.0, 4.0);
float weights[5] = float[]( 0.13465834124289953661305802732548, //precalculated using the Gaussian function:
0.13051534237555914090930704141833, // G(x) = (1 / sqrt(2 * pi * sigma^2)) * e^(-x^2 / (2 * sigma^2))
0.11883557904592230273554609080014, //where sigma = 4.0 and x = offset in range [0, 5]
0.10164546793794160274995705611009, //normalized to 1 to prevent image darkening by multiplying each weight by:
0.08167444001912718529866079800870 ); // 1 / sum(all weights)
//sample the current fragment and apply its weight /*
vec4 out_color = texture(Source, clamp(vTexCoord.xy, lower_bound.xy, upper_bound.xy)) * weights[0]; Precalculated using the Gaussian function:
G(x) = (1 / sqrt(2 * pi * sigma^2)) * e^(-x^2 / (2 * sigma^2))
//iterate across the offsets in both directions sampling texels and adding their weighted alpha values to the total Where sigma = 4.0 and x = offset in range [0, 5]
Normalized to 1 to prevent image darkening by multiplying each weight by:
1 / sum(all weights)
*/
float weights[5] = float[]( 0.13465834124289953661305802732548,
0.13051534237555914090930704141833,
0.11883557904592230273554609080014,
0.10164546793794160274995705611009,
0.08167444001912718529866079800870 );
// Sample the current fragment and apply its weight
vec4 out_color = texture(Source, clamp(vTexCoord, lower_bound, upper_bound)) * weights[0];
// Iterate across the offsets in both directions sampling texels
// and adding their weighted alpha values to the total
for (int i = 1; i < 5; i++) for (int i = 1; i < 5; i++)
{ {
out_color.a += texture(Source, clamp(vTexCoord.xy + vec2(offsets[i] * texel.x, 0.0), lower_bound, upper_bound)).a * weights[i]; out_color.a += texture(Source, clamp(vTexCoord + vec2(offsets[i] * texel.x, 0.0), lower_bound, upper_bound)).a * weights[i];
out_color.a += texture(Source, clamp(vTexCoord.xy - vec2(offsets[i] * texel.x, 0.0), lower_bound, upper_bound)).a * weights[i]; out_color.a += texture(Source, clamp(vTexCoord - vec2(offsets[i] * texel.x, 0.0), lower_bound, upper_bound)).a * weights[i];
} }
FragColor = vec4(out_color); FragColor = out_color;
} }

73
handheld/gameboy/shader-files/gb-pass3.slang
View file

@ -41,7 +41,8 @@ void main()
{ {
gl_Position = global.MVP * Position; gl_Position = global.MVP * Position;
vTexCoord = TexCoord; vTexCoord = TexCoord;
texel = 1.0 / global.SourceSize.xy;
texel = global.SourceSize.zw;
lower_bound = vec2(0.0); lower_bound = vec2(0.0);
upper_bound = vec2(texel * (global.OutputSize.xy - 1.0)); upper_bound = vec2(texel * (global.OutputSize.xy - 1.0));
} }
@ -54,47 +55,53 @@ layout(location = 3) in vec2 upper_bound;
layout(location = 0) out vec4 FragColor; layout(location = 0) out vec4 FragColor;
layout(set = 0, binding = 2) uniform sampler2D Source; layout(set = 0, binding = 2) uniform sampler2D Source;
//sigma = 4.0, normalized for 5 pixel offset sigma = 4.0, normalized for 4 pixel offset /*
//Raw Gaussian weights: Raw Gaussian weights: sigma = 4.0, normalized for 5 pixel offset sigma = 4.0, normalized for 4 pixel offset
// 0.09973561222190091607086808117254 @position0 0.09973561222190091607086808117254 @position0 Raw Gaussian weights: Raw Gaussian weights:
// 0.09666707205829167156101677393475 @position1 0.09666707205829167156101677393475 @position1 0.09973561222190091607086808117254 @position0 0.09973561222190091607086808117254 @position0
// 0.08801637626376240452162358324964 @position2 0.08801637626376240452162358324964 @position2 0.09666707205829167156101677393475 @position1 0.09666707205829167156101677393475 @position1
// 0.07528440407628116669052257071979 @position3 0.07528440407628116669052257071979 @position3 0.08801637626376240452162358324964 @position2 0.08801637626376240452162358324964 @position2
// 0.06049272702308815188099267447364 @position4 0.06049272702308815188099267447364 @position4 0.07528440407628116669052257071979 @position3 0.07528440407628116669052257071979 @position3
// 0.04566231462789672460813692086928 @position5 0.06049272702308815188099267447364 @position4 0.06049272702308815188099267447364 @position4
// 0.04566231462789672460813692086928 @position5
//sum [p0 + 2(p1 + p2 + p3 + p4 + p5)]: sum [p0 + 2(p1 + p2 + p3 + p4)]:
// 0.83198140032054115459545312766674 0.74065677106474770537917928592818
//
//Normalizing factor [1 / sum]: Normalizing factor [1 / sum]:
// 1.2019499469756482251051310195171 1.350153052084338115052273748029
//
//Normalized Gaussian weights: Normalized Gaussian weights:
// 0.11987721382169761913280166382392 @position0 0.13465834124289953661305802732548 @position0
// 0.11618898213475484076479592086597 @position1 0.13051534237555914090930704141833 @position1
// 0.10579127878321792515352079488329 @position2 0.11883557904592230273554609080014 @position2
// 0.09048808548757942339961181362524 @position3 0.10164546793794160274995705611009 @position3
// 0.07270923003781316665844409497651 @position4 0.08167444001912718529866079800870 @position4
// 0.05488381664578583445722654373702 @position5
sum [p0 + 2(p1 + p2 + p3 + p4 + p5)]: sum [p0 + 2(p1 + p2 + p3 + p4)]:
0.83198140032054115459545312766674 0.74065677106474770537917928592818
Normalizing factor [1 / sum]: Normalizing factor [1 / sum]:
1.2019499469756482251051310195171 1.350153052084338115052273748029
Normalized Gaussian weights: Normalized Gaussian weights:
0.11987721382169761913280166382392 @position0 0.13465834124289953661305802732548 @position0
0.11618898213475484076479592086597 @position1 0.13051534237555914090930704141833 @position1
0.10579127878321792515352079488329 @position2 0.11883557904592230273554609080014 @position2
0.09048808548757942339961181362524 @position3 0.10164546793794160274995705611009 @position3
0.07270923003781316665844409497651 @position4 0.08167444001912718529866079800870 @position4
0.05488381664578583445722654373702 @position5
*/
void main() void main()
{ {
//define offsets and weights - change this for both the X and Y passes if you change the sigma value or number of texels sampled // Define offsets and weights - change this for both the X and Y passes if you change the sigma value or number of texels sampled
float offsets[5] = float[](0.0, 1.0, 2.0, 3.0, 4.0); float offsets[5] = float[](0.0, 1.0, 2.0, 3.0, 4.0);
float weights[5] = float[]( 0.13465834124289953661305802732548, //precalculated using the Gaussian function:
0.13051534237555914090930704141833, // G(x) = (1 / sqrt(2 * pi * sigma^2)) * e^(-x^2 / (2 * sigma^2))
0.11883557904592230273554609080014, //where sigma = 4.0 and x = offset in range [0, 5]
0.10164546793794160274995705611009, //normalized to 1 to prevent image darkening by multiplying each weight by:
0.08167444001912718529866079800870 ); // 1 / sum(all weights)
/*
Precalculated using the Gaussian function:
G(x) = (1 / sqrt(2 * pi * sigma^2)) * e^(-x^2 / (2 * sigma^2))
Where sigma = 4.0 and x = offset in range [0, 5]
Normalized to 1 to prevent image darkening by multiplying each weight by:
1 / sum(all weights)
*/
float weights[5] = float[]( 0.13465834124289953661305802732548,
0.13051534237555914090930704141833,
0.11883557904592230273554609080014,
0.10164546793794160274995705611009,
0.08167444001912718529866079800870 );
//sample the current fragment and apply its weight //sample the current fragment and apply its weight
vec4 out_color = texture(Source, clamp(vTexCoord, lower_bound, upper_bound)) * weights[0]; vec4 out_color = texture(Source, clamp(vTexCoord, lower_bound, upper_bound)) * weights[0];
//iterate across the offsets in both directions sampling texels and adding their weighted alpha values to the total //iterate across the offsets in both directions sampling texels and adding their weighted alpha values to the total
for (int i = 1; i < 5; i++) for (int i = 1; i < 5; i++)
{ {
out_color.a += texture(Source, clamp(vTexCoord + vec2(0.0, offsets[i] * texel.y), lower_bound, upper_bound)).a * weights[i]; out_color.a += texture(Source, clamp(vTexCoord + vec2(0.0, offsets[i] * texel.y), lower_bound, upper_bound)).a * weights[i];
@ -102,5 +109,5 @@ void main()
} }
//return the new value //return the new value
FragColor = vec4(out_color); FragColor = vec4(out_color.rgb, 1.0);
} }

125
handheld/gameboy/shader-files/gb-pass4.slang
View file

@ -6,21 +6,47 @@ layout(std140, set = 0, binding = 0) uniform UBO
vec4 OutputSize; vec4 OutputSize;
vec4 OriginalSize; vec4 OriginalSize;
vec4 SourceSize; vec4 SourceSize;
vec4 PassOutputSize1;
} global; } global;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//config // // Config //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#define contrast 0.95 //useful to fine-tune the colors. higher values make the "black" color closer to black - [0, 1] [DEFAULT: 0.95]
#define screen_light 1.00 //controls the ambient light of the screen. lower values darken the screen - [0, 2] [DEFAULT: 1.00] // Useful to fine-tune the colors.
#define pixel_opacity 1.00 //controls the opacity of the dot-matrix pixels. lower values make pixels more transparent - [0, 1] [DEFAULT: 1.00] // Higher values make the "black" color closer to black - [0, 1] [DEFAULT: 0.95]
#define bg_smoothing 0.75 //higher values suppress changes in background color directly beneath the foreground to improve image clarity - [0, 1] [DEFAULT: 0.75] #define contrast 0.95
#define shadow_opacity 0.55 //how strongly shadows affect the background, higher values darken the shadows - [0, 1] [DEFAULT: 0.55]
#define shadow_offset_x 1.0 //how far the shadow should be shifted to the right in pixels - [-infinity, infinity] [DEFAULT: 1.0] // Controls the ambient light of the screen.
#define shadow_offset_y 1.0 //how far the shadow should be shifted to down in pixels - [-infinity, infinity] [DEFAULT: 1.5] // Lower values darken the screen - [0, 2] [DEFAULT: 1.00]
#define screen_offset_x 0 //screen offset - [-infinity, infinity] [DEFAULT: 0] #define screen_light 1.00
#define screen_offset_y 0 //screen offset - [-infinity, infinity] [DEFAULT: 0]
// Controls the opacity of the dot-matrix pixels.
// Lower values make pixels more transparent - [0, 1] [DEFAULT: 1.00]
#define pixel_opacity 1.00
// Higher values suppress changes in background color directly beneath
// the foreground to improve image clarity - [0, 1] [DEFAULT: 0.75]
#define bg_smoothing 0.75
// How strongly shadows affect the background
// Higher values darken the shadows - [0, 1] [DEFAULT: 0.55]
#define shadow_opacity 0.55
// How far the shadow should be shifted to the
// right in pixels - [-infinity, infinity] [DEFAULT: 1.0]
#define shadow_offset_x 1.0
// How far the shadow should be shifted
// down in pixels - [-infinity, infinity] [DEFAULT: 1.5]
#define shadow_offset_y 1.5
// Screen offset - [-infinity, infinity] [DEFAULT: 0]
#define screen_offset_x 0
// Screen offset - [-infinity, infinity] [DEFAULT: 0]
#define screen_offset_y 0
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// // // //
@ -53,54 +79,73 @@ void main()
{ {
gl_Position = global.MVP * Position; gl_Position = global.MVP * Position;
vTexCoord = TexCoord; vTexCoord = TexCoord;
texel = 1.0 / global.SourceSize.xy;
texel = global.SourceSize.zw;
} }
////////////////////////////////////////////////////////////////////////////////
// Fragment definitions //
////////////////////////////////////////////////////////////////////////////////
#pragma stage fragment #pragma stage fragment
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//fragment definitions //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define bg_color vec4(0.625, 0.664, 0.02, 1.0) //tex2D(COLOR_PALETTE, vec2(0.25, 0.5)) //sample the background color from the palette
#define shadow_alpha (contrast * shadow_opacity) //blending factor used when overlaying shadows on the background
#define shadow_offset vec2(shadow_offset_x * texel.x, shadow_offset_y * texel.y) //offset for the shadow
#define screen_offset vec2(screen_offset_x * texel.x, screen_offset_y * texel.y) //offset for the entire screen
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//fragment shader //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
layout(location = 0) in vec2 vTexCoord; layout(location = 0) in vec2 vTexCoord;
layout(location = 1) in vec2 texel; layout(location = 1) in vec2 texel;
layout(location = 0) out vec4 FragColor; layout(location = 0) out vec4 FragColor;
layout(set = 0, binding = 2) uniform sampler2D Source; layout(set = 0, binding = 1) uniform sampler2D Source;
layout(set = 0, binding = 3) uniform sampler2D PassOutput1; layout(set = 0, binding = 2) uniform sampler2D PassOutput2;
//#define bg_color tex2D(COLOR_PALETTE, vec2(0.25, 0.5))
#define bg_color vec4(0.625, 0.664, 0.25, 0.5)
// Sample the background color from the palette
#define shadow_alpha (contrast * shadow_opacity)
// Offset for the shadow
#define shadow_offset vec2(shadow_offset_x * texel.x, shadow_offset_y * texel.y)
// Offset for the entire screen
#define screen_offset vec2(screen_offset_x * texel.x, screen_offset_y * texel.y)
////////////////////////////////////////////////////////////////////////////////
// Fragment shader //
////////////////////////////////////////////////////////////////////////////////
void main() void main()
{ {
//sample all the relevant textures vec2 tex = floor(global.PassOutputSize1.xy * vTexCoord);
vec4 foreground = texture(PassOutput1, vTexCoord - screen_offset); tex = (tex + 0.5) * global.PassOutputSize1.zw;
vec4 background = vec4(0.5); //hardcoded value rather than LUT
vec4 shadows = texture(Source, vTexCoord - (shadow_offset + screen_offset)); // Sample all the relevant textures
vec4 foreground = texture(PassOutput2, tex - screen_offset);
vec4 background = vec4(0.5); // Hardcoded value rather than LUT
vec4 shadows = texture(Source, tex - (shadow_offset + screen_offset));
vec4 background_color = bg_color; vec4 background_color = bg_color;
//foreground and background are blended with the background color // Foreground and background are blended with the background color
foreground *= bg_color; foreground *= bg_color;
float bg_test = 0.0; float bg_test = 0.0;
if ( foreground.a > 0.0 ) if ( foreground.a > 0.0 )
{ bg_test = 1.0; } bg_test = 1.0;
background -= (background - 0.5) * bg_smoothing * bg_test; background -= (background - 0.5) * bg_smoothing * bg_test;
background.rgb = clamp(vec3( //allows for highlights, background = bg_color when the background color is 0.5 gray // Allows for highlights,
// background = bg_color when the background color is 0.5 gray
background.rgb = clamp(
vec3(
bg_color.r + mix(-1.0, 1.0, background.r), bg_color.r + mix(-1.0, 1.0, background.r),
bg_color.g + mix(-1.0, 1.0, background.g), bg_color.g + mix(-1.0, 1.0, background.g),
bg_color.b + mix(-1.0, 1.0, background.b) ), 0.0, 1.0); bg_color.b + mix(-1.0, 1.0, background.b)
),
0.0, 1.0
);
//shadows are alpha blended with the background // Shadows are alpha blended with the background
vec4 out_color = (shadows * shadows.a * shadow_alpha) + (background * (1.0 - shadows.a * shadow_alpha)); vec4 out_color = (shadows * shadows.a * shadow_alpha) + (background * (1 - shadows.a * shadow_alpha));
//foreground is alpha blended with the shadowed background // Foreground is alpha blended with the shadowed background
out_color = (foreground * foreground.a * contrast) + (out_color * (screen_light - foreground.a * contrast * pixel_opacity)); out_color = (foreground * foreground.a * contrast) + (out_color * (screen_light - foreground.a * contrast * pixel_opacity));
FragColor = vec4(out_color); FragColor = out_color;
} }