settings.cpp

Go to the documentation of this file.

#include "settings.hpp"
 
#include <fstream>
#include <serialization/associative_archive.h>
#include <serialization/binary_archive.h>
#include <serialization/types/array.hpp>
#include <engine/meta/assets/asset_handle.hpp>
#include <engine/meta/ecs/entity.hpp>
#include <engine/meta/input/input.hpp>
#include <engine/meta/assets/asset_importer_meta.hpp>
 
namespace unravel
{
 
REFLECT_INLINE(settings::app_settings)
{
    entt::meta_factory<settings::app_settings>{}
        .type("app_settings"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "app_settings"},
            entt::attribute{"pretty_name", "Application Settings"},
        })
        .data<&settings::app_settings::company>("company"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "company"},
            entt::attribute{"pretty_name", "Company"},
            entt::attribute{"tooltip", "Missing..."},
        })
        .data<&settings::app_settings::product>("product"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "product"},
            entt::attribute{"pretty_name", "Product"},
            entt::attribute{"tooltip", "Missing..."},
        })
        .data<&settings::app_settings::version>("version"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "version"},
            entt::attribute{"pretty_name", "Version"},
            entt::attribute{"tooltip", "Missing..."},
        });
}
 
SAVE_INLINE(settings::app_settings)
{
    try_save(ar, ser20::make_nvp("company", obj.company));
    try_save(ar, ser20::make_nvp("product", obj.product));
    try_save(ar, ser20::make_nvp("version", obj.version));
}
 
LOAD_INLINE(settings::app_settings)
{
    try_load(ar, ser20::make_nvp("company", obj.company));
    try_load(ar, ser20::make_nvp("product", obj.product));
    try_load(ar, ser20::make_nvp("version", obj.version));
}
 
 
REFLECT_INLINE(settings::asset_settings::texture_importer_settings)
{
    entt::meta_factory<settings::asset_settings::texture_importer_settings>{}
        .type("texture_importer_settings"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "texture_importer_settings"},
            entt::attribute{"pretty_name", "Texture Importer Settings"},
        })
        .data<&settings::asset_settings::texture_importer_settings::default_max_size>("default_max_size"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "default_max_size"},
            entt::attribute{"pretty_name", "Default Max Size"},
            entt::attribute{"tooltip", "The default maximum size for textures."},
        })
        .data<&settings::asset_settings::texture_importer_settings::default_compression>("default_compression"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "default_compression"},
            entt::attribute{"pretty_name", "Default Compression"},
            entt::attribute{"tooltip", "The default compression for textures."},
        });
}
 
SAVE_INLINE(settings::asset_settings::texture_importer_settings)
{
    try_save(ar, ser20::make_nvp("default_max_size", obj.default_max_size));
    try_save(ar, ser20::make_nvp("default_compression", obj.default_compression));
}
 
LOAD_INLINE(settings::asset_settings::texture_importer_settings)
{
    try_load(ar, ser20::make_nvp("default_max_size", obj.default_max_size));
    try_load(ar, ser20::make_nvp("default_compression", obj.default_compression));
}
 
SAVE_INLINE(settings::asset_settings)
{
    try_save(ar, ser20::make_nvp("texture", obj.texture));
}
 
LOAD_INLINE(settings::asset_settings)
{
    try_load(ar, ser20::make_nvp("texture", obj.texture));
}
 
 
REFLECT_INLINE(settings::graphics_settings)
{
    entt::meta_factory<settings::graphics_settings>{}
        .type("graphics_settings"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "graphics_settings"},
            entt::attribute{"pretty_name", "Graphics Settings"},
        });
}
 
SAVE_INLINE(settings::graphics_settings)
{
    // try_save(ar, ser20::make_nvp("company", obj.company));
    // try_save(ar, ser20::make_nvp("product", obj.product));
    // try_save(ar, ser20::make_nvp("version", obj.version));
}
 
LOAD_INLINE(settings::graphics_settings)
{
    // try_load(ar, ser20::make_nvp("company", obj.company));
    // try_load(ar, ser20::make_nvp("product", obj.product));
    // try_load(ar, ser20::make_nvp("version", obj.version));
}
 
REFLECT_INLINE(settings::standalone_settings)
{
 
    entt::meta_factory<settings::standalone_settings>{}
        .type("standalone_settings"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "standalone_settings"},
            entt::attribute{"pretty_name", "Standalone Settings"},
        })
        .data<&settings::standalone_settings::startup_scene>("startup_scene"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "startup_scene"},
            entt::attribute{"pretty_name", "Startup Scene"},
            entt::attribute{"tooltip", "The scene to load first."},
        });
}
 
SAVE_INLINE(settings::standalone_settings)
{
    try_save(ar, ser20::make_nvp("startup_scene", obj.startup_scene));
}
 
