reflection_probe_component.h

Go to the documentation of this file.

#pragma once
#include <base/basetypes.hpp>
#include <engine/ecs/components/basic_component.h>
#include <engine/rendering/reflection_probe.h>
 
#include <graphics/render_pass.h>
#include <graphics/render_view.h>
 
#include <array>
 
namespace unravel
{
 
class reflection_probe_component : public component_crtp<reflection_probe_component>
{
public:
    auto get_probe() const -> const reflection_probe&;
 
    void set_probe(const reflection_probe& probe);
 
    auto get_bounds() const -> math::bbox;
 
    auto compute_projected_sphere_rect(irect32_t& rect,
                                       const math::vec3& position,
                                       const math::vec3& scale,
                                       const math::vec3& view_origin,
                                       const math::transform& view,
                                       const math::transform& proj) const -> int;
 
    auto get_render_view(size_t idx) -> gfx::render_view&;
 
    auto get_cubemap_prefiltered() -> const gfx::texture::ptr&;
    auto get_cubemap() -> const gfx::texture::ptr&;
 
    auto get_cubemap_fbo(size_t face) -> const gfx::frame_buffer::ptr&;
 
    void update(float dt);
    void release_resources();
 
    auto already_generated() const -> bool;
 
    auto already_generated(size_t face) const -> bool;
 
    void set_generation_frame(size_t face, uint64_t frame);
 
    void mark_dirty(bool force_full_first_frame = false);
 
    auto is_dirty() const -> bool;
 
    auto is_bake_cycle_unstarted() const -> bool;
 
    auto is_bake_complete() const -> bool;
 
    auto get_faces_per_frame() const -> size_t { return faces_per_frame_; }
 
    void set_faces_per_frame(size_t faces) { faces_per_frame_ = faces; }
 
    auto get_apply_prefilter() const -> bool { return apply_prefilter_; }
 
    void set_apply_prefilter(bool apply) { apply_prefilter_ = apply; }
 
    auto get_update_mode() const -> probe_update_mode { return update_mode_; }
 
    void set_update_mode(probe_update_mode mode);
 
    auto get_update_interval() const -> float { return update_interval_; }
 
    void set_update_interval(float seconds) { update_interval_ = seconds; }
 
    auto get_resolution() const -> probe_resolution { return resolution_; }
 
    void set_resolution(probe_resolution resolution);
 
    auto get_capture_sky() const -> bool { return capture_sky_; }
 
    void set_capture_sky(bool capture);
 
    auto get_capture_shadows() const -> bool { return capture_shadows_; }
 
    void set_capture_shadows(bool capture);
 
private:
    reflection_probe probe_;
 
    std::array<gfx::render_view, 6> face_rviews_;
    gfx::render_view rview_;
 
    std::array<uint64_t, 6> generated_frame_{uint64_t(-1),
                                             uint64_t(-1),
                                             uint64_t(-1),
                                             uint64_t(-1),
                                             uint64_t(-1),
                                             uint64_t(-1)};
 
    bool apply_prefilter_{true};
    size_t faces_per_frame_ = 1;
    size_t generated_faces_count_ = 0;
    bool first_generation_{true};
    float time_since_last_refresh_ = 0.0f;
    bool has_pending_bake_{false};
 
    probe_update_mode update_mode_{probe_update_mode::once};
    float update_interval_{0.0f};
    probe_resolution resolution_{probe_resolution::res_256};
    bool capture_sky_{true};
    bool capture_shadows_{true};
};
 
} // namespace unravel