globals_editor.hpp

Go to the documentation of this file.

#pragma once
 
#include "components/ui/imgui/imgui.h"
 
#include <Strings/components/utils/string/string.h>
 
#include "components/resources/engine_text/engine_text.h"
#include "components/resources/engine_globals/globals.h"
#include "components/3rdparty/imgui/misc/imgui_stdlib.h"
 
class BlamImGuiWindow_GlobalsEditor : public BlamImGuiWindow
{
private:
    char search_buffer[128];      
    bool use_tabs = false;        
    bool show_empty_tabs = false; 
 
    void GenerateGlobalControl(BlamEngineGlobal* global)
    {
        switch (global->type)
        {
        case BlamGlobalType::Boolean:
        {
            ImGui::Checkbox(global->name.c_str(), &global->boolean_value);
            break;
        }
        case BlamGlobalType::Short:
        {
            ImGui::InputShort(global->name.c_str(), &global->short_value, 1, 10, NULL);
            break;
        }
        case BlamGlobalType::Long:
        {
            ImGui::InputLong(global->name.c_str(), &global->long_value, 1, 10, NULL);
            break;
        }
        case BlamGlobalType::String:
        {
            ImGui::InputText(global->name.c_str(), &global->value_raw);
            break;
        }
        case BlamGlobalType::Int:
        {
            ImGui::InputInt(global->name.c_str(), &global->int_value);
            break;
        }
        case BlamGlobalType::Real:
        {
            ImGui::InputFloat(global->name.c_str(), &global->float_value);
            break;
        }
        case BlamGlobalType::Color:
        {
            float color_values[4];
            {
                color_values[0] = global->color_value.GetRedAsFloat();
                color_values[1] = global->color_value.GetGreenAsFloat();
                color_values[2] = global->color_value.GetBlueAsFloat();
                color_values[3] = global->color_value.GetAlphaAsFloat();
            }
 
            ImGui::ColorEdit4(global->name.c_str(), color_values);
 
            global->color_value.r = color_values[0] * 255;
            global->color_value.g = color_values[1] * 255;
            global->color_value.b = color_values[2] * 255;
            global->color_value.a = color_values[3] * 255;
            break;
        }
        default:
        {
            ImGui::TextColored(ImVec4(1, 0, 0, 1), std::string("this global is not supported for editing: '" + global->name + "'").c_str());
            break;
        }
        }
 
        if (global->info.size() > 0)
        {
            ImGui::SameLine();
            Blam::UI::ImGUI::Widgets::ShowHelpMarker(global->info.c_str());
        }
    }
 
