globals.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <map>
#include <vector>
 
#include <Strings/components/utils/string/string.h>
 
#define GVARS_FILE "./globals.xml" 
 
#ifndef BLAM
#define BLAM
#endif
 
class BlamColor
{
public:
    unsigned char r = 255; 
    unsigned char g = 255; 
    unsigned char b = 255; 
    unsigned char a = 255; 
 
    BlamColor()
    {
        r = 255;
        g = 255;
        b = 255;
        a = 255;
    }
 
    BlamColor(short _r, short _g, short _b)
    {
        r = _r;
        g = _g;
        b = _b;
        a = 255;
    }
 
    BlamColor(short _r, short _g, short _b, short _a)
    {
        r = _r;
        g = _g;
        b = _b;
        a = _a;
    }
 
    std::string ToString()
    {
        return std::string(std::to_string(r) + "," + std::to_string(g) + "," + std::to_string(b) + "," + std::to_string(a));
    }
 
    float GetRedAsFloat()
    {
        return r / 255.0f;
    }
 
    float GetGreenAsFloat()
    {
        return g / 255.0f;
    }
 
    float GetBlueAsFloat()
    {
        return b / 255.0f;
    }
 
    float GetAlphaAsFloat()
    {
        return a / 255.0f;
    }
 
    int GetColorAsInt()
    {
        int color_int = 0xFFFFFFFF;
 
        char* color_int_ptr = (char*)&color_int;
 
        memcpy(color_int_ptr + 3, &r, 1);
        memcpy(color_int_ptr + 2, &g, 1);
        memcpy(color_int_ptr + 1, &b, 1);
        memcpy(color_int_ptr, &a, 1);
 
        return color_int;
    }
 
    std::string ToString(std::string format)
    {
        std::string new_string = format;
 
        new_string = BlamStrings::Utils::String::Replace(new_string, "{r}", std::to_string(r));
        new_string = BlamStrings::Utils::String::Replace(new_string, "{g}", std::to_string(g));
        new_string = BlamStrings::Utils::String::Replace(new_string, "{b}", std::to_string(b));
        new_string = BlamStrings::Utils::String::Replace(new_string, "{a}", std::to_string(a));
 
        double r_float = (double)r / 255.0f;
        double g_float = (double)g / 255.0f;
        double b_float = (double)b / 255.0f;
        double a_float = (double)a / 255.0f;
 
        new_string = BlamStrings::Utils::String::Replace(new_string, "{r>f}", std::to_string(r_float));
        new_string = BlamStrings::Utils::String::Replace(new_string, "{g>f}", std::to_string(g_float));
        new_string = BlamStrings::Utils::String::Replace(new_string, "{b>f}", std::to_string(b_float));
        new_string = BlamStrings::Utils::String::Replace(new_string, "{a>f}", std::to_string(a_float));
 
        return new_string;
    }
 
    std::string ToStringForCSS()
    {
        return ToString("rgba({r},{g},{b},{a>f})");
    }
 
    bool FromString(std::string string)
    {
        std::vector<std::string> color_values = BlamStrings::Utils::String::Split(string, ",");
 
        if (color_values.size() == 3)
        {
            r = atoi(color_values.at(0).c_str());
            g = atoi(color_values.at(1).c_str());
            b = atoi(color_values.at(2).c_str());
            a = 255;
 
            return true;
        }
        else if (color_values.size() == 4)
        {
            r = atoi(color_values.at(0).c_str());
            g = atoi(color_values.at(1).c_str());
            b = atoi(color_values.at(2).c_str());
            a = atoi(color_values.at(3).c_str());
 
            return true;
        }
        else
        {
            return false;
        }
    }
};
 
namespace Blam
{
    namespace Globals
    {
        enum GvarUpdateResult
        {
            InvalidType,       
            UnknownGlobal,     
            Ok,                
            InvalidArgs,       
            OutOfBounds,       
            GlobalIsProtected 
        };
 
        enum GvarType
        {
            Boolean,  
            Real,     
            Short,    
            Long,     
            Object,   
            String,   
            Int,      
            Float,    
            Color     
        };
 
        struct EngineGlobal
        {
            GvarType type;           
            std::string name = "";   
            std::string info = "";   
            std::string value_raw = "";  
            bool read_only = false;  
 
            // Additional value storage types, these are used in place of value_raw based on type. //
 
            bool boolean_value = false; 
            short short_value = 0;      
            long long_value = 0;        
            int int_value = 0;          
            float float_value = 0.0f;   
            BlamColor color_value = BlamColor(0, 0, 0); 
        };
 
        BLAM std::map<std::string, EngineGlobal>* GetGlobalsList();
 
        BLAM bool               LoadGlobalsFromFile();
 
        BLAM std::string        GetGvarTypeLabel(GvarType type);
 
        BLAM bool               GlobalExists(std::string id);
 
        BLAM void               RegisterGvar(EngineGlobal var);
 
        BLAM void               RegisterGvar(std::string name, std::string value_raw, GvarType type);
 
        BLAM void               RegisterGvar(std::string name, std::string value_raw, GvarType type, std::string info);
 
        BLAM EngineGlobal* GetGlobal(std::string name);
 
        BLAM GvarUpdateResult   UpdateGlobalWrap(std::string name, std::string new_value);
 
        BLAM GvarUpdateResult   UpdateGlobal(std::string name, std::string new_value);
 
        BLAM GvarUpdateResult   UpdateGlobal(std::string name, bool new_value);
 
        BLAM GvarUpdateResult   UpdateGlobal(std::string name, int new_value);
 
        BLAM GvarUpdateResult   UpdateGlobal(std::string name, short new_value);
 
        BLAM GvarUpdateResult   UpdateGlobal(std::string name, long new_value);
 
        BLAM GvarUpdateResult   UpdateGlobal(std::string name, float new_value);
 
        BLAM GvarUpdateResult   UpdateGlobal(std::string name, BlamColor new_value);
 
        BLAM bool* GetGlobalAsBoolean(std::string name);
 
        BLAM std::string* GetGlobalAsString(std::string name);
 
        BLAM short* GetGlobalAsShort(std::string name);
 
        BLAM long* GetGlobalAsLong(std::string name);
 
        BLAM int* GetGlobalAsInteger(std::string name);
 
        BLAM float* GetGlobalAsFloat(std::string name);
 
        BLAM BlamColor* GetGlobalAsColor(std::string name);
    }
}