ssil_pass.h

Go to the documentation of this file.

#pragma once
 
#include <engine/rendering/gpu_program.h>
#include <graphics/render_view.h>
#include <engine/rendering/camera.h>
#include <graphics/texture.h>
#include <graphics/render_pass.h>
#include "trace_resolution.h"
 
namespace unravel
{
 
class ssil_pass
{
public:
    struct spatial_denoise_settings
    {
        float depth_sigma = 0.02f;
        float normal_power = 64.0f;
        float luma_sigma = 4.0f;
 
        int passes = 4;
        int full_res_passes = 0;
        int max_step = 16;
    };
 
    struct temporal_settings
    {
        float history_strength = 0.9f;
        float depth_threshold = 0.2f;
        float normal_dot_threshold = 0.6f;
        int max_accum_frames = 16;
    };
 
    struct ssil_settings
    {
        int max_rays = 4;
        int max_steps = 64;
        float depth_tolerance = 0.15f;
        float thickness = 0.5f;
        float brightness = 0.5f;
        float max_distance = 300.0f;
        trace_resolution resolution = trace_resolution::full;
 
        bool enable_multi_bounce = true;
        float multi_bounce_intensity = 0.8f;
 
        bool enable_spatial_denoise = true;
        spatial_denoise_settings spatial_denoise;
 
        bool enable_temporal_accumulation = true;
        temporal_settings temporal;
    };
 
    struct run_params
    {
        gfx::frame_buffer::ptr g_buffer;
        gfx::texture::ptr hiz_buffer;
        gfx::texture::ptr direct_lighting;
        gfx::texture::ptr prev_depth;
        gfx::texture::ptr prev_ssil;
        gfx::texture::ptr irradiance_sh;
        const camera* cam{};
        ssil_settings settings;
    };
 
    auto init(rtti::context& ctx) -> bool;
 
    auto run(gfx::render_view& rview, const run_params& params) -> gfx::texture::ptr;
 
    void release_resources(gfx::render_view& rview);
 
private:
    auto run_trace(gfx::render_view& rview, const run_params& params) -> gfx::frame_buffer::ptr;
 
    auto run_spatial_denoise(gfx::render_view& rview,
                             const gfx::frame_buffer::ptr& ssil_curr,
                             const gfx::frame_buffer::ptr& g_buffer,
                             const gfx::texture::ptr& moments,
                             const camera* cam,
                             const ssil_settings& settings) -> gfx::frame_buffer::ptr;
 
    auto run_temporal_resolve(gfx::render_view& rview,
                              gfx::frame_buffer::ptr ssil_input,
                              const gfx::frame_buffer::ptr& g_buffer,
                              const gfx::texture::ptr& prev_depth,
                              const camera* cam,
                              const ssil_settings& settings,
                              gfx::frame_buffer::ptr& out_result_fb,
                              gfx::texture::ptr& out_moments_tex) -> bool;
 
    auto run_upsample(gfx::render_view& rview,
                      const gfx::frame_buffer::ptr& ssil_input,
                      const gfx::frame_buffer::ptr& g_buffer,
                      const camera* cam,
                      const ssil_settings& settings) -> gfx::frame_buffer::ptr;
 
    auto create_or_update_ssil_fb(gfx::render_view& rview,
                                  const std::string& name,
                                  const gfx::frame_buffer::ptr& reference,
                                  trace_resolution res,
                                  uint64_t extra_flags = 0) -> gfx::frame_buffer::ptr;
 
    auto create_or_update_ssil_tex(gfx::render_view& rview,
                                   const std::string& name,
                                   const gfx::frame_buffer::ptr& reference,
                                   trace_resolution res,
                                   uint64_t extra_flags = 0) -> gfx::texture::ptr;
 
    auto create_or_update_ssil_fb_mrt(gfx::render_view& rview,
                                      const std::string& fbo_name,
                                      const std::string& color_tex_name,
                                      const std::string& moments_tex_name,
                                      const gfx::frame_buffer::ptr& reference,
                                      trace_resolution res,
                                      uint64_t extra_flags = 0) -> gfx::frame_buffer::ptr;
 
    void release_history_resources(gfx::render_view& rview);
 
    void release_denoise_resources(gfx::render_view& rview);
 
    // Trace program (fullscreen fragment shader)
    struct trace_program : uniforms_cache
    {
        gpu_program::ptr program;
        gfx::program::uniform_ptr u_ssil_params;
        gfx::program::uniform_ptr u_ssil_params2;
        gfx::program::uniform_ptr u_ssil_params3;
        gfx::program::uniform_ptr u_ssil_resolution;
        gfx::program::uniform_ptr s_color;
        gfx::program::uniform_ptr s_normal;
        gfx::program::uniform_ptr s_hiz;
        gfx::program::uniform_ptr s_emissive;
        gfx::program::uniform_ptr s_albedo;
        gfx::program::uniform_ptr s_prev_ssil;
        gfx::program::uniform_ptr s_irradiance;
 
