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/model.h>
#include <engine/rendering/batch_collector.h>
#include <graphics/frame_buffer.h>
#include <graphics/render_view.h>
 
#include <cstdint>
 
 
#include "passes/assao_pass.h"
#include "passes/atmospheric_pass_perez.h"
#include "passes/atmospheric_pass_skybox.h"
#include "passes/auto_exposure_pass.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/ssil_pass.h"
#include "passes/bloom_pass.h"
#include "passes/tonemapping_pass.h"
#include "passes/taa_pass.h"
#include "volume_resolver.h"
 
#include <engine/ui/ecs/components/ui_document_component.h>
#include <engine/rendering/ecs/components/text_component.h>
#include <engine/ecs/components/transform_component.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 visibility_data
{
    entt::handle entity;
    unravel::lod_data lod_data;
};
 
using visibility_set_models_t = hpp::small_vector<visibility_data>;
 
struct pipeline_stats
{
    uint32_t drawn_models = 0;
    uint32_t drawn_static_submeshes = 0;
    uint32_t drawn_skinned_models = 0;
    uint32_t drawn_skinned_submeshes = 0;
    uint32_t drawn_models_for_shadows = 0;
    uint32_t drawn_submeshes_for_shadows = 0;
    uint32_t drawn_skinned_models_for_shadows = 0;
    uint32_t drawn_skinned_submeshes_for_shadows = 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_static_submeshes > 0 || drawn_skinned_models > 0 || drawn_skinned_submeshes > 0 ||
               drawn_models_for_shadows > 0 || drawn_submeshes_for_shadows > 0 || drawn_skinned_models_for_shadows > 0 ||
               drawn_skinned_submeshes_for_shadows > 0 || drawn_lights > 0 || drawn_lights_casting_shadows > 0 || drawn_particles > 0 ||
               drawn_particles_batches > 0;
    }
    
    void add_batch_stats(const batch_stats& stats);
    void add_stats(const pipeline_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,     
    };
 
    using visibility_flags = uint32_t; 
    using pipeline_flags = uint32_t;
 
    enum class pipeline_run_type : std::uint8_t
    {
        camera = 0,
        reflection_probe_capture = 1,
    };
 
    struct run_params
    {
        visibility_flags vflags = visibility_query::not_specified;
 
        pipeline_run_type run_type = pipeline_run_type::camera;
 
        pipeline_flags pflags = 0xFFFFFFFFu;
 
        std::function<void(assao_pass::run_params& params)> fill_assao_params;
        std::function<void(auto_exposure_pass::run_params& params)> fill_auto_exposure_params;
        std::function<void(bloom_pass::run_params& params)> fill_bloom_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(taa_pass::run_params& params)> fill_taa_params;
        std::function<void(camera&, const usize32_t& viewport_size)> apply_taa_params;
        std::function<void(ssr_pass::run_params& params)> fill_ssr_params;
        std::function<void(ssil_pass::run_params& params)> fill_ssil_params;
    };
 
    pipeline() = default;
    virtual ~pipeline() = default;
 
    virtual auto init(rtti::context& ctx) -> bool;
 
    virtual void gather_visible_models(scene& scn,
                                       const camera* cam,
                                       visibility_flags query,
                                       const layer_mask& render_mask,
                                       delta_t dt,
                                       const std::function<void(entt::handle entity, const lod_data& lod_data)>& lod_data_callback,
                                       const camera* lod_reference_cam = nullptr);
 
    static auto get_shadow_lod_bias() -> float;
    static void set_shadow_lod_bias(float bias);
 
    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 run_ui_pass(scene& scn,
                         const camera& camera,
                         gfx::render_view& rview,
                         const gfx::frame_buffer::ptr& output);
 
    virtual void run_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;
    virtual auto create_run_params(entt::handle camera_ent, scene* scn, const camera* cam) const -> rendering::pipeline::run_params;
 
    auto get_stats() -> pipeline_stats&
    {
        return stats_;
    }
 
protected:
    prefilter_pass prefilter_pass_{};
    blit_pass blit_pass_{};
    atmospheric_pass_perez atmospheric_pass_perez_{};
    atmospheric_pass_skybox atmospheric_pass_skybox_{};
    assao_pass assao_pass_{};
    auto_exposure_pass auto_exposure_pass_{};
    bloom_pass bloom_pass_{};
    fxaa_pass fxaa_pass_{};
    taa_pass taa_pass_{};
    tonemapping_pass tonemapping_pass_{};
    ssr_pass ssr_pass_{};
    hiz_pass hiz_pass_{}; 
    ssil_pass ssil_pass_{};
 
    std::unique_ptr<gpu_program> particle_program_{};
    std::unique_ptr<gpu_program> particle_program_instanced_{};
    std::unique_ptr<gpu_program> particle_program_instanced_mask_{};
    std::unique_ptr<gpu_program> world_quad_program_{};
 
    pipeline_stats stats_{};
 
 
    entt::registry cache_registry_;
    entt::entity cache_entity_;
};
} // namespace rendering
} // namespace unravel