console.hpp

Go to the documentation of this file.

#pragma once
 
#include <set>
 
#include "components/rendering/rendering.h"
#include "../../render_stack.h"
#include "components/ui/blam_old/console/console.h"
#include <Strings/components/utils/string/string.h>
#include "components/settings/config/config.h"
#include "components/diagnostics/logger/logger.h"
#include <Strings/components/utils/math/math.h>
#include "components/resources/engine_globals/globals.h"
#include "components/core/events/events.h"
#include "components/core/tick/tick.h"
#include "components/resources/animation/animations/ColorTransition.h"
 
namespace BlamRendering::RenderStack
{
    class ConsoleMessage : public Blam::Events::EventListener
    {
    public:
        BitmapText* message;
        int ticks_left = 0;
        Blam::Animation::ColorTransitionAnimation anim;
        bool* console_visible;
 
        ConsoleMessage(bool* _console_visible)
        {
            console_visible = _console_visible;
 
            Subscribe(EventType::Tick);
            Blam::Events::RegisterListener(this);
        }
 
        void onTickEvent(Blam::Events::TickEvent* event)
        {
            if (!*console_visible)
            {
                anim.Resume();
 
                if (ticks_left == 0)
                {
                    if (!anim.HasStarted())
                    {
                        anim.Start();
                    }
 
                    message->color.a = anim.GetColor().a;
                    message->shadow_color.a = anim.GetColor().a;
                }
                else
                {
                    ticks_left--;
                }
            }
            else
            {
                anim.Pause();
            }
        }
    };
 
    class ConsoleUI : public StackObjectBase, public Blam::Events::EventListener
    {
    private:
        //console placement offset from bottom left
        float x_offset_base = 9;
        float y_offset_base = 10;
 
        float x_offset = x_offset_base;
        float y_offset = y_offset_base;
 
        BitmapText* prompt;
        BitmapText* input;
 
        int prompt_stack_index = -1;
        int input_stack_index = -1;
 
        //todo: make these configurable maybe
        char active_index_char = '_';
        std::string font_id = "";
        bool extra_padding = false;
        bool ready = false;
        
        int active_index = 0; //current cursor index
        std::string current_input_display = ""; //modified version of input, used ONLY for display onscreen
        std::string current_input = ""; //current input text
 
        int temp_line_height_base = 14;
        int temp_line_height = temp_line_height_base;
 
        int max_recent_items = 30;
 
        std::vector<ConsoleMessage*> recent_output;
        std::vector<std::string> recent_input;
        int current_history_index = 0;
 
        int console_bottom_margin_base = 12;
        int input_field_offset_base = 46;
 
        int console_bottom_margin = console_bottom_margin_base;
        int input_field_offset = input_field_offset_base;
 
        float c_scale_factor = 1.0f;
 
        float message_show_duration = 4.0f;
        float message_fade_duration = 1.0f;
 
    public:
        ConsoleUI()
        {
            type_label = STACKTYPE_CONSOLE;
 
            font_id = Blam::Config::GetConfig()->GetString("ui_default_font");
            extra_padding = Blam::Config::GetConfig()->GetBoolean("extraConsoleOutputPadding");
 
            // create prompt text
            prompt = new BitmapText();
 
            prompt->font_id = font_id;
            prompt->use_shadow = true;
            prompt->color = D2D1::ColorF(1, 0.298, 1, 1);
            prompt->text = "halo(";
 
            prompt_stack_index = BlamRendering::RenderStack::AddToStack("console_prompt", prompt);
 
            // create input text
            input = new BitmapText();
 
            input->font_id = font_id;
            input->use_shadow = true;
            input->color = D2D1::ColorF(1, 0.298, 1, 1);
 
            input_stack_index = BlamRendering::RenderStack::AddToStack("console_input", input);
 
            // add cursor position
            updateInputDisplay();
 
            HandleResize();
 
            toggleVisibility();
 
            Subscribe(EventType::CharacterInput);
            Subscribe(EventType::KeyPress);
 
            Blam::Events::RegisterListener(this);
 
            ready = true;
        }
 
        ~ConsoleUI()
        {
            for (int i = 0; i < recent_output.size(); i++)
            {
                delete recent_output[i]->message;
                delete recent_output[i];
            }
 
            BlamRendering::RenderStack::RemoveFromStack("console_prompt");
            BlamRendering::RenderStack::RemoveFromStack("console_input");
            delete prompt;
            delete input;
        }
 
