config.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <string>
#include <Windows.h>
 
#include <Strings/components/settings/config/config.h>
 
#include "components/resources/engine_globals/globals.h"
#include "components/diagnostics/errors/errors.h"
 
#define CONFIG_VER "1"                          
#define CONFIG_COMMENT_DELIMETER "#"            
#define CONFIG_DEFAULT_NAME "engine.cfg"        
#define CONFIG_COLOR_NAME "console_colors.cfg"  
 
 
#define ENGINE_CFG Blam::Settings::Config::GetEngineConfiguration()
 
#define ENGINE_CFG_SECTION(section_name) Blam::Settings::Config::GetEngineConfiguration()->GetConfigurationSection(section_name)
 
#define ENGINE_DATA_PATH(path) Blam::Settings::Paths::GetEngineDataPath(path)
 
#define USER_DATA_PATH(path) Blam::Settings::Paths::GetUserDataPath(path)
 
#ifndef BLAM
#define BLAM
#endif
 
enum class BlamEngineDataFolder
{
    DataRoot,       
    Content,        
    Gallery,        
    Maps,           
    Fonts,          
    Tags,           
    Extensions,     
    Resources,      
    DefaultConfigs, 
    Plugins,        
    Movies,         
};
 
enum class BlamUserDataFolder
{
    DataRoot,    
    Tags,        
    Maps,        
    Mods,        
    Extensions,  
    Plugins,     
    Screenshots, 
    Reports,     
    LogArchives, 
    Cache        
};
/*
class BlamEngineConfig
{
    struct paths_data
    {
        std::string game_data_root = ".";
        std::string user_mods_dir = "/mods/";
        std::string raw_data_dir = "/content/";
        std::string raw_data_images_dir = "/content/Gallery/";
        std::string screenshots_dir = "/screenshots/";
        std::string levels_dir = "/maps/";
        std::string fonts_dir = "/maps/fonts/";
        std::string tags_dir = "/tags/";
        std::string plugins_dir = "/plugins/";
        std::string builtin_plugins_dir = "./plugins/";
        std::string engine_resource_dir = "/data/";
    };
 
    paths_data paths = paths_data();
 
    struct resources_data
    {
        bool force_regenerate_game_engine_text = true;
        bool force_regenerate_globals = true;
    };
 
    resources_data resources = resources_data();
 
    struct logging_data
    {
        bool clear_log_first = true;
        bool enable_multi_log = true;
        bool enable_timestamped_log = true;
        std::string log_format = "html";
        std::string multi_log_dir = "/logs/";
        std::string timestamped_log_dir = "/logs/";
        std::string reports_dir = "/reports/";
        bool use_reports = true;
        bool stylized_html_logs = true;
        std::string console_color_set = "new";
        bool show_header_in_stylized_reports = true;
        bool include_extras_in_stylized_reports = false;
        bool bypass_queue = true;
        int max_errors_before_supression = 5;
    };
 
    logging_data logging = logging_data();
 
    struct imgui_data
    {
        std::string sys_font = "font_package_dbg";
        bool sys_font_force_extension = true;
        float sys_font_size = 15.0f;
        bool allow_imgui_mouse_change = false;
    };
 
    imgui_data imgui = imgui_data();
 
    struct debug_data
    {
        bool screenshot_debug = false;
        bool debugMode = true;
        bool config_colors_debug = true;
        bool disable_tag_class_version_checking = false;
        bool disable_tag_field_type_version_checking = false;
    };
 
    debug_data debug = debug_data();
 
    struct debug_ui_data
    {
        std::string ui_default_font = "fixedsys";
        bool always_generate_menubar_file = true;
    };
 
    debug_ui_data debug_ui = debug_ui_data();
 
    struct rendering_data
    {
        std::string rendering_engine = "ogre";
        int debug_thread_count = 1;
    };
 
    rendering_data rendering = rendering_data();
 
    struct sentry_data
    {
        bool enable_sentry = false;
        std::string sentry_host = "http://[email protected]:9000/2";
    };
 
    sentry_data sentry = sentry_data();
 
    struct fonts_data
    {
        bool use_font_table = true;
        bool draw_shadow_separately = true;
    };
 
    fonts_data fonts = fonts_data();
 
    struct console_data
    {
        bool extraConsoleOutputPadding = true;
        bool useEnhancedBooleanCommands = false;
        bool useEnhancedGvarMessages = true;
    };
 
    console_data console = console_data();
 
    struct debug_menu_data
    {
        bool useAlternateDebugMenuUnknownGlobalDisplay = false;
        bool autoGenerateNewDebugMenuFile = true;
    };
 
    debug_menu_data debug_menu = debug_menu_data();
 
    struct features_data
    {
        bool show_firstboot = true;
        bool show_windows_menubar = false;
        bool use_custom_cursor = true;
        bool enable_imgui_gamepad_nav = false;
    };
 
    features_data features = features_data();
 
    struct network_data
    {
        bool use_netcode = true;
        bool enable_discord_rpc = true;
    };
 
    network_data network = network_data();
 
    struct threading_data
    {
        bool use_separate_render_thread = false;
    };
 
    threading_data threading = threading_data();
 
    struct appearance_data
    {
        bool use_themed_windows = true;
        bool use_themed_controls = false;
        bool use_win32_dialogs = false;
        bool use_classic_qt_dialogs = false;
        float default_scale_factor = 1.0f;
        std::string default_color_scheme = "elaztek_blue";
        std::string default_metrics = "auto";
    };
 
    appearance_data appearance = appearance_data();
 
    struct miscellaneous_data
    {
        std::string screenshot_format = "PNG";
    };
 
    miscellaneous_data miscellaneous = miscellaneous_data();
 
    struct rendering_ogre_data
    {
        std::string rendering_system = "directx11";
        int color_depth = 32;
        bool srgb_gamma_conversion = false;
        std::string resolution = "640x480";
        bool fullscreen = false;
        bool vsync = false;
        int vsync_interval = 1;
        int fsaa = 1;
        bool allow_nvperfhud = false;
        bool reverse_depth = false;
        bool msaa = false;
        int msaa_quality = 0;
    };
 
    rendering_ogre_data rendering_ogre = rendering_ogre_data();
    
    struct rendering_dx11_data
    {
        std::string backbuffer_count = "auto";
        std::string driver_type = "hardware";
        bool fast_shaders = true;
        std::string floating_point_mode = "fastest";
        std::string info_queue_exceptions_bottom_level = "none";
        std::string max_feature_level = "11.0";
        std::string min_feature_level = "9.1";
        std::string device = "default";
        std::string vendor_extensions = "auto";
    };
 
    rendering_dx11_data rendering_dx11 = rendering_dx11_data();
    
    struct rendering_opengl_data
    {
        std::string display_frequency = "none";
        std::string render_to_texture_preferred_mode = "fbo";
    };
 
    rendering_opengl_data rendering_opengl = rendering_opengl_data();
 
    struct rendering_vulkan_data
    {
        std::string display_frequency = "none";
        std::string vsync_method = "fifo";
    };
 
    rendering_vulkan_data rendering_vulkan = rendering_vulkan_data();
 
    struct special_data
    {
        int conf_ver = 1;
    };
 
    special_data special = special_data();
};*/
 
