reflection_probe.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include <math/math.h>
 
#include <cstdint>
 
namespace unravel
{
enum class probe_type : std::uint8_t
{
    box = 0,
    sphere = 1
};
 
enum class reflect_method : std::uint8_t
{
    environment = 0,
    static_only = 1
};
 
enum class probe_update_mode : std::uint8_t
{
    on_demand = 0,
    once = 1,
    realtime = 2
};
 
enum class probe_resolution : std::uint8_t
{
    res_16 = 0,
    res_32,
    res_64,
    res_128,
    res_256,
    res_512,
    res_1024,
 
    count
};
 
inline auto probe_resolution_to_size(probe_resolution resolution) -> std::uint16_t
{
    switch(resolution)
    {
    case probe_resolution::res_16:
        return 16;
    case probe_resolution::res_32:
        return 32;
    case probe_resolution::res_64:
        return 64;
    case probe_resolution::res_128:
        return 128;
    case probe_resolution::res_256:
        return 256;
    case probe_resolution::res_512:
        return 512;
    case probe_resolution::res_1024:
        return 1024;
    default:
        return 256;
    }
}
 
struct reflection_probe
{
    struct box
    {
        math::vec3 extents = {5.0, 5.0f, 5.0f};
        float transition_distance = 1.0f;
    };
 
    struct sphere
    {
        float range = 5.0f;
    };
 
    auto get_face_extents(uint32_t face, const math::transform& transform) const -> float
    {
        const auto& scale = transform.get_scale();
 
        if(type == probe_type::sphere)
        {
            auto max_scale = math::max(scale.x, math::max(scale.y, scale.z));
            return sphere_data.range * max_scale;
        }
 
        if(type == probe_type::box)
        {
            auto scaled_extents = box_data.extents * scale;
            return math::max(scaled_extents.x, math::max(scaled_extents.y, scaled_extents.z));
        }
 
        return {};
    }
 
    auto get_max_range() const -> float
    {
        if(type == probe_type::sphere)
        {
            return sphere_data.range;
        }
        else if(type == probe_type::box)
        {
            return math::max(box_data.extents.x, math::max(box_data.extents.y, box_data.extents.z));
        }
        return 0.0f;
    }
 
    probe_type type = probe_type::box;
    reflect_method method = reflect_method::environment;
    float intensity = 1.0f;
    box box_data;
    sphere sphere_data;
};
 
inline auto operator==(const reflection_probe& pr1, const reflection_probe& pr2) -> bool
{
    return pr1.type == pr2.type && pr1.method == pr2.method &&
           math::equal(pr1.intensity, pr2.intensity, math::epsilon<float>()) &&
           math::all(math::equal(pr1.box_data.extents, pr2.box_data.extents, math::epsilon<float>())) &&
           math::equal(pr1.box_data.transition_distance, pr2.box_data.transition_distance, math::epsilon<float>()) &&
           math::equal(pr1.sphere_data.range, pr2.sphere_data.range, math::epsilon<float>());
}
 
inline auto operator!=(const reflection_probe& pr1, const reflection_probe& pr2) -> bool
{
    return !(pr1 == pr2);
}
 
} // namespace unravel