debug_menu.hpp

Go to the documentation of this file.

#pragma once
 
#include "../debug_ui.h"
 
#include "components/resources/debug_menu/debug_menu.h"
#include "components/resources/console/console.h"
 
namespace Blam::DebugUI::Windows
{
    class DebugMenu : public Blam::DebugUI::ImGUIDrawingGroup
    {
    private:
        BlamDebugMenu* menu = nullptr;
    public:
        DebugMenu() 
        {
            menu = Blam::Resources::DebugMenu::GetDebugMenu();
        }
 
        void GenerateItemControl(BlamDebugMenuItem* item)
        {
            switch (item->item_type)
            {
                case MENU_ITEM_TYPE_CATEGORY:
                {
                    if (ImGui::TreeNode(item->title.c_str()))
                    {
                        for (int i = 0; i < item->items.size(); i++)
                        {
                            GenerateItemControl(&item->items.at(i));
                        }
 
                        ImGui::TreePop();
                    }
 
                    return;
                }
                case MENU_ITEM_TYPE_EXEC:
                {
                    if (ImGui::Button(item->title.c_str(), ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeightWithSpacing())))
                    {
                        item->HandleKeyEnter();
                    }
 
                    return;
                }
                case MENU_ITEM_TYPE_GLOBAL:
                {
                    using namespace Blam::Globals;
 
                    EngineGlobal* global = GetGlobal(item->global_id);
 
                    if (global)
                    {
                        switch (global->type)
                        {
                            case GvarType::Boolean:
                            {
                                ImGui::Checkbox(item->title.c_str(), &global->boolean_value);
                                return;
                            }
                            case GvarType::Int:
                            {
                                if (item->use_bounds)
                                {
                                    ImGui::SliderInt(item->title.c_str(), &global->int_value, item->min, item->max);
                                }
                                else
                                {
                                    ImGui::InputInt(item->title.c_str(), &global->int_value, 1, item->inc);
                                }
                                
                                return;
                            }
                            case GvarType::Long:
                            {
                                if (item->use_bounds)
                                {
                                    ImGui::SliderInt(item->title.c_str(), (int*)&global->long_value, item->min, item->max);
                                }
                                else
                                {
                                    ImGui::InputInt(item->title.c_str(), (int*)&global->long_value, 1, item->inc);
                                }
 
                                return;
                            }
                            case GvarType::Short:
                            {
                                if (item->use_bounds)
                                {
                                    ImGui::SliderInt(item->title.c_str(), (int*)&global->short_value, item->min, item->max);
                                }
                                else
                                {
                                    ImGui::InputInt(item->title.c_str(), (int*)&global->short_value, 1, item->inc);
                                }
 
                                return;
                            }
                            case GvarType::Float:
                            {
                                if (item->use_bounds)
                                {
                                    ImGui::SliderFloat(item->title.c_str(), &global->float_value, item->min, item->max);
                                }
                                else
                                {
                                    ImGui::InputFloat(item->title.c_str(), &global->float_value, 1, item->inc);
                                }
 
                                return;
                            }
                            default:
                            {
                                std::string text = "UNSUPPORTED: " + item->title + " (" + global->name + ")";
                                ImGui::TextColored(ImVec4(1, 0, 0, 1), text.c_str());
 
                                return;
                            }
                        }
                    }
                    else
                    {
                        std::string text = "UNDEFINED: " + item->title + " (" + item->global_id + ")";
                        ImGui::TextColored(ImVec4(1, 0, 0, 1), text.c_str());
                    }
 
                    return;
                }
                case MENU_ITEM_TYPE_MULTIEXEC:
                {
                    if (ImGui::Button(item->title.c_str(), ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeightWithSpacing())))
                    {
                        item->HandleKeyEnter();
                    }
 
                    return;
                }
                case MENU_ITEM_TYPE_UNKNOWN:
                {
                    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1, 0, 0, 1));
 
                    if (ImGui::Button(item->title.c_str(), ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeightWithSpacing())))
                    {
                        item->HandleKeyEnter();
                    }
 
                    ImGui::PopStyleColor();
 
                    return;
                }
                default:
                {
                    return;
                }
            }
        }
 
        void Draw()
        {
            if (show)
            {
                if (menu)
                {
                    if (ImGui::Begin(menu->title.c_str(), &show))
                    {
                        ImGui::TextColored(ImVec4(1, 0, 0, 1), "this debug menu is not supported, please use PgUp and use the primary debug menu");
                        ImGui::TextColored(ImVec4(1, 0, 0, 1), "only use this if you seriously can't stand that one");
 
                        for (int i = 0; i < menu->items.size(); i++)
                        {
                            if (menu->items.at(i).item_type == MENU_ITEM_TYPE_CATEGORY)
                            {
                                if (ImGui::CollapsingHeader(menu->items.at(i).title.c_str()))
                                {
                                    for (int x = 0; x < menu->items.at(i).items.size(); x++)
                                    {
                                        GenerateItemControl(&menu->items.at(i).items.at(x));
                                    }
                                }
                            }
                            else
                            {
                                GenerateItemControl(&menu->items.at(i));
                            }
                        }
                    }
                }
                else
                {
                    if (ImGui::Begin("Main", &show))
                    {
                        ImGui::TextColored(ImVec4(1, 0, 0, 1), "debug menu does not appear to be loaded (menu was nullptr)");
                    }
                }
                
                ImGui::End();
            }
        }
    };
}