scene_environment_settings.h

#pragma once
 
#include "pixelbullet/filesystem/asset_path.h"
#include "pixelbullet/filesystem/asset_path_serialization.h"
#include "pixelbullet/serialization/node.h"
#include "pixelbullet/serialization/node_reader.h"
 
#include <array>
#include <string_view>
 
namespace pixelbullet
{
struct SceneEnvironmentSettings
{
    bool enabled = false;
    AssetPath environment_asset;
    float background_intensity = 1.0f;
    float ambient_intensity = 0.15f;
    float specular_intensity = 1.0f;
    float exposure = 1.0f;
 
    [[nodiscard]] bool operator==(const SceneEnvironmentSettings& other) const noexcept
    {
        return enabled == other.enabled && environment_asset.logical_path() == other.environment_asset.logical_path() &&
               background_intensity == other.background_intensity && ambient_intensity == other.ambient_intensity &&
               specular_intensity == other.specular_intensity && exposure == other.exposure;
    }
 
    [[nodiscard]] bool operator!=(const SceneEnvironmentSettings& other) const noexcept
    {
        return !(*this == other);
    }
};
 
inline constexpr std::array<std::string_view, 6> k_scene_environment_cubemap_faces = {
    "Right", "Left", "Top", "Bottom", "Front", "Back",
};
 
inline Node& operator<<(Node& node, const SceneEnvironmentSettings& settings)
{
    node["enabled"] << settings.enabled;
    node["environmentAsset"] << settings.environment_asset;
    node["backgroundIntensity"] << settings.background_intensity;
    node["ambientIntensity"] << settings.ambient_intensity;
    node["specularIntensity"] << settings.specular_intensity;
    node["exposure"] << settings.exposure;
    return node;
}
 
inline const Node& operator>>(const Node& node, SceneEnvironmentSettings& settings)
{
    if (node.has_property("enabled"))
    {
        node["enabled"] >> settings.enabled;
    }
    if (node.has_property("environmentAsset"))
    {
        node["environmentAsset"] >> settings.environment_asset;
    }
    if (node.has_property("backgroundIntensity"))
    {
        node["backgroundIntensity"] >> settings.background_intensity;
    }
    if (node.has_property("ambientIntensity"))
    {
        node["ambientIntensity"] >> settings.ambient_intensity;
    }
    if (node.has_property("specularIntensity"))
    {
        node["specularIntensity"] >> settings.specular_intensity;
    }
    if (node.has_property("exposure"))
    {
        node["exposure"] >> settings.exposure;
    }
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, SceneEnvironmentSettings& settings, serialization::NodeReader& reader)
{
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "enabled", settings.enabled, reader);
    ok &= serialization::TryReadOptionalProperty(node, "environmentAsset", settings.environment_asset, reader);
    ok &= serialization::TryReadOptionalProperty(node, "backgroundIntensity", settings.background_intensity, reader);
    ok &= serialization::TryReadOptionalProperty(node, "ambientIntensity", settings.ambient_intensity, reader);
    ok &= serialization::TryReadOptionalProperty(node, "specularIntensity", settings.specular_intensity, reader);
    ok &= serialization::TryReadOptionalProperty(node, "exposure", settings.exposure, reader);
    return ok;
}
} // namespace pixelbullet