render_settings.h

#pragma once
 
#include <cstdint>
 
#include "core/reflect.h"
 
namespace Vkm::Engine {

enum class TextureFiltering : uint8_t {
    Nearest = 0,
    Bilinear,
    Trilinear,
    Count       
};

#define VKM_RENDER_MODES(X)                                              \
    X(Default,          "Default",              DEFAULT,           true)  \
    X(Depth,            "Depth",                DEPTH,             false) \
    X(Normals,          "Normals",              NORMALS,           false) \
    X(Roughness,        "Roughness (authored)", ROUGHNESS,         false) \
    X(Metalness,        "Metalness (authored)", METALNESS,         false) \
    X(AmbientOcclusion, "Ambient Occlusion",    AMBIENT_OCCLUSION, false) \
    X(Bloom,            "Bloom",                BLOOM,             false) \
    X(ShadowAtlas,      "Shadow Atlas",         SHADOW_ATLAS,      false) \
    X(Fog,              "Fog",                  FOG,               false) \
    X(GiOnly,           "GI Only",              GI_ONLY,           true)  \
    X(DirectOnly,       "Direct Only",          DIRECT_ONLY,       true)  \
    X(Clusters,         "Light Clusters",       CLUSTERS,          true)

#define VKM_TONEMAPS(X)                                   \
    X(Reinhard,       "Reinhard",            REINHARD)    \
    X(ACES,           "ACES (filmic)",       ACES)        \
    X(KhronosNeutral, "Khronos PBR Neutral", KHRONOS_NEUTRAL)

enum class Tonemap : uint8_t {
#define VKM_TONEMAP_ENUMERATOR(name, label, glsl) name,
    VKM_TONEMAPS(VKM_TONEMAP_ENUMERATOR)
#undef VKM_TONEMAP_ENUMERATOR
    Count,  
};

enum class RenderMode : uint8_t {
#define VKM_RENDER_MODE_ENUMERATOR(name, label, glsl, shaded) name,
    VKM_RENDER_MODES(VKM_RENDER_MODE_ENUMERATOR)
#undef VKM_RENDER_MODE_ENUMERATOR
    Count,  
};

struct RenderSettings {
    // Debug
    RenderMode renderMode = RenderMode::Default;
 
    // Pass toggles
    bool gtao       = true;
    bool bloom      = true;
    bool probes     = true;
    bool ssr        = true;   
 
    // GTAO
    float gtaoRadius    = 0.6f;   
    float gtaoIntensity = 1.0f;   
    float gtaoPower     = 1.5f;   
 
    // Screen-space reflections
    float ssrMaxRoughness = 0.6f;   
    float ssrMaxDistance  = 50.0f;  
 
    // Bloom
    float bloomStrength  = 0.06f;   
    float bloomThreshold = 1.0f;    
    float bloomKnee      = 0.5f;    
    float bloomRadius    = 0.005f;  
 
    // Display transform
    Tonemap tonemap = Tonemap::Reinhard;

    float exposure = 0.0f;
 
    // Culling
    float cullMaxDistance = 500.0f;  
    float cullMinPixels   = 3.0f;    
 
    // Anti-aliasing
    uint32_t msaaSamples = 4;

    TextureFiltering textureFiltering = TextureFiltering::Trilinear;
    uint32_t textureAnisotropy = 16;
 
    // Shadows
    uint32_t shadowResolution = 4096;
 
    // Overlays
    bool grid = false;  

    static constexpr float MIN_GTAO_RADIUS = 0.05f;
    static constexpr float MAX_GTAO_RADIUS = 5.0f;
 
    static constexpr uint32_t MSAA_SAMPLE_COUNTS[] = {1, 2, 4, 8};  

    static bool isMsaaSampleCount(uint32_t samples) {
        for (const uint32_t count : MSAA_SAMPLE_COUNTS) {
            if (count == samples) return true;
        }
        return false;
    }
};

template <typename Settings, typename Fn>
void visitShippedRenderFields(Settings& r, Fn&& f) {
    f("gtao",              r.gtao);
    f("bloom",             r.bloom);
    f("probes",            r.probes);
    f("ssr",               r.ssr);
    f("gtaoRadius",        r.gtaoRadius);
    f("gtaoIntensity",     r.gtaoIntensity);
    f("gtaoPower",         r.gtaoPower);
    f("ssrMaxRoughness",   r.ssrMaxRoughness);
    f("ssrMaxDistance",    r.ssrMaxDistance);
    f("bloomStrength",     r.bloomStrength);
    f("bloomThreshold",    r.bloomThreshold);
    f("bloomKnee",         r.bloomKnee);
    f("bloomRadius",       r.bloomRadius);
    f("tonemap",           r.tonemap);
    f("exposure",          r.exposure);
    f("cullMaxDistance",   r.cullMaxDistance);
    f("cullMinPixels",     r.cullMinPixels);
    f("msaaSamples",       r.msaaSamples);
    f("textureFiltering",  r.textureFiltering);
    f("textureAnisotropy", r.textureAnisotropy);
    f("shadowResolution",  r.shadowResolution);
}
 
} // namespace Vkm::Engine
 
#define VKM_TONEMAP_LABEL(name, label, glsl) label,
VKM_ENUM_NAMES(::Vkm::Engine::Tonemap, VKM_TONEMAPS(VKM_TONEMAP_LABEL))
#undef VKM_TONEMAP_LABEL
 
#define VKM_RENDER_MODE_LABEL(name, label, glsl, shaded) label,
VKM_ENUM_NAMES(::Vkm::Engine::RenderMode, VKM_RENDER_MODES(VKM_RENDER_MODE_LABEL))
#undef VKM_RENDER_MODE_LABEL
 
VKM_ENUM_NAMES(::Vkm::Engine::TextureFiltering, "Nearest", "Bilinear", "Trilinear")