pipeline.h

Go to the documentation of this file.

#pragma once
 
#include <engine/ecs/ecs.h>
#include <engine/layers/layer_mask.h>
#include <engine/rendering/camera.h>
#include <engine/rendering/batch_collector.h>
#include <graphics/frame_buffer.h>
#include <graphics/render_view.h>
 
 
#include "passes/assao_pass.h"
#include "passes/atmospheric_pass.h"
#include "passes/atmospheric_pass_perez.h"
#include "passes/atmospheric_pass_skybox.h"
#include "passes/blit_pass.h"
#include "passes/fxaa_pass.h"
#include "passes/hiz_pass.h"
#include "passes/prefilter_pass.h"
#include "passes/ssr_pass.h"
#include "passes/tonemapping_pass.h"
 
 
#include <base/basetypes.hpp>
#include <context/context.hpp>
 
#include <hpp/small_vector.hpp>
#include <map>
#include <memory>
#include <vector>
 
 
namespace unravel
{
namespace rendering
{
struct lod_data
{
    std::uint32_t current_lod_index = 0; 
    std::uint32_t target_lod_index = 0;  
    float current_time = 0.0f;           
};
 
using lod_data_container = std::map<entt::handle, lod_data>;
using visibility_set_models_t = hpp::small_vector<entt::handle>;
 
struct pipeline_stats
{
    uint32_t drawn_models = 0;
    uint32_t drawn_skinned_models = 0;
    uint32_t drawn_lights = 0;
    uint32_t drawn_lights_casting_shadows = 0;
    uint32_t drawn_particles = 0;
    uint32_t drawn_particles_batches = 0;
    
    // Static mesh batching statistics
    batch_stats batching_stats;
 
    auto anything_drawn() const -> bool
    {
        return drawn_models > 0 || drawn_skinned_models > 0 || drawn_lights > 0 ||
               drawn_lights_casting_shadows > 0 || drawn_particles > 0 || drawn_particles_batches > 0;
    }
    
    void add_batch_stats(const batch_stats& stats);
};
class pipeline
{
public:
    using uptr = std::unique_ptr<pipeline>;
    using sptr = std::shared_ptr<pipeline>;
    using wptr = std::weak_ptr<pipeline>;
 
    enum visibility_query : uint32_t
    {
        not_specified = 1 << 0,        
        is_dirty = 1 << 1,             
        is_static = 1 << 2,            
        is_shadow_caster = 1 << 3,     
        is_reflection_caster = 1 << 4, 
    };
 
    using visibility_flags = uint32_t; 
 
    struct run_params
    {
        visibility_flags vflags = visibility_query::not_specified;
 
        std::function<void(assao_pass::run_params& params)> fill_assao_params;
        std::function<void(tonemapping_pass::run_params& params)> fill_hdr_params;
        std::function<void(fxaa_pass::run_params& params)> fill_fxaa_params;
        std::function<void(ssr_pass::run_params& params)> fill_ssr_params;
    };
 
    pipeline() = default;
    virtual ~pipeline() = default;
 
    virtual auto init(rtti::context& ctx) -> bool;
 
    virtual auto gather_visible_models(scene& scn,
                                       const math::frustum* frustum,
                                       visibility_flags query,
                                       const layer_mask& render_mask) -> visibility_set_models_t;
 
    virtual auto run_pipeline(scene& scn,
                              const camera& camera,
                              gfx::render_view& rview,
                              delta_t dt,
                              const run_params& params,
                              layer_mask render_mask = layer_mask{
                                  layer_reserved::everything_layer}) -> gfx::frame_buffer::ptr = 0;
 
    virtual void run_pipeline(const gfx::frame_buffer::ptr& output,
                              scene& scn,
                              const camera& camera,
                              gfx::render_view& rview,
                              delta_t dt,
                              const run_params& params,
                              layer_mask render_mask = layer_mask{layer_reserved::everything_layer}) = 0;
 
    virtual void set_debug_pass(int pass) = 0;
 
    virtual void ui_pass(scene& scn,
                         const camera& camera,
                         gfx::render_view& rview,
                         const gfx::frame_buffer::ptr& output);
 
    virtual void particle_pass(scene& scn,
                               const camera& camera,
                               gfx::render_view& rview,
                               const gfx::frame_buffer::ptr& output);
 
    virtual auto create_run_params(entt::handle camera_ent) const -> rendering::pipeline::run_params;
 
    auto get_stats() -> pipeline_stats&
    {
        return stats_;
    }
 
protected:
    prefilter_pass prefilter_pass_{};
    blit_pass blit_pass_{};
    atmospheric_pass atmospheric_pass_{};
    atmospheric_pass_perez atmospheric_pass_perez_{};
    atmospheric_pass_skybox atmospheric_pass_skybox_{};
    assao_pass assao_pass_{};
    fxaa_pass fxaa_pass_{};
    tonemapping_pass tonemapping_pass_{};
    ssr_pass ssr_pass_{};
    hiz_pass hiz_pass_{}; 
 
    std::unique_ptr<gpu_program> particle_program_{};
    std::unique_ptr<gpu_program> particle_program_instanced_{};
 
    pipeline_stats stats_{};
};
} // namespace rendering
} // namespace unravel