menu_item.hpp

Go to the documentation of this file.

#pragma once
 
#include "components/resources/debug_menu/debug_menu.h"
#include "../../../render_stack.h"
#include "components/resources/engine_globals/globals.h"
#include "components/settings/config/config.h"
#include "components/core/tick/tick.h"
#include "components/core/events/events.h"
#include "components/resources/animation/animations/ColorTransition.h"
 
namespace BlamRendering::RenderStack
{
    class DebugMenuItem : public StackObjectBase, public BlamEventListener
    {
        Rectangle* background;  
        BitmapText* index;      
        BitmapText* label;      
 
        int bar_width = 0;   
        int bar_height = 0;  
 
        D2D1_COLOR_F inactive_color = D2D1::ColorF(204.0f / 255.0f, 204.0f / 255.0f, 191.0f / 255.0f);  
        D2D1_COLOR_F active_color = D2D1::ColorF(0, 0, 0);  
        D2D1_COLOR_F active_color_2 = D2D1::ColorF(91 / 255.0f, 91 / 255.0f, 85 / 255.0f);  
 
        D2D1_COLOR_F category_text_color = D2D1::ColorF(12 / 255.0f, 165 / 255.0f, 12 / 255.0f);  
        D2D1_COLOR_F prop_text_color = D2D1::ColorF(76 / 255.0f, 107 / 255.0f, 84 / 255.0f);  
        D2D1_COLOR_F exec_text_color = D2D1::ColorF(255 / 255.0f, 127 / 255.0f, 0 / 255.0f);  
        D2D1_COLOR_F unknown_text_color = D2D1::ColorF(1, 0, 0);  
        
        Rectangle* global_bg;  
        BitmapText* global_value_label;  
        int global_view_width_base = 60;  
        int global_view_space_between_base = 5;  
 
        // Scaled properties
        int global_view_width = global_view_width_base;  
        int global_view_space_between = global_view_space_between_base;  
 
        Blam::Animation::ColorTransitionAnimation animation;
 
    public:
        bool active = false;     
        int menu_index_num = 0;  
 
        bool lock = false;      
        bool deleting = false;  
 
        BlamDebugMenuItem menu_item;  
 
        bool useAlternateDebugMenuUnknownGlobalDisplay = false;
 
        DebugMenuItem()
        {
            type_label = StackType::Generic;
 
            // Load some configuration settings
            {
                useAlternateDebugMenuUnknownGlobalDisplay = Blam::Config::GetConfig()->GetBoolean("useAlternateDebugMenuUnknownGlobalDisplay");
            }
 
            // background layer
            {
                background = new Rectangle();
 
                background->fill_color = inactive_color;
                background->draw_mode = DRAWMODE_FILL;
            }
 
            // number label
            {
                index = new BitmapText();
                index->color = unknown_text_color;
                index->font_id = Blam::Config::GetConfig()->GetString("ui_default_font");
                index->use_shadow = true;
                index->shadow_x = 1;
                index->shadow_y = 1;
                index->shadow_color = D2D1::ColorF(0, 0, 0);
            }
 
            // label
            {
                label = new BitmapText();
                label->color = unknown_text_color;
                label->font_id = Blam::Config::GetConfig()->GetString("ui_default_font");
                label->use_shadow = true;
                label->shadow_x = 1;
                label->shadow_y = 1;
                label->shadow_color = D2D1::ColorF(0, 0, 0);
            }
 
            // global value bg
            {
                global_bg = new Rectangle();
 
                global_bg->fill_color = inactive_color;
                global_bg->draw_mode = DRAWMODE_FILL;
            }
 
            // global value label
            {
                global_value_label = new BitmapText();
                global_value_label->color = prop_text_color;
                global_value_label->font_id = Blam::Config::GetConfig()->GetString("ui_default_font");
                global_value_label->use_shadow = true;
                global_value_label->shadow_x = 1;
                global_value_label->shadow_y = 1;
                global_value_label->shadow_color = D2D1::ColorF(0, 0, 0);
                global_value_label->text = "<global>";
            }
 
 
            Subscribe(EventType_Tick);
            Blam::Events::RegisterListener(this);
 
            animation.Initialize(active_color, active_color_2, 1.3f, true);
            animation.Start();
        }
 
        ~DebugMenuItem()
        {
            deleting = true;
 
            while (lock)
            {
                // wait
            }
 
            delete background;
            delete index;
            delete label;
            delete global_bg;
            delete global_value_label;
 
            //delete this;
        }
 
        void OnTickEvent(TickEvent* event)
        {
            if (active)
            {
                background->fill_color = animation.GetColor();
            }
            else
            {
                background->fill_color = inactive_color;
            }
        }
 