LOAD_INLINE(settings::standalone_settings)
{
    try_load(ar, ser20::make_nvp("startup_scene", obj.startup_scene));
}
 
REFLECT_INLINE(settings::time_settings)
{
    entt::meta_factory<settings::time_settings>{}
        .type("time_settings"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "time_settings"},
            entt::attribute{"pretty_name", "Time Settings"},
        })
        .data<&settings::time_settings::fixed_timestep>("fixed_timestep"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "fixed_timestep"},
            entt::attribute{"pretty_name", "Fixed Timestep"},
            entt::attribute{"step", 0.001f},
            entt::attribute{"tooltip", "A framerate-idependent interval which dictates when physics calculations and FixedUpdate events are performed."},
        })
        .data<&settings::time_settings::max_fixed_steps>("max_fixed_steps"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "max_fixed_steps"},
            entt::attribute{"pretty_name", "Max Fixed Steps"},
            entt::attribute{"tooltip", "A cap for framerate-idependent worst case scenario. No more than this much fixed updates per frame."},
        });
}
 
SAVE_INLINE(settings::time_settings)
{
    try_save(ar, ser20::make_nvp("fixed_timestep", obj.fixed_timestep));
    try_save(ar, ser20::make_nvp("max_fixed_steps", obj.max_fixed_steps));
}
 
LOAD_INLINE(settings::time_settings)
{
    try_load(ar, ser20::make_nvp("fixed_timestep", obj.fixed_timestep));
    try_load(ar, ser20::make_nvp("max_fixed_steps", obj.max_fixed_steps));
}
 
REFLECT_INLINE(settings::layer_settings)
{
    entt::meta_factory<settings::layer_settings>{}
        .type("layer_settings"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "layer_settings"},
            entt::attribute{"pretty_name", "Layer Settings"},
        })
        .data<&settings::layer_settings::layers>("layers"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "layers"},
            entt::attribute{"pretty_name", "Layers"},
            entt::attribute{"readonly_count", get_reserved_layers().size()},
            entt::attribute{"tooltip", ""},
        });
}
 
SAVE_INLINE(settings::layer_settings)
{
    try_save(ar, ser20::make_nvp("layers", obj.layers));
}
 
LOAD_INLINE(settings::layer_settings)
{
    try_load(ar, ser20::make_nvp("layers", obj.layers));
}
 
SAVE_INLINE(settings::input_settings)
{
    try_save(ar, ser20::make_nvp("actions", obj.actions));
}
 
LOAD_INLINE(settings::input_settings)
{
    try_load(ar, ser20::make_nvp("actions", obj.actions));
}
 
 
SAVE_INLINE(settings::resolution_settings::resolution)
{
    try_save(ar, ser20::make_nvp("name", obj.name));
    try_save(ar, ser20::make_nvp("width", obj.width));
    try_save(ar, ser20::make_nvp("height", obj.height));
    try_save(ar, ser20::make_nvp("aspect", obj.aspect));
}
 
LOAD_INLINE(settings::resolution_settings::resolution)
{
    try_load(ar, ser20::make_nvp("name", obj.name));
    try_load(ar, ser20::make_nvp("width", obj.width));
    try_load(ar, ser20::make_nvp("height", obj.height));
    try_load(ar, ser20::make_nvp("aspect", obj.aspect));
}
 
SAVE_INLINE(settings::resolution_settings)
{
    try_save(ar, ser20::make_nvp("resolutions", obj.resolutions));
    try_save(ar, ser20::make_nvp("current_resolution", obj.current_resolution));
}
 
LOAD_INLINE(settings::resolution_settings)
{
    try_load(ar, ser20::make_nvp("resolutions", obj.resolutions));
    try_load(ar, ser20::make_nvp("current_resolution", obj.current_resolution));
}
 
REFLECT_INLINE(settings::resolution_settings::resolution)
{
    entt::meta_factory<settings::resolution_settings::resolution>{}
        .type("resolution"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "resolution"},
            entt::attribute{"pretty_name", "Resolution"},
        })
        .data<&settings::resolution_settings::resolution::name>("name"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "name"},
            entt::attribute{"pretty_name", "Name"},
            entt::attribute{"tooltip", "Display name for this resolution"},
        })
        .data<&settings::resolution_settings::resolution::width>("width"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "width"},
            entt::attribute{"pretty_name", "Width"},
            entt::attribute{"min", 0},
            entt::attribute{"tooltip", "Width in pixels (0 for free aspect)"},
        })
        .data<&settings::resolution_settings::resolution::height>("height"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "height"},
            entt::attribute{"pretty_name", "Height"},
            entt::attribute{"min", 0},
            entt::attribute{"tooltip", "Height in pixels (0 for free aspect)"},
        })
        .data<&settings::resolution_settings::resolution::aspect>("aspect"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "aspect"},
            entt::attribute{"pretty_name", "Aspect Ratio"},
            entt::attribute{"min", 0.0f},
            entt::attribute{"tooltip", "Aspect ratio (0 for free aspect)"},
        });
}
 