        void Draw()
        {
            float scale_factor = *Blam::Globals::GetGlobalAsFloat("ui_scale_factor");
 
            if (scale_factor != c_scale_factor)
            {
                c_scale_factor = scale_factor;
 
                console_bottom_margin = console_bottom_margin_base * (int)round(scale_factor);
                input_field_offset = input_field_offset_base * (int)round(scale_factor);
 
                x_offset = x_offset_base * (int)round(scale_factor);
                y_offset = y_offset_base * (int)round(scale_factor);
 
                temp_line_height = temp_line_height_base * (int)round(scale_factor);
 
                HandleResize();
            }
 
            for (int i = 0; i < recent_output.size(); i++)
            {
                BitmapText* item = recent_output[i]->message;
 
                item->Draw();
            }
 
            for (int i = recent_output.size() - 1; i >= 0; i--)
            {
                BitmapText* item = recent_output[i]->message;
 
                if (item->color.a == 0)
                {
                    delete recent_output[i]->message;
                    delete recent_output[i];
 
                    recent_output.erase(recent_output.begin() + i);
                }
            }
        }
 
        void onCharacterInputEvent(Blam::Events::CharacterInputEvent* event)
        {
            if (event->GetCharacter() == '`')
            {
                toggleVisibility();
            }
            else
            {
                if (visible)
                {
                    std::string c(1, event->GetCharacter());
 
                    current_input.insert(active_index, c);
                    active_index++;
 
                    updateInputDisplay();
                }
            }
        }
 
        void onKeyPressEvent(Blam::Events::KeyPressEvent* event)
        {
            switch (event->GetVirtualKey())
            {
                case SDLK_BACKSPACE:
                {
                    handleBackspace();
                    event->setCancelled(true);
                    break;
                }
                case SDLK_LEFT:
                {
                    handleCursorLeft();
                    event->setCancelled(true);
                    break;
                }
                case SDLK_RIGHT:
                {
                    handleCursorRight();
                    event->setCancelled(true);
                    break;
                }
                case SDLK_RETURN:
                {
                    sendCommand();
                    event->setCancelled(true);
                    break;
                }
                case SDLK_UP:
                {
                    handleCursorUp();
                    event->setCancelled(true);
                    break;
                }
                case SDLK_DOWN:
                {
                    handleCursorDown();
                    event->setCancelled(true);
                    break;
                }
                case SDLK_TAB:
                {
                    showCommandList();
                    event->setCancelled(true);
                    break;
                }
                default:
                {
                    break;
                }
            }
        }
 
        void ShowImPropertyEditor()
        {
 
        }
 
        // Updates the input display format
        void updateInputDisplay()
        {
            current_input_display = current_input;
 
            if (active_index == current_input.length())
            {
                current_input_display += active_index_char;
            }
            else
            {
                current_input_display[active_index] = active_index_char;
            }
 
            input->text = current_input_display;
        }
 
        // Handles console placement on window resize
        void HandleResize()
        {
            // the - 12 is extra offset to ensure alignment from bottom of screen, adjust actual offset with x_offset and y_offset
            if (prompt)
            {
                prompt->SetTranslation(x_offset, (BlamRendering::DirectX::GetSwapChainDesc().BufferDesc.Height - console_bottom_margin) - y_offset);
            }
 
            if (input)
            {
                input->SetTranslation(x_offset + input_field_offset, (BlamRendering::DirectX::GetSwapChainDesc().BufferDesc.Height - console_bottom_margin) - y_offset);
            }
 
 
            int line_multiplier = recent_output.size();
            for (int i = 0; i < recent_output.size(); i++)
            {
                BitmapText* item = recent_output[i]->message;
 
                int y_placement = (BlamRendering::DirectX::GetSwapChainDesc().BufferDesc.Height - console_bottom_margin) - y_offset;
 
                if (extra_padding)
                {
                    y_placement -= temp_line_height;
                }
                
                y_placement -= (temp_line_height * line_multiplier);
 
                item->SetTranslation(x_offset, y_placement);
 
                item->force_regenerate = true;
 
                line_multiplier--;
            }
        }
 
        int error_count = 0;
        bool supression_message_shown = false;
 
