Settings.h

Go to the documentation of this file.

#ifndef SKR_FPS2_SETTINGS_H
#define SKR_FPS2_SETTINGS_H
 
#include "..\..\pch.h"
 
#include <string>
#include <unordered_map>
#include <vector>
 
namespace skr
{
namespace fps2
{
 
    class Settings
    {
        private:
            Settings(){};
 
            Settings(const Settings&) = delete;
 
            Settings operator=(const Settings&) = delete;
 
            std::string _settingsFilePath = "settings.cfg";
        public:
            static Settings& GetInstance();
 
#pragma region Integer type Settings
        public:
            enum struct SettingUInt32t
            {
                SCR_WIDTH,  
                SCR_HEIGHT, 
                RNG_MODE,   
                RNG_SEED    
            };
 
#pragma warning(disable:4251) // only using types from standard library, warning can be ignored. Source: https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4251
 
            std::unordered_map<SettingUInt32t, uint32_t> _settings_uint32t
            {
                {SettingUInt32t::SCR_WIDTH,  1280},
                {SettingUInt32t::SCR_HEIGHT, 720},
                {SettingUInt32t::RNG_MODE, 0},
                {SettingUInt32t::RNG_SEED, 0}
            };
 
        private:
            // using this manually maintained mapping tables is a dirty hack
            // using compile-time reflection would be better, but also requires a lot of work up front, currently not worth it with the limited amount of settings
 
            typedef std::unordered_map<std::string, SettingUInt32t> StringToSettingIntMap;
 
            static const std::unordered_map<std::string, SettingUInt32t> MapStringToSettingInt;
           
            typedef std::unordered_map<SettingUInt32t, std::string> SettingIntToStringMap;
 
            static const std::unordered_map<SettingUInt32t, std::string> MapSettingIntToString;
 
#pragma warning(default:4251)
#pragma endregion
 
#pragma region Float type Settings
        public:
            enum struct SettingFloat
            {
                RND_NEAR,   
                RND_FAR     
            };
 
#pragma warning(disable:4251) // only using types from standard library, warning can be ignored. Source: https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4251
 
            std::unordered_map<SettingFloat, float> _settings_float
            {
                {SettingFloat::RND_NEAR, 0.1f},
                {SettingFloat::RND_FAR,  300.0f}
            };
 
        private:
            // using this manually maintained mapping tables is a dirty hack
            // using compile-time reflection would be better, but also requires a lot of work up front, currently not worth it with the limited amount of settings
 
            typedef std::unordered_map<SettingFloat, std::string> SettingFloatToStringMap;
 
            static const std::unordered_map<SettingFloat, std::string> MapSettingFloatToString;
 
            typedef std::unordered_map<std::string, SettingFloat> StringToSettingFloatMap;
 
            static const std::unordered_map<std::string, SettingFloat> MapStringToSettingFloat;
 
#pragma warning(default:4251)
#pragma endregion
 
#pragma region Boolean type Settings
 
        public:
            enum struct SettingBool
            {
                RND_VSYNC,              
                RNG_PRINTSEED,          
                RND_GAMMACORRECTION,    
                RND_COLORCODEDROOMS     
            };
 
#pragma warning(disable:4251) // only using types from standard library, warning can be ignored. Source: https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4251
 
            std::unordered_map<SettingBool, bool> _settings_bool
            {
                {SettingBool::RND_VSYNC, false},
                {SettingBool::RNG_PRINTSEED, true},
                {SettingBool::RND_GAMMACORRECTION, true},
                {SettingBool::RND_COLORCODEDROOMS, false},
            };
 
        private:
            // using this manually maintained mapping tables is a dirty hack
            // using compile-time reflection would be better, but also requires a lot of work up front, currently not worth it with the limited amount of settings
 
            typedef std::unordered_map<SettingBool, std::string> SettingBoolToStringMap;
 
            static const std::unordered_map<SettingBool, std::string> MapSettingBoolToString;
 
            typedef std::unordered_map<std::string, SettingBool> StringToSettinBoolMap;
 
            static const std::unordered_map<std::string, SettingBool> MapStringToSettingBool;
#pragma warning(default:4251)
 
#pragma endregion
 
#pragma region RunTime Settings
        public:
            enum struct RuntimeBoolSetting
            {
                GhostMode,          
                DrawDebugLight,     
                MoveLights,         
                DrawBoundingBox,    
                UseNormalMapping    
            };
 
            std::unordered_map<RuntimeBoolSetting, bool> _runtime_bool
            {
                {RuntimeBoolSetting::GhostMode, false},
                {RuntimeBoolSetting::DrawDebugLight, false},
                {RuntimeBoolSetting::MoveLights, false},
                {RuntimeBoolSetting::DrawBoundingBox, false},
                {RuntimeBoolSetting::UseNormalMapping, false}
            };
 
            enum struct ShadowType
            {
                Off,                    
                ShadowMapping,          
                ShadowMappingPCF,       
                ShadowMappingPCFDisk    
            };
 
            ShadowType _shadowRenderingMode = ShadowType::ShadowMappingPCF; 
 
#pragma endregion
 
        public:
            bool WriteSettingsToFile();
 
            bool WriteSettingsToFile(const std::string path);
 
            bool ReadSettingsFromFile();
 
            bool ReadSettingsFromFile(const std::string path);
 
            std::string PrintSettingsToString();
 
        private:
            bool GetSettingsFromFile(const std::string path, std::vector<std::string>& settings);
 
            bool SetSettingsFromString(std::vector<std::string> settings);
 
            std::string GetHumanReadableBool(bool v);
    };
 
}
}
 
#endif // !SKR_FPS2_SETTINGS_H