REFLECT_INLINE(settings::resolution_settings)
{
    entt::meta_factory<settings::resolution_settings>{}
        .type("resolution_settings"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "resolution_settings"},
            entt::attribute{"pretty_name", "Resolution Settings"},
        })
        .data<&settings::resolution_settings::resolutions>("resolutions"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "resolutions"},
            entt::attribute{"pretty_name", "Resolutions"},
            entt::attribute{"tooltip", "List of available resolutions"},
        })
        .data<&settings::resolution_settings::current_resolution>("current_resolution"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "current_resolution"},
            entt::attribute{"pretty_name", "Current Resolution"},
            entt::attribute{"tooltip", "The current resolution to use"},
        });
}
 
REFLECT(settings)
{
 
    entt::meta_factory<settings>{}
        .type("settings"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "settings"},
            entt::attribute{"pretty_name", "Settings"},
        })
        .data<&settings::app>("app"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "app"},
            entt::attribute{"pretty_name", "Application"},
            entt::attribute{"tooltip", "Missing..."},
        })
        .data<&settings::graphics>("graphics"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "graphics"},
            entt::attribute{"pretty_name", "Graphics"},
            entt::attribute{"tooltip", "Missing..."},
        })
        .data<&settings::standalone>("standalone"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "standalone"},
            entt::attribute{"pretty_name", "Standalone"},
            entt::attribute{"tooltip", "Missing..."},
        })
        .data<&settings::resolution>("resolution"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "resolution"},
            entt::attribute{"pretty_name", "Resolution"},
            entt::attribute{"tooltip", "Resolution settings for the project"},
        });
}
 
SAVE(settings)
{
    try_save(ar, ser20::make_nvp("app", obj.app));
    try_save(ar, ser20::make_nvp("assets", obj.assets));
    try_save(ar, ser20::make_nvp("graphics", obj.graphics));
    try_save(ar, ser20::make_nvp("standalone", obj.standalone));
    try_save(ar, ser20::make_nvp("layer", obj.layer));
    try_save(ar, ser20::make_nvp("input", obj.input));
    try_save(ar, ser20::make_nvp("time", obj.time));
    try_save(ar, ser20::make_nvp("resolutions", obj.resolution));
}
SAVE_INSTANTIATE(settings, ser20::oarchive_associative_t);
SAVE_INSTANTIATE(settings, ser20::oarchive_binary_t);
 
LOAD(settings)
{
    try_load(ar, ser20::make_nvp("app", obj.app));
    try_load(ar, ser20::make_nvp("assets", obj.assets));
    try_load(ar, ser20::make_nvp("graphics", obj.graphics));
    try_load(ar, ser20::make_nvp("standalone", obj.standalone));
    try_load(ar, ser20::make_nvp("layer", obj.layer));
    try_load(ar, ser20::make_nvp("input", obj.input));
    try_load(ar, ser20::make_nvp("time", obj.time));
    try_load(ar, ser20::make_nvp("resolutions", obj.resolution));
}
LOAD_INSTANTIATE(settings, ser20::iarchive_associative_t);
LOAD_INSTANTIATE(settings, ser20::iarchive_binary_t);
 
void save_to_file(const std::string& absolute_path, const settings& obj)
{
    std::ofstream stream(absolute_path);
    if(stream.good())
    {
        auto ar = ser20::create_oarchive_associative(stream);
        try_save(ar, ser20::make_nvp("settings", obj));
    }
}
 
void save_to_file_bin(const std::string& absolute_path, const settings& obj)
{
    std::ofstream stream(absolute_path, std::ios::binary);
    if(stream.good())
    {
        ser20::oarchive_binary_t ar(stream);
        try_save(ar, ser20::make_nvp("settings", obj));
    }
}
 
auto load_from_file(const std::string& absolute_path, settings& obj) -> bool
{
    std::ifstream stream(absolute_path);
    if(stream.good())
    {
        auto ar = ser20::create_iarchive_associative(stream);
        return try_load(ar, ser20::make_nvp("settings", obj));
    }
 
    return false;
}
 
auto load_from_file_bin(const std::string& absolute_path, settings& obj) -> bool
{
    std::ifstream stream(absolute_path, std::ios::binary);
    if(stream.good())
    {
        ser20::iarchive_binary_t ar(stream);
        return try_load(ar, ser20::make_nvp("settings", obj));
    }
 
    return false;
}
 
} // namespace unravel