diff --git a/blurs/magicbloom/magicbloom.slangp b/blurs/magicbloom/magicbloom.slangp new file mode 100644 index 0000000..c1fb0ba --- /dev/null +++ b/blurs/magicbloom/magicbloom.slangp @@ -0,0 +1,108 @@ +shaders = 12 + +shader0 = ../../stock.slang +filter_linear0 = true +wrap_mode0 = mirrored_repeat +scale_type0 = viewport +scale0 = 1.0 +alias0 = "PreBloomPass" + +// shader0 = ../kawase/linearize.slang +// filter_linear0 = true +// wrap_mode0 = mirrored_repeat +// scale_type0 = viewport +// scale0 = 1.0 +// alias0 = "PreBloomPass" + +shader1 = ./magicbloom_blur_pass_1.slang +filter_linear1 = true +mipmap_input1 = true +wrap_mode1 = mirrored_repeat +scale_type1 = absolute +// scale_x1 = 960 +// scale_y1 = 540 +scale_x1 = 1920 +scale_y1 = 1080 +// scale_type1 = viewport +// scale1 = 0.5 +alias1 = "tMagicBloom_1" + +shader2 = ./magicbloom_blur_pass_2.slang +filter_linear2 = true +mipmap_input2 = true +wrap_mode2 = mirrored_repeat +scale_type2 = source +scale2 = 0.75 +// scale2 = 0.25 +alias2 = "tMagicBloom_2" + +shader3 = ./magicbloom_blur_pass_3.slang +filter_linear3 = true +mipmap_input3 = true +wrap_mode3 = mirrored_repeat +scale_type3 = source +scale3 = 0.75 +// scale3 = 0.125 +alias3 = "tMagicBloom_3" + +shader4 = ./magicbloom_blur_pass_4.slang +filter_linear4 = true +mipmap_input4 = true +wrap_mode4 = mirrored_repeat +scale_type4 = source +scale4 = 0.75 +alias4 = "tMagicBloom_4" + +shader5 = ./magicbloom_blur_pass_5.slang +filter_linear5 = true +mipmap_input5 = true +wrap_mode5 = mirrored_repeat +scale_type5 = source +scale5 = 0.75 +alias5 = "tMagicBloom_5" + +shader6 = ./magicbloom_blur_pass_6.slang +filter_linear6 = true +mipmap_input6 = true +scale_type6 = source +scale6 = 0.5 +alias6 = "tMagicBloom_6" + +shader7 = ./magicbloom_blur_pass_7.slang +filter_linear7 = true +mipmap_input7 = true +scale_type7 = source +scale7 = 0.5 +alias7 = "tMagicBloom_7" + +shader8 = ./magicbloom_blur_pass_8.slang +filter_linear8 = true +mipmap_input8 = true +scale_type8 = source +scale8 = 0.5 +alias8 = "tMagicBloom_8" + +shader9 = ./magicbloom_get_small_luma.slang +filter_linear9 = true +mipmap_input9 = true +scale_type9 = absolute +scale_x9 = 256 +scale_y9 = 256 +alias9 = "tMagicBloom_Small" + +shader10 = ./magicbloom_get_adapt.slang +filter_linear10 = true +mipmap_input10 = true +scale_type10 = source +scale10 = 1.0 +alias10 = "tMagicBloom_Adapt" + +shader11 = ./magicbloom_blend.slang +filter_linear11 = true +mipmap_input11 = true +scale_type11 = viewport +scale11 = 1.0 + +textures = "tMagicBloom_Dirt" + +tMagicBloom_Dirt = "MagicBloom_dirt.png" \ No newline at end of file diff --git a/reshade/magicbloom.slangp b/reshade/magicbloom.slangp new file mode 100644 index 0000000..b0e9c7b --- /dev/null +++ b/reshade/magicbloom.slangp @@ -0,0 +1,95 @@ +shaders = 12 + +shader0 = ../stock.slang +filter_linear0 = true +wrap_mode0 = mirrored_repeat +scale_type0 = viewport +scale0 = 1.0 +alias0 = "PreBloomPass" + +shader1 = ./shaders/magicbloom/magicbloom_blur_pass_1.slang +filter_linear1 = true +mipmap_input1 = true +wrap_mode1 = mirrored_repeat +scale_type1 = absolute +scale_x1 = 1920 +scale_y1 = 1080 +alias1 = "tMagicBloom_1" + +shader2 = ./shaders/magicbloom/magicbloom_blur_pass_2.slang +filter_linear2 = true +mipmap_input2 = true +wrap_mode2 = mirrored_repeat +scale_type2 = source +scale2 = 0.75 +alias2 = "tMagicBloom_2" + +shader3 = ./shaders/magicbloom/magicbloom_blur_pass_3.slang +filter_linear3 = true +mipmap_input3 = true +wrap_mode3 = mirrored_repeat +scale_type3 = source +scale3 = 0.75 +alias3 = "tMagicBloom_3" + +shader4 = ./shaders/magicbloom/magicbloom_blur_pass_4.slang +filter_linear4 = true +mipmap_input4 = true +wrap_mode4 = mirrored_repeat +scale_type4 = source +scale4 = 0.75 +alias4 = "tMagicBloom_4" + +shader5 = ./shaders/magicbloom/magicbloom_blur_pass_5.slang +filter_linear5 = true +mipmap_input5 = true +wrap_mode5 = mirrored_repeat +scale_type5 = source +scale5 = 0.75 +alias5 = "tMagicBloom_5" + +shader6 = ./shaders/magicbloom/magicbloom_blur_pass_6.slang +filter_linear6 = true +mipmap_input6 = true +scale_type6 = source +scale6 = 0.5 +alias6 = "tMagicBloom_6" + +shader7 = ./shaders/magicbloom/magicbloom_blur_pass_7.slang +filter_linear7 = true +mipmap_input7 = true +scale_type7 = source +scale7 = 0.5 +alias7 = "tMagicBloom_7" + +shader8 = ./shaders/magicbloom/magicbloom_blur_pass_8.slang +filter_linear8 = true +mipmap_input8 = true +scale_type8 = source +scale8 = 0.5 +alias8 = "tMagicBloom_8" + +shader9 = ./shaders/magicbloom/magicbloom_get_small_luma.slang +filter_linear9 = true +mipmap_input9 = true +scale_type9 = absolute +scale_x9 = 256 +scale_y9 = 256 +alias9 = "tMagicBloom_Small" + +shader10 = ./shaders/magicbloom/magicbloom_get_adapt.slang +filter_linear10 = true +mipmap_input10 = true +scale_type10 = source +scale10 = 1.0 +alias10 = "tMagicBloom_Adapt" + +shader11 = ./shaders/magicbloom/magicbloom_blend.slang +filter_linear11 = true +mipmap_input11 = true +scale_type11 = viewport +scale11 = 1.0 + +textures = "tMagicBloom_Dirt" + +tMagicBloom_Dirt = "./shaders/magicbloom/MagicBloom_dirt.png" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/MagicBloom_Dirt.png b/reshade/shaders/magicbloom/MagicBloom_Dirt.png new file mode 100644 index 0000000..e20987a Binary files /dev/null and b/reshade/shaders/magicbloom/MagicBloom_Dirt.png differ diff --git a/reshade/shaders/magicbloom/magicbloom_blend.slang b/reshade/shaders/magicbloom/magicbloom_blend.slang new file mode 100644 index 0000000..98357fe --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blend.slang @@ -0,0 +1,215 @@ +#version 450 + +/* + Magic Bloom by luluco250 + Attempts to simulate a natural-looking bloom. + Features: + --Wide bloom blurring, derived from the gaussian function + defined here: https://en.wikipedia.org/wiki/Gaussian_blur#Mathematics + --Eye adaptation, decreases or increases the brightness + of bloom according to the overall image luminance. + --Lens dirt, as standard I suppose. Really not much here. + It uses an image named "MagicBloom_Dirt.png" so make + sure you have one in your textures directory. + --Unwanted features can be disabled through + preprocessor definitions, saving performance. + + Preprocessor definitions: + --MAGICBLOOM_ADAPT_RESOLUTION: + Determines the width/height of the texture used for adaptation. + It is recommended to use 256, but you can use as far as 1024 without issues. + Too low resolutions will make adaptation seem "unstable". + Must be a power of two value: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 etc. + --MAGICBLOOM_BLUR_PRECALCULATED: + If set to 0 the gaussian blur will be calculated inside the shader. + Otherwise, it uses a pre-calculated kernel (array). + + --MAGICBLOOM_NODIRT: + If set to 1 all lens dirt related features are disabled. + Beneficial for performance if you don't wish to use lens dirt. + --MAGICBLOOM_NOADAPT: + If set to 1 all adaptation related features are disabled. + Beneficial for performance if you don't wish to use adaptation. + MIT Licensed: + Copyright (c) 2017 luluco250 + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + +//Statics + +#ifndef MAGICBLOOM_ADAPT_RESOLUTION + #define MAGICBLOOM_ADAPT_RESOLUTION 256 +#endif + +#ifndef MAGICBLOOM_BLUR_PRECALCULATED + #define MAGICBLOOM_BLUR_PRECALCULATED 1 +#endif + +#ifndef MAGICBLOOM_NODIRT + #define MAGICBLOOM_NODIRT 0 +#endif + +// #ifndef MAGICBLOOM_NOADAPT + #define MAGICBLOOM_NOADAPT 0 +// #endif + +#define iBlurSamples 4 +float iAdaptResolution = MAGICBLOOM_ADAPT_RESOLUTION; + +// #define CONST_LOG2(v) (((v) & 0xAAAAAAAA) != 0) | ((((v) & 0xFFFF0000) != 0) << 4) | ((((v) & 0xFF00FF00) != 0) << 3) | ((((v) & 0xF0F0F0F0) != 0) << 2) | ((((v) & 0xCCCCCCCC) != 0) << 1) +#define CONST_LOG2(v) log2(v) + +int sigma = int(float(iBlurSamples) / 2.0); +float double_pi = 6.283185307179586476925286766559; +float lowest_mip = CONST_LOG2(iAdaptResolution) + 1; +vec3 luma_value = vec3(0.2126, 0.7152, 0.0722); + + +layout(push_constant) uniform Push +{ + vec4 SourceSize; + vec4 OriginalSize; + vec4 OutputSize; + uint FrameCount; + float ApplyBloom; + float fExposure; + float iDebug; + float fDirt_Intensity; +} params; + +layout(std140, set = 0, binding = 0) uniform UBO +{ + mat4 MVP; +} global; + +#pragma parameter ApplyBloom " Apply Bloom" 1 0 1 1 +#define ApplyBloom params.ApplyBloom + +#pragma parameter fExposure " Exposure" 0.2 0 1 0.001 +#define fExposure params.fExposure + +#pragma parameter fDirt_Intensity " Dirt Intensity" 0 0 1 0.001 +#define fDirt_Intensity params.fDirt_Intensity + +#pragma parameter iDebug " Debug: Show Blur Pass" 0 0 1 1 +#define iDebug params.iDebug + +#pragma stage vertex +layout(location = 0) in vec4 Position; +layout(location = 1) in vec2 TexCoord; +layout(location = 0) out vec2 vTexCoord; + +void main() +{ + gl_Position = global.MVP * Position; + vTexCoord = TexCoord * 1.00001; +} + +#pragma stage fragment + +layout(location = 0) in vec2 vTexCoord; +layout(location = 0) out vec4 FragColor; +layout(set = 0, binding = 2) uniform sampler2D Source; +layout(set = 0, binding = 3) uniform sampler2D PreBloomPass; +layout(set = 0, binding = 4) uniform sampler2D tMagicBloom_1; +layout(set = 0, binding = 5) uniform sampler2D tMagicBloom_2; +layout(set = 0, binding = 6) uniform sampler2D tMagicBloom_3; +layout(set = 0, binding = 7) uniform sampler2D tMagicBloom_4; +layout(set = 0, binding = 8) uniform sampler2D tMagicBloom_5; +layout(set = 0, binding = 9) uniform sampler2D tMagicBloom_6; +layout(set = 0, binding = 10) uniform sampler2D tMagicBloom_7; +layout(set = 0, binding = 11) uniform sampler2D tMagicBloom_8; +layout(set = 0, binding = 12) uniform sampler2D tMagicBloom_Adapt; +layout(set = 0, binding = 13) uniform sampler2D tMagicBloom_Dirt; + +//Functions + +/* + Uncharted 2 Tonemapper + Thanks John Hable and Naughty Dog. +*/ +vec3 tonemap(vec3 col, float exposure) { + const float A = 0.15; //shoulder strength + const float B = 0.50; //linear strength + const float C = 0.10; //linear angle + const float D = 0.20; //toe strength + const float E = 0.02; //toe numerator + const float F = 0.30; //toe denominator + const float W = 11.2; //linear white point value + + col *= exposure; + + col = ((col * (A * col + C * B) + D * E) / (col * (A * col + B) + D * F)) - E / F; + const float white = 1.0 / (((W * (A * W + C * B) + D * E) / (W * (A * W + B) + D * F)) - E / F); + col *= white; + return col; +} + +vec3 blend_screen(vec3 a, vec3 b) { + return 1.0 - (1.0 - a) * (1.0 - b); +} + +//Final blend shader +vec4 PS_Blend(vec2 uv){ + vec3 col = texture(PreBloomPass, uv).rgb; + vec3 bloom = 0 + + texture(tMagicBloom_1, uv).rgb + + texture(tMagicBloom_2, uv).rgb + + texture(tMagicBloom_3, uv).rgb + + texture(tMagicBloom_4, uv).rgb + + texture(tMagicBloom_5, uv).rgb + + texture(tMagicBloom_6, uv).rgb + + texture(tMagicBloom_7, uv).rgb + + texture(tMagicBloom_8, uv).rgb; + bloom /= 8; + + // TODO need to use the feedback, also the blend is possibly the last pass +// #if !MAGICBLOOM_NOADAPT + float exposure = fExposure / max(texture(tMagicBloom_Adapt, vec2(0.0)).x, 0.00001); + bloom = tonemap(bloom, exposure); +// #else + // Without adaptation it seems 100.0 exposure is needed for bloom to look bright enough. + // bloom = tonemap(bloom, 100.0); +// #endif + + // // #if !MAGICBLOOM_NODIRT + vec3 dirt = texture(tMagicBloom_Dirt, uv).rgb; + dirt *= fDirt_Intensity; + bloom = blend_screen(bloom, dirt * bloom); + // // #endif + + col = blend_screen(col, bloom); + + // If we're to display the bloom texture, we replace col with it. + col = iDebug == 1 ? bloom : col; + + // col = pow(abs(col), vec3(1/2.2)); + + return vec4(col, 1.0); +} + +void main() +{ + if (ApplyBloom < 1){ + FragColor = texture(PreBloomPass, vTexCoord); + // FragColor = pow(abs(FragColor), vec4(1/2.2)); + return; + } + + FragColor = PS_Blend(vTexCoord); + // FragColor = pow(abs(FragColor), vec4(1/2.2)); +} diff --git a/reshade/shaders/magicbloom/magicbloom_blur.inc b/reshade/shaders/magicbloom/magicbloom_blur.inc new file mode 100644 index 0000000..65988e2 --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur.inc @@ -0,0 +1,247 @@ +/* + Magic Bloom by luluco250 + Attempts to simulate a natural-looking bloom. + Features: + --Wide bloom blurring, derived from the gaussian function + defined here: https://en.wikipedia.org/wiki/Gaussian_blur#Mathematics + --Eye adaptation, decreases or increases the brightness + of bloom according to the overall image luminance. + --Lens dirt, as standard I suppose. Really not much here. + It uses an image named "MagicBloom_Dirt.png" so make + sure you have one in your textures directory. + --Unwanted features can be disabled through + preprocessor definitions, saving performance. + + Preprocessor definitions: + --MAGICBLOOM_ADAPT_RESOLUTION: + Determines the width/height of the texture used for adaptation. + It is recommended to use 256, but you can use as far as 1024 without issues. + Too low resolutions will make adaptation seem "unstable". + Must be a power of two value: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 etc. + --MAGICBLOOM_BLUR_PRECALCULATED: + If set to 0 the gaussian blur will be calculated inside the shader. + Otherwise, it uses a pre-calculated kernel (array). + + --MAGICBLOOM_NODIRT: + If set to 1 all lens dirt related features are disabled. + Beneficial for performance if you don't wish to use lens dirt. + --MAGICBLOOM_NOADAPT: + If set to 1 all adaptation related features are disabled. + Beneficial for performance if you don't wish to use adaptation. + MIT Licensed: + Copyright (c) 2017 luluco250 + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + +#pragma format R16G16B16A16_SFLOAT + +//Statics + +#ifndef MAGICBLOOM_ADAPT_RESOLUTION + #define MAGICBLOOM_ADAPT_RESOLUTION 256 +#endif + +#ifndef MAGICBLOOM_BLUR_PRECALCULATED + #define MAGICBLOOM_BLUR_PRECALCULATED 1 +#endif + +#ifndef MAGICBLOOM_NODIRT + #define MAGICBLOOM_NODIRT 0 +#endif + +#ifndef MAGICBLOOM_NOADAPT + #define MAGICBLOOM_NOADAPT 0 +#endif + +#define iBlurSamples 4 +float iAdaptResolution = MAGICBLOOM_ADAPT_RESOLUTION; + +// #define CONST_LOG2(v) (((v) & 0xAAAAAAAA) != 0) | ((((v) & 0xFFFF0000) != 0) << 4) | ((((v) & 0xFF00FF00) != 0) << 3) | ((((v) & 0xF0F0F0F0) != 0) << 2) | ((((v) & 0xCCCCCCCC) != 0) << 1) +#define CONST_LOG2(v) log2(v) + +int sigma = int(float(iBlurSamples) / 2.0); +float double_pi = 6.283185307179586476925286766559; +float lowest_mip = CONST_LOG2(iAdaptResolution) + 1; +vec3 luma_value = vec3(0.2126, 0.7152, 0.0722); + + +layout(push_constant) uniform Push +{ + vec4 SourceSize; + vec4 OriginalSize; + vec4 OutputSize; + uint FrameCount; + float fBloom_Intensity; + float fBloom_Threshold; + float ApplyBloom; +} params; + +layout(std140, set = 0, binding = 0) uniform UBO +{ + mat4 MVP; +} global; + +#pragma parameter MagicBloomTitle "[ MAGIC BLOOM ]" 0 0 0.001 0.001 + +#pragma parameter ApplyBloom " Apply Bloom" 1 0 1 1 +#define ApplyBloom params.ApplyBloom + +#pragma parameter fBloom_Intensity " Bloom Intensity" 1 0 10 0.1 +#define fBloom_Intensity params.fBloom_Intensity / 4 + +#pragma parameter fBloom_Threshold " Bloom Threshold" 2 1 10 0.1 +#define fBloom_Threshold params.fBloom_Threshold + + +#pragma stage vertex +layout(location = 0) in vec4 Position; +layout(location = 1) in vec2 TexCoord; +layout(location = 0) out vec2 vTexCoord; + +void main() +{ + gl_Position = global.MVP * Position; + vTexCoord = TexCoord * 1.00001; +} + +#pragma stage fragment + +layout(location = 0) in vec2 vTexCoord; +layout(location = 0) out vec4 FragColor; +layout(set = 0, binding = 2) uniform sampler2D Source; + +//Functions + +#if !MAGICBLOOM_BLUR_PRECALCULATED +float gaussian_function(vec2 i) { + float first_part = 1.0 / (double_pi * pow(sigma, 2.0)); + float second_part_a = 1.0 / (2.0 * pow(sigma, 2.0)); + float second_part_b = (pow(i.x, 2.0) + pow(i.y, 2.0)) * second_part_a; + return first_part * exp(-second_part_b); +} +#endif + +//Why use a single-pass blur? To reduce the amount of textures used in half. +//Scale should be the original resolution divided by target resolution. +vec3 blur(sampler2D sp, vec2 uv, float scale) { + vec2 ps = params.OutputSize.zw * scale; + + #if MAGICBLOOM_BLUR_PRECALCULATED + float kernel[9] = { + 0.0269955, 0.0647588, 0.120985, 0.176033, 0.199471, 0.176033, 0.120985, 0.0647588, 0.0269955 + }; + float accum = 1.02352; + #else + float accum = 0.0; + #endif + + float gaussian_weight = 0.0; + vec3 col = vec3(0); + + // [unroll] + for (int x = int(-iBlurSamples); x <= int(iBlurSamples); ++x) { + for (int y = int(-iBlurSamples); y <= int(iBlurSamples); ++y) { + #if MAGICBLOOM_BLUR_PRECALCULATED + gaussian_weight = kernel[x + iBlurSamples] * kernel[y + iBlurSamples]; + #else + gaussian_weight = gaussian_function(vec2(x, y)); + accum += gaussian_weight; + #endif + col += texture(sp, uv + ps * vec2(x, y)).rgb * gaussian_weight; + } + } + + #if MAGICBLOOM_BLUR_PRECALCULATED + return col * accum; + #else + return col / accum; + #endif +} + +vec4 PS_Blur1(vec2 uv, sampler2D in_sampler) { + vec3 col = blur(in_sampler, uv, 2.0); + col = pow(abs(col), vec3(fBloom_Threshold)); + col *= fBloom_Intensity; + return vec4(col, 1.0); +} + +vec4 PS_Blur2(vec2 uv, sampler2D in_sampler) { + return vec4(blur(in_sampler, uv, 4.0), 1.0); +} + +vec4 PS_Blur3(vec2 uv, sampler2D in_sampler) { + return vec4(blur(in_sampler, uv, 8.0), 1.0); +} + +vec4 PS_Blur4(vec2 uv, sampler2D in_sampler) { + return vec4(blur(in_sampler, uv, 8.0), 1.0); +} + +vec4 PS_Blur5(vec2 uv, sampler2D in_sampler) { + return vec4(blur(in_sampler, uv, 16.0), 1.0); +} + +vec4 PS_Blur6(vec2 uv, sampler2D in_sampler) { + return vec4(blur(in_sampler, uv, 32.0), 1.0); +} + +vec4 PS_Blur7(vec2 uv, sampler2D in_sampler) { + return vec4(blur(in_sampler, uv, 64.0), 1.0); +} + +vec4 PS_Blur8(vec2 uv, sampler2D in_sampler) { + return vec4(blur(in_sampler, uv, 128.0), 1.0); +} + +void main() +{ + if (ApplyBloom < 1) + return; + +#ifdef BLUR_PASS_1 + FragColor = PS_Blur1(vTexCoord, Source); +#endif + +#ifdef BLUR_PASS_2 + FragColor = PS_Blur2(vTexCoord, Source); +#endif + +#ifdef BLUR_PASS_3 + FragColor = PS_Blur3(vTexCoord, Source); +#endif + +#ifdef BLUR_PASS_4 + FragColor = PS_Blur4(vTexCoord, Source); +#endif + +#ifdef BLUR_PASS_5 + FragColor = PS_Blur5(vTexCoord, Source); +#endif + +#ifdef BLUR_PASS_6 + FragColor = PS_Blur6(vTexCoord, Source); +#endif + +#ifdef BLUR_PASS_7 + FragColor = PS_Blur7(vTexCoord, Source); +#endif + +#ifdef BLUR_PASS_8 + FragColor = PS_Blur8(vTexCoord, Source); +#endif + +} diff --git a/reshade/shaders/magicbloom/magicbloom_blur_pass_1.slang b/reshade/shaders/magicbloom/magicbloom_blur_pass_1.slang new file mode 100644 index 0000000..0e1ebb4 --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur_pass_1.slang @@ -0,0 +1,12 @@ +#version 450 + +/* + Magic Bloom by luluco250 + See .inc file for more info +*/ + +#define BLUR_PASS_1 + +#pragma alias tMagicBloom_1 + +#include "magicbloom_blur.inc" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/magicbloom_blur_pass_2.slang b/reshade/shaders/magicbloom/magicbloom_blur_pass_2.slang new file mode 100644 index 0000000..03b7bfc --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur_pass_2.slang @@ -0,0 +1,12 @@ +#version 450 + +/* + Magic Bloom by luluco250 + See .inc file for more info +*/ + +#define BLUR_PASS_2 + +#pragma alias tMagicBloom_2 + +#include "magicbloom_blur.inc" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/magicbloom_blur_pass_3.slang b/reshade/shaders/magicbloom/magicbloom_blur_pass_3.slang new file mode 100644 index 0000000..3c7b8cd --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur_pass_3.slang @@ -0,0 +1,12 @@ +#version 450 + +/* + Magic Bloom by luluco250 + See .inc file for more info +*/ + +#define BLUR_PASS_3 + +#pragma alias tMagicBloom_3 + +#include "magicbloom_blur.inc" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/magicbloom_blur_pass_4.slang b/reshade/shaders/magicbloom/magicbloom_blur_pass_4.slang new file mode 100644 index 0000000..de22691 --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur_pass_4.slang @@ -0,0 +1,12 @@ +#version 450 + +/* + Magic Bloom by luluco250 + See .inc file for more info +*/ + +#define BLUR_PASS_4 + +#pragma alias tMagicBloom_4 + +#include "magicbloom_blur.inc" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/magicbloom_blur_pass_5.slang b/reshade/shaders/magicbloom/magicbloom_blur_pass_5.slang new file mode 100644 index 0000000..b437f4e --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur_pass_5.slang @@ -0,0 +1,12 @@ +#version 450 + +/* + Magic Bloom by luluco250 + See .inc file for more info +*/ + +#define BLUR_PASS_5 + +#pragma alias tMagicBloom_5 + +#include "magicbloom_blur.inc" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/magicbloom_blur_pass_6.slang b/reshade/shaders/magicbloom/magicbloom_blur_pass_6.slang new file mode 100644 index 0000000..0dd119a --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur_pass_6.slang @@ -0,0 +1,12 @@ +#version 450 + +/* + Magic Bloom by luluco250 + See .inc file for more info +*/ + +#define BLUR_PASS_6 + +#pragma alias tMagicBloom_6 + +#include "magicbloom_blur.inc" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/magicbloom_blur_pass_7.slang b/reshade/shaders/magicbloom/magicbloom_blur_pass_7.slang new file mode 100644 index 0000000..3ab54f7 --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur_pass_7.slang @@ -0,0 +1,12 @@ +#version 450 + +/* + Magic Bloom by luluco250 + See .inc file for more info +*/ + +#define BLUR_PASS_7 + +#pragma alias tMagicBloom_7 + +#include "magicbloom_blur.inc" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/magicbloom_blur_pass_8.slang b/reshade/shaders/magicbloom/magicbloom_blur_pass_8.slang new file mode 100644 index 0000000..a85005f --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_blur_pass_8.slang @@ -0,0 +1,12 @@ +#version 450 + +/* + Magic Bloom by luluco250 + See .inc file for more info +*/ + +#define BLUR_PASS_8 + +#pragma alias tMagicBloom_8 + +#include "magicbloom_blur.inc" \ No newline at end of file diff --git a/reshade/shaders/magicbloom/magicbloom_get_adapt.slang b/reshade/shaders/magicbloom/magicbloom_get_adapt.slang new file mode 100644 index 0000000..5923ba6 --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_get_adapt.slang @@ -0,0 +1,159 @@ +#version 450 + +/* + Magic Bloom by luluco250 + Attempts to simulate a natural-looking bloom. + Features: + --Wide bloom blurring, derived from the gaussian function + defined here: https://en.wikipedia.org/wiki/Gaussian_blur#Mathematics + --Eye adaptation, decreases or increases the brightness + of bloom according to the overall image luminance. + --Lens dirt, as standard I suppose. Really not much here. + It uses an image named "MagicBloom_Dirt.png" so make + sure you have one in your textures directory. + --Unwanted features can be disabled through + preprocessor definitions, saving performance. + + Preprocessor definitions: + --MAGICBLOOM_ADAPT_RESOLUTION: + Determines the width/height of the texture used for adaptation. + It is recommended to use 256, but you can use as far as 1024 without issues. + Too low resolutions will make adaptation seem "unstable". + Must be a power of two value: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 etc. + --MAGICBLOOM_BLUR_PRECALCULATED: + If set to 0 the gaussian blur will be calculated inside the shader. + Otherwise, it uses a pre-calculated kernel (array). + + --MAGICBLOOM_NODIRT: + If set to 1 all lens dirt related features are disabled. + Beneficial for performance if you don't wish to use lens dirt. + --MAGICBLOOM_NOADAPT: + If set to 1 all adaptation related features are disabled. + Beneficial for performance if you don't wish to use adaptation. + MIT Licensed: + Copyright (c) 2017 luluco250 + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + +#pragma format R32G32B32A32_SFLOAT + +//Statics + +#ifndef MAGICBLOOM_ADAPT_RESOLUTION + #define MAGICBLOOM_ADAPT_RESOLUTION 256 +#endif + +#ifndef MAGICBLOOM_BLUR_PRECALCULATED + #define MAGICBLOOM_BLUR_PRECALCULATED 1 +#endif + +#ifndef MAGICBLOOM_NODIRT + #define MAGICBLOOM_NODIRT 0 +#endif + +// #ifndef MAGICBLOOM_NOADAPT + #define MAGICBLOOM_NOADAPT 0 +// #endif + +#define iBlurSamples 4 +float iAdaptResolution = MAGICBLOOM_ADAPT_RESOLUTION; + +// #define CONST_LOG2(v) (((v) & 0xAAAAAAAA) != 0) | ((((v) & 0xFFFF0000) != 0) << 4) | ((((v) & 0xFF00FF00) != 0) << 3) | ((((v) & 0xF0F0F0F0) != 0) << 2) | ((((v) & 0xCCCCCCCC) != 0) << 1) +#define CONST_LOG2(v) log2(v) + +int sigma = int(float(iBlurSamples) / 2.0); +float double_pi = 6.283185307179586476925286766559; +float lowest_mip = CONST_LOG2(iAdaptResolution) + 1; +vec3 luma_value = vec3(0.2126, 0.7152, 0.0722); + + +layout(push_constant) uniform Push +{ + vec4 SourceSize; + vec4 OriginalSize; + vec4 OutputSize; + uint FrameCount; + float fAdapt_Speed; + float fAdapt_Sensitivity; + float f2Adapt_Clip_Min; + float f2Adapt_Clip_Max; + float ApplyBloom; +} params; + +layout(std140, set = 0, binding = 0) uniform UBO +{ + mat4 MVP; +} global; + +#pragma parameter ApplyBloom " Apply Bloom" 1 0 1 1 +#define ApplyBloom params.ApplyBloom + +#pragma parameter fAdapt_Speed " Adaptation Speed" 1 0.001 1 0.001 +#define fAdapt_Speed params.fAdapt_Speed + +#pragma parameter fAdapt_Sensitivity " Adaptation Sensitivity" 1 0 3 0.001 +float fAdapt_Sensitivity = params.fAdapt_Sensitivity; + +#pragma parameter f2Adapt_Clip_Min " Adaptation Min" 0 0 3 0.001 +#define f2Adapt_Clip_Min params.f2Adapt_Clip_Min + +#pragma parameter f2Adapt_Clip_Max " Adaptation Max" 1 0 3 0.001 +#define f2Adapt_Clip_Max params.f2Adapt_Clip_Max + + +#pragma stage vertex +layout(location = 0) in vec4 Position; +layout(location = 1) in vec2 TexCoord; +layout(location = 0) out vec2 vTexCoord; + +void main() +{ + gl_Position = global.MVP * Position; + vTexCoord = TexCoord * 1.00001; +} + +#pragma stage fragment + +layout(location = 0) in vec2 vTexCoord; +layout(location = 0) out vec4 FragColor; +layout(set = 0, binding = 2) uniform sampler2D Source; +layout(set = 0, binding = 3) uniform sampler2D tMagicBloom_Small; +layout(set = 0, binding = 4) uniform sampler2D tMagicBloom_AdaptFeedback; + +//Functions + +float PS_GetAdapt(vec2 uv){ + float m = max(log2(params.SourceSize.x), log2(params.SourceSize.y)); + // m = floor(max(m, 1.0))-1.0; + + float curr = textureLod(tMagicBloom_Small, vec2(0.5, 0.5), m - 2).x; + + curr *= fAdapt_Sensitivity; + curr = clamp(curr, f2Adapt_Clip_Min, f2Adapt_Clip_Max); + float last = texture(tMagicBloom_AdaptFeedback, vec2(0.5)).x; + //Using the frametime/delta here would actually scale adaptation with the framerate. + //We don't want that, so we don't even bother with it. + return mix(float(last), float(curr), float(fAdapt_Speed)); +} + +void main() +{ + if (ApplyBloom < 1) + return; + + FragColor = vec4(PS_GetAdapt(vTexCoord)); +} diff --git a/reshade/shaders/magicbloom/magicbloom_get_small_luma.slang b/reshade/shaders/magicbloom/magicbloom_get_small_luma.slang new file mode 100644 index 0000000..2681755 --- /dev/null +++ b/reshade/shaders/magicbloom/magicbloom_get_small_luma.slang @@ -0,0 +1,130 @@ +#version 450 + +/* + Magic Bloom by luluco250 + Attempts to simulate a natural-looking bloom. + Features: + --Wide bloom blurring, derived from the gaussian function + defined here: https://en.wikipedia.org/wiki/Gaussian_blur#Mathematics + --Eye adaptation, decreases or increases the brightness + of bloom according to the overall image luminance. + --Lens dirt, as standard I suppose. Really not much here. + It uses an image named "MagicBloom_Dirt.png" so make + sure you have one in your textures directory. + --Unwanted features can be disabled through + preprocessor definitions, saving performance. + + Preprocessor definitions: + --MAGICBLOOM_ADAPT_RESOLUTION: + Determines the width/height of the texture used for adaptation. + It is recommended to use 256, but you can use as far as 1024 without issues. + Too low resolutions will make adaptation seem "unstable". + Must be a power of two value: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 etc. + --MAGICBLOOM_BLUR_PRECALCULATED: + If set to 0 the gaussian blur will be calculated inside the shader. + Otherwise, it uses a pre-calculated kernel (array). + + --MAGICBLOOM_NODIRT: + If set to 1 all lens dirt related features are disabled. + Beneficial for performance if you don't wish to use lens dirt. + --MAGICBLOOM_NOADAPT: + If set to 1 all adaptation related features are disabled. + Beneficial for performance if you don't wish to use adaptation. + MIT Licensed: + Copyright (c) 2017 luluco250 + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + +#pragma format R32G32B32A32_SFLOAT + +//Statics + +#ifndef MAGICBLOOM_ADAPT_RESOLUTION + #define MAGICBLOOM_ADAPT_RESOLUTION 256 +#endif + +#ifndef MAGICBLOOM_BLUR_PRECALCULATED + #define MAGICBLOOM_BLUR_PRECALCULATED 1 +#endif + +#ifndef MAGICBLOOM_NODIRT + #define MAGICBLOOM_NODIRT 0 +#endif + +// #ifndef MAGICBLOOM_NOADAPT + #define MAGICBLOOM_NOADAPT 0 +// #endif + +#define iBlurSamples 4 +float iAdaptResolution = MAGICBLOOM_ADAPT_RESOLUTION; + +// #define CONST_LOG2(v) (((v) & 0xAAAAAAAA) != 0) | ((((v) & 0xFFFF0000) != 0) << 4) | ((((v) & 0xFF00FF00) != 0) << 3) | ((((v) & 0xF0F0F0F0) != 0) << 2) | ((((v) & 0xCCCCCCCC) != 0) << 1) +#define CONST_LOG2(v) log2(v) + +int sigma = int(float(iBlurSamples) / 2.0); +float double_pi = 6.283185307179586476925286766559; +float lowest_mip = CONST_LOG2(iAdaptResolution) + 1; +vec3 luma_value = vec3(0.2126, 0.7152, 0.0722); + + +layout(push_constant) uniform Push +{ + vec4 SourceSize; + vec4 OriginalSize; + vec4 OutputSize; + uint FrameCount; + float ApplyBloom; +} params; + +layout(std140, set = 0, binding = 0) uniform UBO +{ + mat4 MVP; +} global; + +#pragma parameter ApplyBloom " Apply Bloom" 1 0 1 1 +#define ApplyBloom params.ApplyBloom + +#pragma stage vertex +layout(location = 0) in vec4 Position; +layout(location = 1) in vec2 TexCoord; +layout(location = 0) out vec2 vTexCoord; + +void main() +{ + gl_Position = global.MVP * Position; + vTexCoord = TexCoord * 1.00001; +} + +#pragma stage fragment + +layout(location = 0) in vec2 vTexCoord; +layout(location = 0) out vec4 FragColor; +layout(set = 0, binding = 2) uniform sampler2D PreBloomPass; + +//Functions + +float PS_GetSmall(vec2 uv){ + return dot(texture(PreBloomPass, uv).rgb, luma_value); +} + +void main() +{ + if (ApplyBloom < 1) + return; + + FragColor = vec4(PS_GetSmall(vTexCoord)); +}