    void GenerateGlobalGroupedControls(std::string string_id_type, std::vector<BlamEngineGlobal*> list)
    {
        if (list.size() > 0 || show_empty_tabs)
        {
            std::string tab_title_id = "globals_editor_group_" + string_id_type + "_title";
            std::string tab_desc_id = "globals_editor_group_" + string_id_type + "_desc";
            std::string empty_message_id = "globals_editor_group_" + string_id_type + "_empty";
 
            if (ImGui::BeginTabItem(ENGINE_TEXT(tab_title_id).c_str()))
            {
                ImGui::Text(ENGINE_TEXT(tab_desc_id).c_str());
 
                ImGui::Separator();
 
                if (list.size() == 0)
                {
                    ImGui::TextDisabled(ENGINE_TEXT(empty_message_id).c_str());
                }
 
                for (int i = 0; i < list.size(); i++)
                {
                    GenerateGlobalControl(list.at(i));
                }
 
                ImGui::EndTabItem();
            }
        }
    }
 
public:
    void Draw()
    {
        if (show)
        {
            if (ImGui::Begin("Engine Globals", &show))
            {
                ImGui::InputTextWithHint("", "filter globals by name...", search_buffer, 128);
 
                ImGui::Checkbox("group into tabs", &use_tabs);
 
                if (use_tabs)
                {
                    ImGui::SameLine();
                    ImGui::Checkbox("show empty tabs", &show_empty_tabs);
                }
 
                std::map<std::string, BlamEngineGlobal>* globals = Blam::Globals::GetGlobalsList();
                std::map<std::string, BlamEngineGlobal>::iterator it;
 
                std::string search_filter = std::string(search_buffer);
 
                if (search_filter.length() == 0)
                {
                    if (use_tabs)
                    {
                        std::vector<BlamEngineGlobal*> boolean_globals = std::vector<BlamEngineGlobal*>();
                        std::vector<BlamEngineGlobal*> float_globals = std::vector<BlamEngineGlobal*>();
                        std::vector<BlamEngineGlobal*> short_globals = std::vector<BlamEngineGlobal*>();
                        std::vector<BlamEngineGlobal*> int_globals = std::vector<BlamEngineGlobal*>();
                        std::vector<BlamEngineGlobal*> long_globals = std::vector<BlamEngineGlobal*>();
                        std::vector<BlamEngineGlobal*> string_globals = std::vector<BlamEngineGlobal*>();
                        std::vector<BlamEngineGlobal*> color_globals = std::vector<BlamEngineGlobal*>();
                        std::vector<BlamEngineGlobal*> unsorted_globals = std::vector<BlamEngineGlobal*>();
 
                        for (it = globals->begin(); it != globals->end(); it++)
                        {
                            switch (it->second.type)
                            {
                            case BlamGlobalType::Boolean:
                            {
                                boolean_globals.push_back(&it->second);
                                break;
                            }
                            case BlamGlobalType::Short:
                            {
                                short_globals.push_back(&it->second);
                                break;
                            }
                            case BlamGlobalType::Long:
                            {
                                long_globals.push_back(&it->second);
                                break;
                            }
                            case BlamGlobalType::String:
                            {
                                string_globals.push_back(&it->second);
                                break;
                            }
                            case BlamGlobalType::Int:
                            {
                                int_globals.push_back(&it->second);
                                break;
                            }
                            case BlamGlobalType::Real:
                            {
                                float_globals.push_back(&it->second);
                                break;
                            }
                            case BlamGlobalType::Color:
                            {
                                color_globals.push_back(&it->second);
                                break;
                            }
                            default:
                            {
                                unsorted_globals.push_back(&it->second);
                                break;
                            }
                            }
                        }
 
                        if (ImGui::BeginTabBar("globals_editor_tabs"))
                        {
                            if (boolean_globals.size() > 0 || show_empty_tabs)
                            {
                                GenerateGlobalGroupedControls("boolean", boolean_globals);
                                GenerateGlobalGroupedControls("real", float_globals);
                                GenerateGlobalGroupedControls("short", short_globals);
                                GenerateGlobalGroupedControls("int", int_globals);
                                GenerateGlobalGroupedControls("long", long_globals);
                                GenerateGlobalGroupedControls("string", string_globals);
                                GenerateGlobalGroupedControls("color", color_globals);
                                GenerateGlobalGroupedControls("unsorted", unsorted_globals);
                            }
 
                            ImGui::EndTabBar();
                        }
                    }
                    else
                    {
                        ImGui::Separator();
 
                        for (it = globals->begin(); it != globals->end(); it++)
                        {
                            GenerateGlobalControl(&it->second);
                        }
                    }
                }
                else
                {
                    std::vector<BlamEngineGlobal*> matching_globals = std::vector<BlamEngineGlobal*>();
                    int omitted_count = 0;
 
                    for (it = globals->begin(); it != globals->end(); it++)
                    {
                        if (BlamStrings::Utils::String::Contains(it->second.name, search_filter))
                        {
                            matching_globals.push_back(&it->second);
                        }
                        else
                        {
                            omitted_count++;
                        }
                    }
 
                    ImGui::Separator();
 
                    ImGui::TextDisabled(std::string("showing matching globals only, omitting " + std::to_string(omitted_count) + " globals").c_str());
 
                    for (int i = 0; i < matching_globals.size(); i++)
                    {
                        GenerateGlobalControl(matching_globals.at(i));
                    }
                }
            }
            ImGui::End();
        }
    }
};