        // Called by Blam::Logger::LogEvent()
        void handleNewOutput(Blam::Logger::LogMessage message)
        {
            if (ready)
            {
                if (message.severity == WSV_ERROR || message.severity == WSV_WARNING)
                {
                    error_count++;
                }
                else
                {
                    error_count = 0;
                    supression_message_shown = false;
                }
 
                if (error_count >= 5)
                {
                    message.severity = WSV_NONE;
                    message.message = "too many errors, only printing to debug.txt";
                    //message = Blam::Logger::Internal::ApplyColorsFromConfig(message);
                }
 
                if (!supression_message_shown || error_count < 5)
                {
                    BitmapText* log_msg = new BitmapText();
 
                    log_msg->font_id = font_id;
                    log_msg->use_shadow = true;
 
                    float new_r = (float)message.color.r / 255;
                    float new_g = (float)message.color.g / 255;
                    float new_b = (float)message.color.b / 255;
 
                    log_msg->color = D2D1::ColorF(new_r, new_g, new_b, 1);
                    log_msg->text = message.message;
 
                    if (extra_padding)
                    {
                        log_msg->SetTranslation(x_offset, (BlamRendering::DirectX::GetSwapChainDesc().BufferDesc.Height - console_bottom_margin_base) - y_offset - temp_line_height);
                    }
                    else
                    {
                        log_msg->SetTranslation(x_offset, (BlamRendering::DirectX::GetSwapChainDesc().BufferDesc.Height - console_bottom_margin_base) - y_offset);
                    }
 
                    ConsoleMessage* c_msg = new ConsoleMessage(&visible);
                    c_msg->message = log_msg;
                    c_msg->ticks_left = Blam::Tick::MaxTicksPerSecond() * 5.0f;
                    c_msg->anim.Initialize(D2D1::ColorF(1.0f, 1.0f, 1.0f, 0.0f), log_msg->color, message_fade_duration, false);
 
                    recent_output.push_back(c_msg);
 
                    // resize/reorder/remove
                    if (recent_output.size() >= max_recent_items)
                    {
                        recent_output.erase(recent_output.begin() + 0);
                    }
 
                    for (int i = 0; i < recent_output.size(); i++)
                    {
                        BitmapText* item = recent_output[i]->message;
 
                        item->SetTranslation(item->x, item->y - temp_line_height);
 
                        //item->force_regenerate = true;
                    }
                }
 
                if (error_count >= 5)
                {
                    supression_message_shown = true;
                }
            }
        }
 
        std::vector<std::string> getRecentInput()
        {
            return recent_input;
        }
 
        void clearScrollback()
        {
            for (int i = 0; i < recent_output.size(); i++)
            {
                while (recent_output[i]->message->currently_locked)
                {
                    // wait
                }
 
                delete recent_output[i]->message;
            }
 
            recent_output.clear();
        }
 
        /******************************************************************** 
           The below functions are called from main.cpp's Window Procedure
        ********************************************************************/
 
        // Called when a key is pressed
        void handleKeyPress(char character)
        {
            /*if (visible)
            {
                std::string c(1, character);
 
                current_input.insert(active_index, c);
                active_index++;
 
                updateInputDisplay();
            }*/
        }
 
        // Called when the backspace key is pressed
        void handleBackspace()
        {
            if (visible)
            {
                if (current_input.length() > 0)
                {
                    current_input.erase(active_index - 1, 1);
 
                    active_index--;
 
                    updateInputDisplay();
                }
            }
        }
 
        // Called when the left arrow key is pressed
        void handleCursorLeft()
        {
            if (visible)
            {
                if (active_index > 0)
                {
                    active_index--;
                }
 
                updateInputDisplay();
            }
        }
 
        // Called when the right arrow key is pressed
        void handleCursorRight()
        {
            if (visible)
            {
                if (active_index < current_input.length())
                {
                    active_index++;
                }
 
                updateInputDisplay();
            }
        }
 
        void handleCursorUp()
        {
            if (current_history_index > 0)
            {
                current_history_index--;
 
                current_input = recent_input[current_history_index];
 
                active_index = current_input.size();
 
                updateInputDisplay();
            }
        }
 
        void handleCursorDown()
        {
            current_history_index++;
 
            if (current_history_index < recent_input.size())
            {
                current_input = recent_input[current_history_index];
 
                active_index = current_input.size();
            }
            else
            {
                current_history_index = recent_input.size();
                current_input.clear();
                active_index = 0;
            }
 
            updateInputDisplay();
        }
 
        // Called when ~ (or technically `) is pressed
        void toggleVisibility()
        {
            visible = !visible;
 
            prompt->visible = visible;
            input->visible = visible;
        }
 
        // Called when enter is pressed
        void sendCommand()
        {
            if (current_input.length() > 0)
            {
                Blam::Logger::LogEventForce("> " + current_input, WSV_INFO, WVIS_FILE_ONLY);
 
                Blam::Console::RunCommandLine(current_input);
 
                recent_input.push_back(current_input);
                current_history_index = recent_input.size();
 
                current_input.clear();
 
                active_index = 0;
 
                updateInputDisplay();
            }
        }
 
        // Called when tab is pressed
        void showCommandList()
        {
            using namespace Blam::Logger;
 
            std::set<std::string> command_list;
 
            std::map<std::string, Blam::Console::ConsoleCommand*> map = Blam::Console::GetCommandList();
            std::map<std::string, Blam::Console::ConsoleCommand*>::iterator it;
 
            // Get any matching commands
            for (it = map.begin(); it != map.end(); it++)
            {
                std::string command_name = it->second->name;
 
                if (BlamStrings::Utils::String::StartsWith(command_name, current_input, true))
                {
                    command_list.insert(command_name);
                }
            }
 
            if (command_list.size() > 0)
            {
                // blank line
                LogEventForce("", WSV_NONE);
            }
 
            std::set<std::string>::iterator list_it;
 
            for (list_it = command_list.begin(); list_it != command_list.end(); list_it++)
            {
                std::string cmd_name = *list_it;
 
                Blam::Logger::LogEventForce(cmd_name, WSV_NONE);
            }
        }
    };
}