bloom_pass.h

Go to the documentation of this file.

#pragma once
 
#include <engine/rendering/camera.h>
#include <engine/rendering/gpu_program.h>
#include <graphics/render_view.h>
#include <math/color.h>
 
namespace unravel
{
 
class bloom_pass
{
public:
    struct settings
    {
        float threshold = 5.0f;
        float soft_knee = 0.5f;
        float clamp = 100.0f;
        float intensity = 1.0f;
        int mip_count = 8;
 
        // Per-mip tint (RGB) and weight (alpha). Applied during upsample cascade.
        // Tint controls color, alpha controls contribution weight (0 = disabled, 1 = full).
        math::color mip0_tint{1.0f, 1.0f, 1.0f, 1.0f};  // 1/2 res  - tightest halo
        math::color mip1_tint{1.0f, 1.0f, 1.0f, 1.0f};  // 1/4 res
        math::color mip2_tint{1.0f, 1.0f, 1.0f, 1.0f};  // 1/8 res
        math::color mip3_tint{1.0f, 1.0f, 1.0f, 1.0f};  // 1/16 res
        math::color mip4_tint{1.0f, 1.0f, 1.0f, 1.0f};  // 1/32 res
        math::color mip5_tint{1.0f, 1.0f, 1.0f, 1.0f};  // 1/64 res - widest bloom
 
        float dirt_intensity = 0.0f;
 
        auto get_mip_tint(int idx) const -> const math::color&
        {
            switch(idx)
            {
                case 0: return mip0_tint;
                case 1: return mip1_tint;
                case 2: return mip2_tint;
                case 3: return mip3_tint;
                case 4: return mip4_tint;
                case 5: return mip5_tint;
                default:
                {
                    static const math::color default_tint(1.0f, 1.0f, 1.0f, 1.0f);
                    return default_tint;
                }
            }
        }
    };
 
    struct run_params
    {
        gfx::frame_buffer::ptr input;
        gfx::frame_buffer::ptr output;
        settings config{};
        gfx::texture::ptr exposure_texture;
    };
 
    auto init(rtti::context& ctx) -> bool;
    auto run(gfx::render_view& rview, const run_params& params) -> gfx::frame_buffer::ptr;
    void release_resources(gfx::render_view& rview);
 
private:
    static constexpr int max_mip_count = 10;
 
    auto create_or_resize_mip_chain(gfx::render_view& rview,
                                    const usize32_t& viewport_size,
                                    int mip_count) -> void;
    auto get_mip_fbo(gfx::render_view& rview, int mip_index) -> const gfx::frame_buffer::ptr&;
    auto create_or_update_output_fb(gfx::render_view& rview,
                                    const gfx::frame_buffer::ptr& input,
                                    const gfx::frame_buffer::ptr& output) -> gfx::frame_buffer::ptr;
 
    struct downsample_program : uniforms_cache
    {
        void cache_uniforms()
        {
            cache_uniform(program.get(), u_pixel_size, "u_pixelSize", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_params, "u_params", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), s_tex, "s_tex", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_exposure, "s_exposure", gfx::uniform_type::Sampler);
        }
        gfx::program::uniform_ptr u_pixel_size;
        gfx::program::uniform_ptr u_params;
        gfx::program::uniform_ptr s_tex;
        gfx::program::uniform_ptr s_exposure;
        std::unique_ptr<gpu_program> program;
    } downsample_program_;
 
    struct upsample_program : uniforms_cache
    {
        void cache_uniforms()
        {
            cache_uniform(program.get(), u_pixel_size, "u_pixelSize", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_tint, "u_tint", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), s_tex, "s_tex", gfx::uniform_type::Sampler);
        }
        gfx::program::uniform_ptr u_pixel_size;
        gfx::program::uniform_ptr u_tint;
        gfx::program::uniform_ptr s_tex;
        std::unique_ptr<gpu_program> program;
    } upsample_program_;
 
    struct combine_program : uniforms_cache
    {
        void cache_uniforms()
        {
            cache_uniform(program.get(), s_scene, "s_scene", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_bloom, "s_bloom", gfx::uniform_type::Sampler);
        }
        gfx::program::uniform_ptr s_scene;
        gfx::program::uniform_ptr s_bloom;
        std::unique_ptr<gpu_program> program;
    } combine_program_;
};
 
} // namespace unravel