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();
 
    auto already_generated() const -> bool;
 
    auto already_generated(size_t face) const -> bool;
 
    void set_generation_frame(size_t face, uint64_t frame);
 
    
    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; }
 
private:
    reflection_probe probe_;
 
    std::array<gfx::render_view, 6> 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_{false};
    size_t faces_per_frame_ = 1;       // Number of faces to generate per frame
    size_t generated_faces_count_ = 0; // Number of faces generated in the current cycle
    bool first_generation_{true};
 
};
 
} // namespace unravel