light.h

Go to the documentation of this file.

#pragma once
 
#include <engine/engine_export.h>
 
#include <cstdint>
#include <math/math.h>
 
namespace unravel
{
enum class light_type : uint8_t
{
    spot = 0,
    point = 1,
    directional = 2,
 
    count
};
 
enum class sm_depth : uint8_t
{
    invz = 0,
    linear = 1,
 
    count
};
 
enum class pack_depth : uint8_t
{
    rgba = 0,
    vsm = 1,
 
    count
};
 
enum class sm_impl : uint8_t
{
    hard = 0,
    pcf = 1,
    pcss = 2,
    vsm = 3,
    esm = 4,
 
    count,
};
 
enum class sm_type : uint8_t
{
    single = 0,
    omni = 1,
    cascade = 2,
 
    count
};
 
enum class sm_resolution : uint8_t
{
    low,
    medium,
    high,
    very_high,
 
    count
};
 
struct light
{
    light_type type = light_type::directional;
 
    struct spot
    {
        void set_range(float r);
 
        float get_range() const
        {
            return range;
        }
 
        void set_outer_angle(float angle);
 
        float get_outer_angle() const
        {
            return outer_angle;
        }
 
        void set_inner_angle(float angle);
 
        float get_inner_angle() const
        {
            return inner_angle;
        }
 
        float range = 10.0f;
        float outer_angle = 60.0f;
        float inner_angle = 30.0f;
 
        // struct shadowmap_params
        // {
        // } shadow_params{};
    };
 
    struct point
    {
        float range = 10.0f;
        float exponent_falloff = 1.0f;
 
        // struct shadowmap_params
        // {
        //     /// Field of view x-axis adjustment.
        //     float fov_x_adjust = 0.0f;
        //     /// Field of view y-axis adjustment.
        //     float fov_y_adjust = 0.0f;
        //     /// Whether to use stencil packing.
        //     bool stencil_pack = false;
 
        // } shadow_params{};
    };
 
    struct directional
    {
        // struct shadowmap_params
        // {
        //     /// Split distribution for cascade shadow maps.
        //     float split_distribution = 0.8f;
        //     /// Number of splits for cascade shadow maps.
        //     uint8_t num_splits = 4;
        //     /// Whether to stabilize the shadow map.
        //     bool stabilize = true;
        // } shadow_params{};
    };
 
    spot spot_data;
    point point_data;
    directional directional_data;
    math::color color = math::color(255, 244, 214, 255);
    float intensity = 5.0f;
 
    bool casts_shadows{true};
 
    struct shadowmap_params
    {
        sm_depth depth = sm_depth::invz;
        sm_impl type = sm_impl::pcf;
        sm_resolution resolution = sm_resolution::high;
        float near_plane{0.2f};
        float far_plane{550.0f};
        float bias{0.00100f};
        float normal_bias{0.1300f};
 
        struct hard_impl_params
        {
            // Hard shadows don't require any special parameters
        };
 
        struct pcf_impl_params
        {
            float x_offset{1.0f};
            float y_offset{1.0f};
        };
 
        struct pcss_impl_params
        {
            float penumbra_x_offset{1.0f};
            float penumbra_y_offset{1.5f};
        };
 
        struct vsm_impl_params
        {
            float min_variance{0.02f};
            float depth_multiplier{450.0f};
            bool do_blur{true};
            float blur_x_offset{1.0f};
            float blur_y_offset{1.0f};
        };
 
        struct esm_impl_params
        {
            float hardness{0.7f};
            float depth_multiplier{9000.0f};
            bool do_blur{true};
            float blur_x_offset{1.0f};
            float blur_y_offset{1.0f};
        };
 
    
        hard_impl_params hard;
        pcf_impl_params pcf;
        pcss_impl_params pcss;
        vsm_impl_params vsm;
        esm_impl_params esm;
 
 
        bool show_coverage{false};
 
       
 
    } shadow_params;
 
    
    struct directional_shadowmap_params
    {
        float split_distribution = 0.8f;
        uint8_t num_splits = 4;
        bool stabilize = true;
    } directional_shadow_params{};
 
    struct point_shadowmap_params
    {
        float fov_x_adjust = 0.0f;
        float fov_y_adjust = 0.0f;
        bool stencil_pack = false;
 
    } point_shadow_params{};
    
    struct spot_shadowmap_params
    {
    } spot_shadow_params{};
 
    struct contact_shadow_params
    {
        bool enabled{false};
        float ray_length{0.2f};
        float thickness{0.15f};
        float n_dot_l_fade_start{0.0f};
        float n_dot_l_fade_end{0.475f};
        float normal_facing_reject{-1.0f};
    } contact_shadow;
};
 
} // namespace unravel