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 = {1.0f, 1.0f, 1.0f, 1.0f};
    float intensity = 2.5f;
 
    float ambient_intensity = 0.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.00110f};
        float normal_bias{0.015f};
 
 
        // struct impl_params
        // {
        //     /// Custom parameter 0 for shadow mapping.
        //     float hardness{};
        //     /// Custom parameter 1 for shadow mapping.
        //     float depth_multiplier{};
        //     /// Number of shadow maps along the x-axis.
        //     float blur_x_num{2};
        //     /// Number of shadow maps along the y-axis.
        //     float blur_y_num{2};
        //     /// Offset along the x-axis for shadow mapping.
        //     float blur_x_offset{1};
        //     /// Offset along the y-axis for shadow mapping.
        //     float blur_y_offset{1};
        //     /// Whether to perform blur on the shadow map.
        //     bool do_blur{true};
        // } impl;
 
 
        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{};
};
 
} // namespace unravel