From 18a6182b0d84d1035b4531547cab44cc0c740ac4 Mon Sep 17 00:00:00 2001 From: Arzed Five Date: Wed, 20 Jul 2016 22:50:07 +0100 Subject: [PATCH] Some MAD optimizations. Style nits: Replaced tabs with spaces, 4-space tabs, 80 char general limit, etc. --- handheld/gameboy/shader-files/gb-pass0.slang | 127 ++++++++------- handheld/gameboy/shader-files/gb-pass1.slang | 106 +++++++------ handheld/gameboy/shader-files/gb-pass2.slang | 104 +++++++------ handheld/gameboy/shader-files/gb-pass3.slang | 95 ++++++------ handheld/gameboy/shader-files/gb-pass4.slang | 155 ++++++++++++------- 5 files changed, 334 insertions(+), 253 deletions(-) diff --git a/handheld/gameboy/shader-files/gb-pass0.slang b/handheld/gameboy/shader-files/gb-pass0.slang index 6b441ea..14ddd0b 100644 --- a/handheld/gameboy/shader-files/gb-pass0.slang +++ b/handheld/gameboy/shader-files/gb-pass0.slang @@ -15,11 +15,17 @@ layout(std140, set = 0, binding = 0) uniform UBO vec4 OriginalHistorySize7; } global; -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//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] +//////////////////////////////////////////////////////////////////////////////// +// Config // +//////////////////////////////////////////////////////////////////////////////// + +// 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 layout(location = 0) in vec4 Position; layout(location = 1) in vec2 TexCoord; layout(location = 0) out vec2 vTexCoord; -layout(location = 1) out vec2 tex; layout(location = 2) out vec2 dot_size; 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 -#define half_pixel (vec2(0.5) / global.OutputSize.xy) //it's... half a pixel + +// Largest integer scale of input video that will fit in the current output (y axis would typically be limiting on widescreens) +#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() { - gl_Position = global.MVP * Position / vec4(vec2(global.OutputSize.xy / scaled_video_out), 1.0, 1.0 ); - vTexCoord = TexCoord + half_pixel; - tex = floor(global.OriginalHistorySize1.xy * vTexCoord); - tex = (tex + 0.5) * global.OriginalHistorySize1.zw; - dot_size = 1.0 / global.SourceSize.xy; - one_texel = 1.0 / (global.SourceSize.xy * video_scale); + // Remaps position to integer scaled output + gl_Position = global.MVP * Position / vec4( vec2(global.OutputSize.xy / scaled_video_out), 1.0, 1.0 ); + vTexCoord = TexCoord + half_pixel; + dot_size = global.SourceSize.zw; + one_texel = 1.0 / (global.SourceSize.xy * video_scale); } -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//fragment shader // -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +// Fragment shader // +//////////////////////////////////////////////////////////////////////////////// #pragma stage fragment layout(location = 0) in vec2 vTexCoord; -layout(location = 1) in vec2 tex; layout(location = 2) in vec2 dot_size; layout(location = 3) in vec2 one_texel; layout(location = 0) out vec4 FragColor; @@ -92,37 +100,36 @@ layout(set = 0, binding = 7) uniform sampler2D OriginalHistory5; layout(set = 0, binding = 8) uniform sampler2D OriginalHistory6; 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 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 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 -//frame sampling definitions - -#define curr_rgb abs(1.0 - texture(Source, vTexCoord).rgb) -#define prev0_rgb abs(1.0 - texture(OriginalHistory1, tex).rgb) -#define prev1_rgb abs(1.0 - texture(OriginalHistory2, tex).rgb) -#define prev2_rgb abs(1.0 - texture(OriginalHistory3, tex).rgb) -#define prev3_rgb abs(1.0 - texture(OriginalHistory4, tex).rgb) -#define prev4_rgb abs(1.0 - texture(OriginalHistory5, tex).rgb) -#define prev5_rgb abs(1.0 - texture(OriginalHistory6, tex).rgb) -#define prev6_rgb abs(1.0 - texture(OriginalHistory7, tex).rgb) +// Frame sampling definitions +#define curr_rgb abs(1.0 - texture(Source, vTexCoord).rgb) +#define prev0_rgb abs(1.0 - texture(OriginalHistory1, vTexCoord).rgb) +#define prev1_rgb abs(1.0 - texture(OriginalHistory2, vTexCoord).rgb) +#define prev2_rgb abs(1.0 - texture(OriginalHistory3, vTexCoord).rgb) +#define prev3_rgb abs(1.0 - texture(OriginalHistory4, vTexCoord).rgb) +#define prev4_rgb abs(1.0 - texture(OriginalHistory5, vTexCoord).rgb) +#define prev5_rgb abs(1.0 - texture(OriginalHistory6, vTexCoord).rgb) +#define prev6_rgb abs(1.0 - texture(OriginalHistory7, vTexCoord).rgb) void main() { - //determine if the corrent texel lies on a dot or in the space between dots -float is_on_dot; -if ( mod(vTexCoord.x, dot_size.x) > one_texel.x && mod(vTexCoord.y, dot_size.y) > one_texel.y ) -{is_on_dot = 1.0;} -else -{is_on_dot = 0.0;} + // Determine if the corrent texel lies on a dot or in the space between dots + float is_on_dot; + if ( mod(vTexCoord.x, dot_size.x) > one_texel.x && mod(vTexCoord.y, dot_size.y) > one_texel.y ) + is_on_dot = 1.0; + else + is_on_dot = 0.0; -//sample color from the current and previous frames, apply response time modifier -//response time effect implmented through an exponential dropoff algorithm -vec3 input_rgb = curr_rgb; + // Sample color from the current and previous frames, apply response time modifier + // Response time effect implmented through an exponential dropoff algorithm + vec3 input_rgb = curr_rgb; input_rgb += (prev0_rgb - input_rgb) * response_time; input_rgb += (prev1_rgb - input_rgb) * pow(response_time, 2.0); input_rgb += (prev2_rgb - input_rgb) * pow(response_time, 3.0); @@ -131,14 +138,16 @@ vec3 input_rgb = curr_rgb; input_rgb += (prev5_rgb - input_rgb) * pow(response_time, 6.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); - -//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 + float rgb_to_alpha = (input_rgb.r + input_rgb.g + input_rgb.b) / 3.0 + (is_on_dot * baseline_alpha); -//overlay the matrix -out_color.a *= is_on_dot; //if the fragment is not on a dot, set its alpha value to 0 + // Apply foreground color and assign alpha value + // 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); -//return fragment color - FragColor = vec4(out_color); -} \ No newline at end of file + // Overlay the matrix + // If the fragment is not on a dot, set its alpha value to 0 + out_color.a *= is_on_dot; + + FragColor = out_color; +} diff --git a/handheld/gameboy/shader-files/gb-pass1.slang b/handheld/gameboy/shader-files/gb-pass1.slang index 5f20275..02fa760 100644 --- a/handheld/gameboy/shader-files/gb-pass1.slang +++ b/handheld/gameboy/shader-files/gb-pass1.slang @@ -2,17 +2,22 @@ layout(std140, set = 0, binding = 0) uniform UBO { - mat4 MVP; - vec4 OutputSize; - vec4 OriginalSize; - vec4 SourceSize; + mat4 MVP; + vec4 OutputSize; + vec4 OriginalSize; + vec4 SourceSize; } global; -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//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 +//////////////////////////////////////////////////////////////////////////////// +// Config // +//////////////////////////////////////////////////////////////////////////////// + +// 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 layout(location = 0) in vec4 Position; @@ -53,21 +58,21 @@ layout(location = 7) out vec2 blur_coords_upper_bound; void main() { - gl_Position = global.MVP * Position; - vTexCoord = TexCoord; - texel = 1.0 / global.SourceSize.xy; - blur_coords_up = vTexCoord + vec2(0.0, texel.y); - blur_coords_down = vTexCoord + vec2(0.0, -texel.y); - blur_coords_right = vTexCoord + vec2(texel.x, 0.0); - blur_coords_left = vTexCoord + vec2(-texel.x, 0.0); - blur_coords_lower_bound = vec2(0.0); - blur_coords_upper_bound = texel * (global.OutputSize.xy - vec2(2.0)); - + gl_Position = global.MVP * Position; + vTexCoord = TexCoord; + + texel = global.SourceSize.zw; + 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_left = vTexCoord + vec2(-texel.x, 0.0); + blur_coords_lower_bound = vec2(0.0); + blur_coords_upper_bound = texel * (global.OutputSize.xy - vec2(2.0)); } -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//fragment shader // -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +// Fragment shader // +//////////////////////////////////////////////////////////////////////////////// #pragma stage fragment 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(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) -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//fragment functions // -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - void main() { -//sample the input textures - vec4 out_color = texture(Source, vTexCoord).rgba; + // 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 -//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_down_clamped = clamp(blur_coords_down, blur_coords_lower_bound, blur_coords_upper_bound); + // Sample the input textures + 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) + 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_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_2 = texture(Source, blur_coords_down_clamped).rgba; vec4 adjacent_texel_3 = texture(Source, blur_coords_right_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 - out_color.a -= ( (out_color.a - adjacent_texel_1.a) + - (out_color.a - adjacent_texel_2.a) + - (out_color.a - adjacent_texel_3.a) + - (out_color.a - adjacent_texel_4.a) ) * adjacent_texel_alpha_blending; - out_color.a *= clamp((0.0) + blending_mode, 0.0, 1.0); -//return - FragColor = vec4(out_color); -} \ No newline at end of file + // 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 - adjacent_texel_2.a) + + (out_color.a - adjacent_texel_3.a) + + (out_color.a - adjacent_texel_4.a) + ) * adjacent_texel_alpha_blending; + + out_color.a *= clamp((0.0) + blending_mode, 0.0, 1.0); + + FragColor = out_color; +} diff --git a/handheld/gameboy/shader-files/gb-pass2.slang b/handheld/gameboy/shader-files/gb-pass2.slang index 2f0fd26..8c22a60 100644 --- a/handheld/gameboy/shader-files/gb-pass2.slang +++ b/handheld/gameboy/shader-files/gb-pass2.slang @@ -2,10 +2,10 @@ layout(std140, set = 0, binding = 0) uniform UBO { - mat4 MVP; - vec4 OutputSize; - vec4 OriginalSize; - vec4 SourceSize; + mat4 MVP; + vec4 OutputSize; + vec4 OriginalSize; + vec4 SourceSize; } global; /////////////////////////////////////////////////////////////////////////// @@ -39,11 +39,12 @@ layout(location = 3) out vec2 upper_bound; void main() { - gl_Position = global.MVP * Position; - vTexCoord = TexCoord; - texel = 1.0 / global.SourceSize.xy; - lower_bound = vec2(0.0); - upper_bound = vec2(texel * (global.OutputSize.xy - 1.0)); + gl_Position = global.MVP * Position; + vTexCoord = TexCoord; + + texel = global.SourceSize.zw; + lower_bound = vec2(0.0); + upper_bound = vec2(texel * (global.OutputSize.xy - 1.0)); } #pragma stage fragment @@ -54,48 +55,59 @@ layout(location = 3) in vec2 upper_bound; layout(location = 0) out vec4 FragColor; 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: -// 0.09973561222190091607086808117254 @position0 0.09973561222190091607086808117254 @position0 -// 0.09666707205829167156101677393475 @position1 0.09666707205829167156101677393475 @position1 -// 0.08801637626376240452162358324964 @position2 0.08801637626376240452162358324964 @position2 -// 0.07528440407628116669052257071979 @position3 0.07528440407628116669052257071979 @position3 -// 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 +/* +sigma = 4.0, normalized for 5 pixel offset sigma = 4.0, normalized for 4 pixel offset +Raw Gaussian weights: Raw Gaussian weights: +0.09973561222190091607086808117254 @position0 0.09973561222190091607086808117254 @position0 +0.09666707205829167156101677393475 @position1 0.09666707205829167156101677393475 @position1 +0.08801637626376240452162358324964 @position2 0.08801637626376240452162358324964 @position2 +0.07528440407628116669052257071979 @position3 0.07528440407628116669052257071979 @position3 +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 +*/ 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 -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) + // 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); + + /* + 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 -vec4 out_color = texture(Source, clamp(vTexCoord.xy, lower_bound.xy, upper_bound.xy)) * weights[0]; + // 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++) + // 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++) { - 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.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 - vec2(offsets[i] * texel.x, 0.0), lower_bound, upper_bound)).a * weights[i]; } -FragColor = vec4(out_color); -} \ No newline at end of file + FragColor = out_color; +} diff --git a/handheld/gameboy/shader-files/gb-pass3.slang b/handheld/gameboy/shader-files/gb-pass3.slang index 654bdbe..75ce0ca 100644 --- a/handheld/gameboy/shader-files/gb-pass3.slang +++ b/handheld/gameboy/shader-files/gb-pass3.slang @@ -2,10 +2,10 @@ layout(std140, set = 0, binding = 0) uniform UBO { - mat4 MVP; - vec4 OutputSize; - vec4 OriginalSize; - vec4 SourceSize; + mat4 MVP; + vec4 OutputSize; + vec4 OriginalSize; + vec4 SourceSize; } global; /////////////////////////////////////////////////////////////////////////// @@ -41,7 +41,8 @@ void main() { gl_Position = global.MVP * Position; vTexCoord = TexCoord; - texel = 1.0 / global.SourceSize.xy; + + texel = global.SourceSize.zw; lower_bound = vec2(0.0); upper_bound = vec2(texel * (global.OutputSize.xy - 1.0)); } @@ -54,53 +55,59 @@ layout(location = 3) in vec2 upper_bound; layout(location = 0) out vec4 FragColor; 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: -// 0.09973561222190091607086808117254 @position0 0.09973561222190091607086808117254 @position0 -// 0.09666707205829167156101677393475 @position1 0.09666707205829167156101677393475 @position1 -// 0.08801637626376240452162358324964 @position2 0.08801637626376240452162358324964 @position2 -// 0.07528440407628116669052257071979 @position3 0.07528440407628116669052257071979 @position3 -// 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 +/* +sigma = 4.0, normalized for 5 pixel offset sigma = 4.0, normalized for 4 pixel offset +Raw Gaussian weights: Raw Gaussian weights: +0.09973561222190091607086808117254 @position0 0.09973561222190091607086808117254 @position0 +0.09666707205829167156101677393475 @position1 0.09666707205829167156101677393475 @position1 +0.08801637626376240452162358324964 @position2 0.08801637626376240452162358324964 @position2 +0.07528440407628116669052257071979 @position3 0.07528440407628116669052257071979 @position3 +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 +*/ 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 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 + + /* + 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 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++) { - 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]; + 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]; } -//return the new value - FragColor = vec4(out_color); -} \ No newline at end of file + //return the new value + FragColor = vec4(out_color.rgb, 1.0); +} diff --git a/handheld/gameboy/shader-files/gb-pass4.slang b/handheld/gameboy/shader-files/gb-pass4.slang index d99dbb7..cc37892 100644 --- a/handheld/gameboy/shader-files/gb-pass4.slang +++ b/handheld/gameboy/shader-files/gb-pass4.slang @@ -2,25 +2,51 @@ layout(std140, set = 0, binding = 0) uniform UBO { - mat4 MVP; - vec4 OutputSize; - vec4 OriginalSize; - vec4 SourceSize; + mat4 MVP; + vec4 OutputSize; + vec4 OriginalSize; + vec4 SourceSize; + vec4 PassOutputSize1; } 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] -#define pixel_opacity 1.00 //controls the opacity of the dot-matrix pixels. lower values make pixels more transparent - [0, 1] [DEFAULT: 1.00] -#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 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] -#define shadow_offset_y 1.0 //how far the shadow should be shifted to down in pixels - [-infinity, infinity] [DEFAULT: 1.5] -#define screen_offset_x 0 //screen offset - [-infinity, infinity] [DEFAULT: 0] -#define screen_offset_y 0 //screen offset - [-infinity, infinity] [DEFAULT: 0] + +// Useful to fine-tune the colors. +// Higher values make the "black" color closer to black - [0, 1] [DEFAULT: 0.95] +#define contrast 0.95 + +// Controls the ambient light of the screen. +// Lower values darken the screen - [0, 2] [DEFAULT: 1.00] +#define screen_light 1.00 + +// 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 /////////////////////////////////////////////////////////////////////////// // // @@ -51,56 +77,75 @@ layout(location = 1) out vec2 texel; void main() { - gl_Position = global.MVP * Position; - vTexCoord = TexCoord; - texel = 1.0 / global.SourceSize.xy; + gl_Position = global.MVP * Position; + vTexCoord = TexCoord; + + texel = global.SourceSize.zw; } +//////////////////////////////////////////////////////////////////////////////// +// Fragment definitions // +//////////////////////////////////////////////////////////////////////////////// + #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 = 1) in vec2 texel; layout(location = 0) out vec4 FragColor; -layout(set = 0, binding = 2) uniform sampler2D Source; -layout(set = 0, binding = 3) uniform sampler2D PassOutput1; +layout(set = 0, binding = 1) uniform sampler2D Source; +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() { -//sample all the relevant textures -vec4 foreground = texture(PassOutput1, vTexCoord - screen_offset); -vec4 background = vec4(0.5); //hardcoded value rather than LUT -vec4 shadows = texture(Source, vTexCoord - (shadow_offset + screen_offset)); -vec4 background_color = bg_color; + vec2 tex = floor(global.PassOutputSize1.xy * vTexCoord); + tex = (tex + 0.5) * global.PassOutputSize1.zw; + + // 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; -//foreground and background are blended with the background color - foreground *= bg_color; - float bg_test = 0.0; - if ( foreground.a > 0.0 ) - { bg_test = 1.0; } - background -= (background - 0.5) * bg_smoothing * bg_test; + // Foreground and background are blended with the background color + foreground *= bg_color; + + float bg_test = 0.0; + if ( foreground.a > 0.0 ) + bg_test = 1.0; - background.rgb = clamp(vec3( //allows for highlights, background = bg_color when the background color is 0.5 gray - bg_color.r + mix(-1.0, 1.0, background.r), - bg_color.g + mix(-1.0, 1.0, background.g), - bg_color.b + mix(-1.0, 1.0, background.b) ), 0.0, 1.0); + background -= (background - 0.5) * bg_smoothing * bg_test; -//shadows are alpha blended with the background - vec4 out_color = (shadows * shadows.a * shadow_alpha) + (background * (1.0 - shadows.a * shadow_alpha)); + // 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.g + mix(-1.0, 1.0, background.g), + bg_color.b + mix(-1.0, 1.0, background.b) + ), + 0.0, 1.0 + ); -//foreground is alpha blended with the shadowed background - out_color = (foreground * foreground.a * contrast) + (out_color * (screen_light - foreground.a * contrast * pixel_opacity)); - - FragColor = vec4(out_color); + // Shadows are alpha blended with the background + vec4 out_color = (shadows * shadows.a * shadow_alpha) + (background * (1 - shadows.a * shadow_alpha)); + + // Foreground is alpha blended with the shadowed background + out_color = (foreground * foreground.a * contrast) + (out_color * (screen_light - foreground.a * contrast * pixel_opacity)); + + FragColor = out_color; }