light_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/light.h>
#include <engine/rendering/shadow.h>
 
namespace unravel
{
 
class light_component : public component_crtp<light_component>
{
public:
    auto get_light() const -> const light&;
 
    void set_light(const light& l);
 
    auto get_bounds() const -> math::bbox;
    auto get_bounds_sphere() const -> math::bsphere;
 
    auto get_bounds_precise(const math::vec3& light_direction) const -> math::bbox;
    auto get_bounds_sphere_precise(const math::vec3& light_direction) const -> math::bsphere;
 
    auto compute_projected_sphere_rect(irect32_t& rect,
                                       const math::vec3& light_position,
                                       const math::vec3& light_direction,
                                       const math::vec3& view_origin,
                                       const math::transform& view,
                                       const math::transform& proj) -> int;
 
    auto get_shadowmap_generator() -> shadow::shadowmap_generator&;
 
private:
    auto get_bounds_sphere_impl(const math::vec3* light_direction) const -> math::bsphere;
 
    light light_;
 
    std::shared_ptr<shadow::shadowmap_generator> shadowmap_generator_ = std::make_shared<shadow::shadowmap_generator>();
};
 
class skylight_component : public component_crtp<skylight_component>
{
public:
    enum class sky_mode
    {
        reserved_0 = 0,
        perez = 1,
        skybox = 2,
    };
 
    enum class irradiance_quality
    {
        flat,
        directional,
    };
 
    enum class cloud_mode
    {
        none = 0,
        flat = 1,
        volumetric = 2,
    };
 
    auto get_mode() const noexcept -> const sky_mode&;
 
    void set_mode(const sky_mode& mode);
 
    auto get_turbidity() const noexcept -> float;
 
    void set_turbidity(float turbidity);
 
    auto get_cloud_mode() const noexcept -> cloud_mode;
 
    void set_cloud_mode(cloud_mode mode);
 
    auto get_cloud_coverage() const noexcept -> float;
 
    void set_cloud_coverage(float coverage);
 
    auto get_cloud_base_altitude() const noexcept -> float;
 
    void set_cloud_base_altitude(float altitude);
 
    auto get_cloud_top_altitude() const noexcept -> float;
 
    void set_cloud_top_altitude(float altitude);
 
    auto get_cloud_speed() const noexcept -> float;
 
    void set_cloud_speed(float speed);
 
    auto get_cloud_density() const noexcept -> float;
 
    void set_cloud_density(float density);
 
    auto get_cloud_absorption() const noexcept -> float;
 
    void set_cloud_absorption(float absorption);
 
    auto get_cloud_light_absorption() const noexcept -> float;
 
    void set_cloud_light_absorption(float absorption);
 
    auto get_cloud_vol_uv_scale() const noexcept -> float;
    void set_cloud_vol_uv_scale(float scale);
 
    auto get_cloud_vol_edge_width() const noexcept -> float;
    void set_cloud_vol_edge_width(float width);
 
    auto get_cloud_vol_shape_power() const noexcept -> float;
    void set_cloud_vol_shape_power(float power);
 
    auto get_cloud_vol_detail_erode() const noexcept -> float;
    void set_cloud_vol_detail_erode(float erode);
 
    auto get_cloud_vol_macro_strength() const noexcept -> float;
    void set_cloud_vol_macro_strength(float strength);
 
    auto get_cloud_vol_coarse_scale() const noexcept -> float;
    void set_cloud_vol_coarse_scale(float scale);
 
    auto get_cloud_vol_base_mix() const noexcept -> float;
    void set_cloud_vol_base_mix(float mix);
 
    auto get_cloud_vol_sun_intensity() const noexcept -> float;
    void set_cloud_vol_sun_intensity(float intensity);
 
    auto get_irradiance_intensity() const noexcept -> float;
 
    void set_irradiance_intensity(float intensity);
 
    auto get_irradiance_tint() const noexcept -> const math::color&;
 
    void set_irradiance_tint(const math::color& color);
 
    auto get_irradiance_quality() const noexcept -> irradiance_quality;
 
    void set_irradiance_quality(irradiance_quality quality);
 
    auto get_irradiance_use_sky() const noexcept -> bool;
 
    void set_irradiance_use_sky(bool use_sky);
 
    auto get_sky_brightness() const noexcept -> float;
 
    void set_sky_brightness(float brightness);
 
    auto get_cubemap() const noexcept -> const asset_handle<gfx::texture>&
    {
        return cubemap_;
    }
    void set_cubemap(const asset_handle<gfx::texture>& cubemap)
    {
        cubemap_ = cubemap;
    }
 
    auto get_cloud_time() const noexcept -> float
    {
        return cloud_time_;
    }
 
    void update(delta_t dt)
    {
        // cloud_speed_ is in km/h. Convert to the noise-UV time scale used by
        // the shader (cloud_time * 0.5 UV/s). Calibrated so that 10-20 km/h =
        // gentle natural drift, ~100 km/h = strong visible wind.
        constexpr float kmh_to_time_scale = 1.0f / 500.0f;
        cloud_time_ += dt.count() * cloud_speed_ * kmh_to_time_scale;
    }
 
private:
    sky_mode mode_{sky_mode::perez};
 
    float turbidity_{1.9};
 
    cloud_mode cloud_mode_{cloud_mode::volumetric};
 
    float cloud_coverage_{0.52f};
 
    float cloud_base_altitude_{27500.0f};
 
    float cloud_top_altitude_{45000.0f};
 
    float cloud_speed_{0.0f};
 
    float cloud_density_{1.5f};
 
    float cloud_absorption_{0.08f};
 
    float cloud_light_absorption_{0.10f};
 
    float cloud_vol_uv_scale_{0.00008f};
    float cloud_vol_edge_width_{0.20f};
    float cloud_vol_shape_power_{1.12f};
    float cloud_vol_detail_erode_{0.48f};
    float cloud_vol_macro_strength_{0.36f};
    float cloud_vol_coarse_scale_{0.38f};
    float cloud_vol_base_mix_{0.45f};
    float cloud_vol_sun_intensity_{24.0f};
 
    float cloud_time_{0.0f};
 
    float irradiance_intensity_{0.05f};
 
    math::color irradiance_tint_{1.0f, 1.0f, 1.0f, 1.0f};
 
    irradiance_quality irradiance_quality_{irradiance_quality::directional};
 
    bool irradiance_use_sky_{true};
 
    float sky_brightness_{1.0f};
 
    asset_handle<gfx::texture> cubemap_;
};
 
} // namespace unravel