        void cache_uniforms()
        {
            cache_uniform(program.get(), u_ssil_params, "u_ssil_params", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_ssil_params2, "u_ssil_params2", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_ssil_params3, "u_ssil_params3", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_ssil_resolution, "u_ssil_resolution", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), s_color, "s_color", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_normal, "s_normal", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_hiz, "s_hiz", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_emissive, "s_emissive", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_albedo, "s_albedo", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_prev_ssil, "s_prev_ssil", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_irradiance, "s_irradiance", gfx::uniform_type::Sampler);
        }
 
        auto is_valid() const -> bool { return program && program->is_valid(); }
    } trace_program_;
 
    // Spatial denoise compute program
    struct denoise_program : uniforms_cache
    {
        gpu_program::ptr program;
        gfx::program::uniform_ptr u_denoise_params;
        gfx::program::uniform_ptr u_denoise_params2;
        gfx::program::uniform_ptr s_ssil_input;
        gfx::program::uniform_ptr s_normal;
        gfx::program::uniform_ptr s_depth;
        gfx::program::uniform_ptr s_ssil_moments;
        gfx::program::uniform_ptr s_ssil_variance;
 
        void cache_uniforms()
        {
            cache_uniform(program.get(), u_denoise_params, "u_denoise_params", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_denoise_params2, "u_denoise_params2", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), s_ssil_input, "s_ssil_input", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_normal, "s_normal", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_depth, "s_depth", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_ssil_moments, "s_ssil_moments", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_ssil_variance, "s_ssil_variance", gfx::uniform_type::Sampler);
        }
 
        auto is_valid() const -> bool { return program && program->is_valid(); }
    } denoise_program_;
 
    // Geometry-aware 2x downsample compute program. Produces the half-resolution input the
    // wide a-trous passes run on (see cs_ssil_downsample.sc).
    struct downsample_program : uniforms_cache
    {
        gpu_program::ptr program;
        gfx::program::uniform_ptr u_downsample_params;
        gfx::program::uniform_ptr s_ssil_input;
        gfx::program::uniform_ptr s_normal;
        gfx::program::uniform_ptr s_depth;
        gfx::program::uniform_ptr s_ssil_variance;
 
        void cache_uniforms()
        {
            cache_uniform(program.get(), u_downsample_params, "u_downsample_params", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), s_ssil_input, "s_ssil_input", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_normal, "s_normal", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_depth, "s_depth", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_ssil_variance, "s_ssil_variance", gfx::uniform_type::Sampler);
        }
 
        auto is_valid() const -> bool { return program && program->is_valid(); }
    } downsample_program_;
 
    // Temporal resolve program (fullscreen fragment shader)
    struct temporal_program : uniforms_cache
    {
        gpu_program::ptr program;
        gfx::program::uniform_ptr u_temporal_params;
        gfx::program::uniform_ptr u_temporal_params2;
        gfx::program::uniform_ptr u_temporal_resolution;
        gfx::program::uniform_ptr u_prev_view_proj;
        gfx::program::uniform_ptr s_ssil_curr;
        gfx::program::uniform_ptr s_ssil_history;
        gfx::program::uniform_ptr s_depth;
        gfx::program::uniform_ptr s_prev_depth;
        gfx::program::uniform_ptr s_ssil_moments_history;
        gfx::program::uniform_ptr s_normal;
 
        void cache_uniforms()
        {
            cache_uniform(program.get(), u_temporal_params, "u_temporal_params", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_temporal_params2, "u_temporal_params2", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_temporal_resolution, "u_temporal_resolution", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), u_prev_view_proj, "u_prev_view_proj", gfx::uniform_type::Mat4);
            cache_uniform(program.get(), s_ssil_curr, "s_ssil_curr", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_ssil_history, "s_ssil_history", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_depth, "s_depth", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_prev_depth, "s_prev_depth", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_ssil_moments_history, "s_ssil_moments_history", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_normal, "s_normal", gfx::uniform_type::Sampler);
        }
 
        auto is_valid() const -> bool { return program && program->is_valid(); }
    } temporal_program_;
 
    // Joint-bilateral upsample program (fullscreen fragment shader)
    struct upsample_program : uniforms_cache
    {
        gpu_program::ptr program;
        gfx::program::uniform_ptr u_upsample_params;
        gfx::program::uniform_ptr s_ssil_input;
        gfx::program::uniform_ptr s_normal;
        gfx::program::uniform_ptr s_depth;
 
        void cache_uniforms()
        {
            cache_uniform(program.get(), u_upsample_params, "u_upsample_params", gfx::uniform_type::Vec4);
            cache_uniform(program.get(), s_ssil_input, "s_ssil_input", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_normal, "s_normal", gfx::uniform_type::Sampler);
            cache_uniform(program.get(), s_depth, "s_depth", gfx::uniform_type::Sampler);
        }
 
        auto is_valid() const -> bool { return program && program->is_valid(); }
    } upsample_program_;
};
 
} // namespace unravel