        void UpdateItemTextColor()
        {
            if (menu_item.item_type == MENU_ITEM_TYPE_EXEC)
            {
                label->color = exec_text_color;
                index->color = exec_text_color;
            }
            else if (menu_item.item_type == MENU_ITEM_TYPE_CATEGORY)
            {
                label->color = category_text_color;
                index->color = category_text_color;
            }
            else if (menu_item.item_type == MENU_ITEM_TYPE_GLOBAL)
            {
                if (Blam::Globals::GlobalExists(menu_item.global_id))
                {
                    label->color = prop_text_color;
                    index->color = prop_text_color;
                }
                else
                {
                    if (useAlternateDebugMenuUnknownGlobalDisplay)
                    {
                        label->color = unknown_text_color;
                        index->color = unknown_text_color;
                    }
                    else
                    {
                        label->color = prop_text_color;
                        index->color = prop_text_color;
                    }
                }
            }
            else if (menu_item.item_type == MENU_ITEM_TYPE_MULTIEXEC)
            {
                label->color = exec_text_color;
                index->color = exec_text_color;
            }
            else
            {
                label->color = unknown_text_color;
                index->color = unknown_text_color;
            }
        }
 
        void SetDefaultBarDimensions(int _width, int _height)
        {
            bar_width = _width;
            bar_height = _height;
        }
 
        void UpdateMetadata()
        {
            float ui_scale_factor = *Blam::Globals::GetGlobalAsFloat("ui_scale_factor");
 
            global_view_space_between = global_view_space_between_base * ui_scale_factor;
            global_view_width = global_view_width_base * ui_scale_factor;
 
            background->SetSize(bar_width, bar_height);
            background->SetTranslation(x, y);
 
            if (menu_item.item_type == MENU_ITEM_TYPE_GLOBAL)
            {
                if (!Blam::Globals::GlobalExists(menu_item.global_id))
                {
                    if (!useAlternateDebugMenuUnknownGlobalDisplay)
                    {
                        global_bg->visible = false;
                        global_value_label->visible = false;
 
                        index->text = "UNDEFINED: " + menu_item.global_id;
                        label->text = "";
                    }
                    else
                    {
                        label->text = menu_item.title;
                        index->text = std::to_string(menu_index_num);
                    }
                }
                else
                {
                    label->text = menu_item.title;
                    index->text = std::to_string(menu_index_num);
                }
            }
            else
            {
                label->text = menu_item.title;
                index->text = std::to_string(menu_index_num);
            }
 
            index->SetTranslation(x + (8 * ui_scale_factor), y - (2 * ui_scale_factor));
 
            label->SetTranslation(x + (26 * ui_scale_factor), y - (2 * ui_scale_factor));
 
            global_bg->SetSize(global_view_width, bar_height);
            global_bg->SetTranslation(x - (global_view_space_between + global_view_width), y);
 
            global_value_label->SetTranslation(global_bg->x + (3 * ui_scale_factor), y - (2 * ui_scale_factor));
 
            UpdateItemTextColor();
        }
 
        void Draw()
        {
            if (!deleting)
            {
                lock = true;
 
                background->Draw();
                index->Draw();
                label->Draw();
 
                if (menu_item.item_type == MENU_ITEM_TYPE_GLOBAL)
                {
                    Blam::Globals::EngineGlobal* global = Blam::Globals::GetGlobal(menu_item.global_id);
 
                    if (global)
                    {
                        if (global->type == Blam::Globals::GvarType::Boolean)
                        {
                            if (global->boolean_value == true)
                            {
                                global_value_label->text = "True";
                            }
                            else
                            {
                                global_value_label->text = "False";
                            }
                        }
                        else if (global->type == Blam::Globals::GvarType::String)
                        {
                            global_value_label->text = "<str>";
                        }
                        else
                        {
                            global_value_label->text = global->value_raw;
                        }
                    }
 
                    global_bg->Draw();
                    global_value_label->Draw();
                }
            }
 
            lock = false;
        }
 
        void ShowImPropertyEditor()
        {
 
        }
 
        void toggleVisibility()
        {
            visible = !visible;
        }
 
        void SetActive(bool _active)
        {
            active = _active;
 
            /*if (active)
            {
                background->fill_color = active_color;
                global_bg->fill_color = active_color;
            }
            else
            {
                background->fill_color = inactive_color;
                global_bg->fill_color = inactive_color;
            }*/
        }
 
        void HandleKeyLeft()
        {
            menu_item.HandleKeyLeft();
        }
 
        void HandleKeyRight()
        {
            menu_item.HandleKeyRight();
        }
 
        void ItemTriggered()
        {
            menu_item.HandleKeyEnter();
        }
    };
}