namespace Blam::Settings
{
    namespace Config
    {
        BLAM BlamResult LoadEngineConfiguration();
 
        BLAM BlamResult LoadConfiguration(std::string filename);
 
        BLAM BlamResult LoadConfiguration(std::string filename, std::string defaults_filename);
 
        BLAM BlamConfigurationFile* GetEngineConfiguration();
 
        BLAM BlamConfigurationFile* GetConfiguration(std::string filename);
 
        BLAM bool IsEngineConfigurationAvailable();
 
        BLAM bool IsConfigurationAvailable(std::string filename);
 
        BLAM std::map<std::string, BlamConfigurationFile*>* GetConfigurationFiles();
    }
 
    namespace Paths
    {
        BLAM std::string GetDefaultEngineDataPath(BlamEngineDataFolder folder);
 
        BLAM std::string GetDefaultUserDataPath(BlamUserDataFolder folder);
 
        BLAM std::string GetEngineDataPath(BlamEngineDataFolder folder);
 
        BLAM std::string GetUserDataPath(BlamUserDataFolder folder);
 
        BLAM BlamUserDataFolder GetUserDataFolderFromString(std::string folder);
 
        BLAM BlamEngineDataFolder GetEngineDataFolderFromString(std::string folder);
 
        BLAM std::string ParseFolderPlaceholders(std::string string);
    }
}