debug_menu.hpp

Go to the documentation of this file.

#pragma once
 
#include "components/ui/imgui/imgui.h"
 
#include "components/resources/debug_menu/debug_menu.h"
#include "components/resources/console/console.h"
 
class BlamImGuiWindow_DebugMenu : public BlamImGuiWindow
{
private:
    BlamDebugMenu* menu = nullptr;
public:
    BlamImGuiWindow_DebugMenu()
    {
        menu = Blam::Resources::DebugMenu::GetDebugMenu();
    }
 
    void GenerateItemControl(BlamDebugMenuItem* item)
    {
        switch (item->GetType())
        {
        case BlamDebugMenuItemType::Submenu:
        {
            BlamDebugMenuItem_Submenu* submenu_item = (BlamDebugMenuItem_Submenu*)item;
 
            if (ImGui::TreeNode(item->title.c_str()))
            {
                for (int i = 0; i < submenu_item->items.size(); i++)
                {
                    GenerateItemControl(submenu_item->items.at(i));
                }
 
                ImGui::TreePop();
            }
 
            return;
        }
        case BlamDebugMenuItemType::Command:
        {
            if (ImGui::Button(item->title.c_str(), ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeightWithSpacing())))
            {
                item->Activate();
            }
 
            return;
        }
        case BlamDebugMenuItemType::Global:
        {
            BlamDebugMenuItem_Global* global_item = (BlamDebugMenuItem_Global*)item;
            BlamEngineGlobal* global = Blam::Globals::GetGlobal(global_item->global_id);
 
            if (global)
            {
                switch (global->type)
                {
                case BlamGlobalType::Boolean:
                {
                    ImGui::Checkbox(item->title.c_str(), &global->boolean_value);
                    return;
                }
                case BlamGlobalType::Int:
                {
                    if (global_item->use_bounds)
                    {
                        ImGui::SliderInt(item->title.c_str(), &global->int_value, global_item->min, global_item->max);
                    }
                    else
                    {
                        ImGui::InputInt(item->title.c_str(), &global->int_value, 1, global_item->inc);
                    }
 
                    return;
                }
                case BlamGlobalType::Long:
                {
                    if (global_item->use_bounds)
                    {
                        ImGui::SliderInt(item->title.c_str(), (int*)&global->long_value, global_item->min, global_item->max);
                    }
                    else
                    {
                        ImGui::InputInt(item->title.c_str(), (int*)&global->long_value, 1, global_item->inc);
                    }
 
                    return;
                }
                case BlamGlobalType::Short:
                {
                    if (global_item->use_bounds)
                    {
                        ImGui::SliderInt(item->title.c_str(), (int*)&global->short_value, global_item->min, global_item->max);
                    }
                    else
                    {
                        ImGui::InputInt(item->title.c_str(), (int*)&global->short_value, 1, global_item->inc);
                    }
 
                    return;
                }
                case BlamGlobalType::Real:
                {
                    if (global_item->use_bounds)
                    {
                        ImGui::SliderFloat(item->title.c_str(), &global->float_value, global_item->min, global_item->max);
                    }
                    else
                    {
                        ImGui::InputFloat(item->title.c_str(), &global->float_value, 1, global_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 + " (" + global_item->global_id + ")";
                ImGui::TextColored(ImVec4(1, 0, 0, 1), text.c_str());
            }
 
            return;
        }
        case BlamDebugMenuItemType::CommandSequence:
        {
            if (ImGui::Button(item->title.c_str(), ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeightWithSpacing())))
            {
                item->Activate();
            }
 
            return;
        }
        case BlamDebugMenuItemType::Unknown:
        {
            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1, 0, 0, 1));
 
            if (ImGui::Button(item->title.c_str(), ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeightWithSpacing())))
            {
                item->Activate();
            }
 
            ImGui::PopStyleColor();
 
            return;
        }
        default:
        {
            return;
        }
        }
    }
 
    void Draw()
    {
        if (!show)
        {
            return;
        }
 
        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)->GetType() == BlamDebugMenuItemType::Submenu)
                    {
                        BlamDebugMenuItem_Submenu* submenu_item = (BlamDebugMenuItem_Submenu*)menu->items.at(i);
 
                        if (ImGui::CollapsingHeader(submenu_item->title.c_str()))
                        {
                            for (int x = 0; x < submenu_item->items.size(); x++)
                            {
                                GenerateItemControl(submenu_item->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();
    }
};