render_stack_editor.hpp

Go to the documentation of this file.

#pragma once
 
#include "../../debug_ui.h"
 
#include "components/rendering/directx11/render_stack/stack_types/blam_ui/debug_menu.hpp"
 
using namespace BlamRendering::RenderStack;
 
namespace Blam::DebugUI::Windows
{
    class RenderStackEditor : public Blam::DebugUI::ImGUIDrawingGroup
    {
    private:
        int active_index = -1;                 
        StackObjectBase* active_object = NULL; 
 
        bool use_raw_values = false;           
        bool compact_area_input = false;       
        bool rect_limit_to_window = true;      
        float shift_limits[2] = { -5, 5 };     
        float translate_speed = 1;             
 
        bool show_unreciognized_popup = false; 
        bool show_invalid_popup = false;       
        bool show_outofbounds_popup = false;   
        bool show_delete_imgui_popup = false;  
 
        StackType add_item_current_selection = StackType::Generic; 
 
    public:
        void Draw()
        {
            // Functions used to draw the various dialogs if their respective visibiliy booleans are enabled.
            UnreciognizedTypePopup();
            InvalidTypePopup();
            IndexOutOfBoundsPopup();
            DeleteImGuiObjectPopup();
 
            if (show)
            {
                if (ImGui::Begin("Render Stack Editor", &show))
                {
                    if (ImGui::BeginCombo("", GetStackTypeLabel(add_item_current_selection).c_str()))
                    {
                        for (int i = 0; i < GetStackTypesList().size(); i++)
                        {
                            StackType type = GetStackTypesList().at(i);
 
                            if (ImGui::Selectable(GetStackTypeLabel(type).c_str()))
                            {
                                add_item_current_selection = type;
                            }
                        }
 
                        ImGui::EndCombo();
                    }
 
                    ImGui::SameLine();
 
                    if (ImGui::Button("Add"))
                    {
                        std::string new_object_id = "item_" + GetStack()->size();
 
                        if (add_item_current_selection == STACKTYPE_IMGUI)
                        {
                            show_invalid_popup = true;
                        }
                        else if (add_item_current_selection == STACKTYPE_GENERIC)
                        {
                            show_invalid_popup = true;
                        }
                        else if (add_item_current_selection == STACKTYPE_RECT)
                        {
                            BlamRendering::RenderStack::Rectangle* new_rect = new BlamRendering::RenderStack::Rectangle();
 
                            AddToStack(new_object_id, new_rect);
                        }
                        else if (add_item_current_selection == STACKTYPE_DWTEXT)
                        {
                            BlamRendering::RenderStack::DWText* new_dwtext = new BlamRendering::RenderStack::DWText();
 
                            AddToStack(new_object_id, new_dwtext);
                        }
                        else if (add_item_current_selection == STACKTYPE_ELLIPSE)
                        {
                            BlamRendering::RenderStack::Ellipse* new_ellipse = new BlamRendering::RenderStack::Ellipse();
 
                            AddToStack(new_object_id, new_ellipse);
                        }
                        else if (add_item_current_selection == STACKTYPE_ROUNDED_RECT)
                        {
                            BlamRendering::RenderStack::RoundedRectangle* new_rounded_rect = new BlamRendering::RenderStack::RoundedRectangle();
 
                            AddToStack(new_object_id, new_rounded_rect);
                        }
                        else if (add_item_current_selection == STACKTYPE_BITMAP)
                        {
                            BlamRendering::RenderStack::Bitmap* new_bitmap = new BlamRendering::RenderStack::Bitmap();
 
                            AddToStack(new_object_id, new_bitmap);
                        }
                        else if (add_item_current_selection == STACKTYPE_LINE)
                        {
                            BlamRendering::RenderStack::Line* new_line = new BlamRendering::RenderStack::Line();
 
                            AddToStack(new_object_id, new_line);
                        }
                        else if (add_item_current_selection == STACKTYPE_BITMAP_TEXT)
                        {
                            BlamRendering::RenderStack::BitmapText* new_bitmap_text = new BlamRendering::RenderStack::BitmapText();
 
                            AddToStack(new_object_id, new_bitmap_text);
                        }
                        else if (add_item_current_selection == STACKTYPE_TEXT)
                        {
                            BlamRendering::RenderStack::Text* new_text = new BlamRendering::RenderStack::Text();
 
                            AddToStack(new_object_id, new_text);
                        }
                        else
                        {
                            show_unreciognized_popup = true;
                        }
                    }
 
                    ImGui::SameLine();
                    if (ImGui::Button("Remove"))
                    {
                        if (GetStack()->at(active_index) != nullptr)
                        {
                            if (GetStack()->at(active_index)->type_label == STACKTYPE_IMGUI)
                            {
                                show_delete_imgui_popup = true;
                            }
                            else
                            {
                                RemoveFromStack(active_index);
                            }
                        }
                        else
                        {
                            show_outofbounds_popup = true;
                        }
                    }
 
                    ImGui::SameLine();
                    if (ImGui::Button("Duplicate"))
                    {
                        Blam::Logger::LogEventForce("not yet implemented", WSV_NONE);
                        // Duplicate entry here
                    }
 
                    ImGui::Separator();
 
                    ImGui::Columns(2);
 
                    ImGui::SetColumnWidth(0, 200);
 
                    if (ImGui::Button("^"))
                    {
                        Blam::Logger::LogEventForce("not yet implemented", WSV_NONE);
                    }
 
                    ImGui::SameLine();
 
                    if (ImGui::Button("v"))
                    {
                        Blam::Logger::LogEventForce("not yet implemented", WSV_NONE);
                    }
 
                    if (ImGui::ListBoxHeader("", ImVec2(ImGui::GetColumnWidth() - 15, -1)))
                    {
                        for (int i = 0; i < GetStack()->size(); i++)
                        {
                            StackObjectBase* obj = GetStack()->at(i);
 
                            std::string label = std::to_string(i) + ": (" + obj->GetType() + ")";
 
                            const char* label_cstr = label.c_str();
 
                            bool active = false;
 
                            if (i == active_index)
                            {
                                active = true;
                            }
 
                            if (ImGui::Selectable(label_cstr, active))
                            {
                                SelectItem(i, obj);
                            }
 
                            if (ImGui::IsItemHovered())
                            {
                                ImGui::BeginTooltip();
                                ImGui::PushTextWrapPos(450.0f);
                                ImGui::Text("object details");
                                ImGui::Separator();
                                
                                std::string object_index = "index: " + std::to_string(i);
                                std::string object_type = "type : " + obj->GetType();
 
 
                                ImGui::Text(object_index.c_str());
                                ImGui::Text(object_type.c_str());
 
                                if (obj->type_label == STACKTYPE_DWTEXT)
                                {
                                    std::string object_text = "text : " + BlamStrings::Converters::WstringToString(((BlamRendering::RenderStack::DWText*)obj)->text);
                                    ImGui::Text(object_text.c_str());
                                }
 
                                ImGui::PopTextWrapPos();
                                ImGui::EndTooltip();
                            }
                        }
 
                        ImGui::ListBoxFooter();
                    }
 
                    ImGui::NextColumn();
 
                    if (active_object != nullptr)
                    {
                        PropertyView();
                    }
                    else
                    {
                        ImGui::Text("no object selected");
                    }
                }
 
                ImGui::End();
            }
        }
 
        void SelectItem(int index, StackObjectBase* obj)
        {
            active_index = index;
            active_object = obj;
        }
 
        void PropertyView()
        {
            std::string header = std::to_string(active_index) + ": (" + active_object->GetType() + ")";
 
            ImGui::Text(header.c_str());
 
            ImGui::Checkbox("use raw values", &use_raw_values);
            ImGui::SameLine();
 
            float object_width = active_object->area.right - active_object->area.left;
            float object_height = active_object->area.bottom - active_object->area.top;
 
            if (object_width < 0 || object_height < 0)
            {
                ImGui::TextColored(ImVec4(255, 0, 0, 255), "[warn]");
                if (ImGui::IsItemHovered())
                {
                    ImGui::BeginTooltip();
                    ImGui::PushTextWrapPos(450.0f);
                    ImGui::Text("height and/or width will be negative on conversion!");
                    ImGui::Separator();
                    if (object_width < 0)
                    {
                        std::string width_msg = "object width would be less than 0 (" + std::to_string(object_width) + ")";
 
                        ImGui::Text(width_msg.c_str());
                    }
                    if (object_height < 0)
                    {
                        std::string height_msg = "object height would be less than 0 (" + std::to_string(object_height) + ")";
 
                        ImGui::Text(height_msg.c_str());
                    }
                    ImGui::PopTextWrapPos();
                    ImGui::EndTooltip();
                }
            }
            else
            {
                ImGui::TextColored(ImVec4(0, 255, 0, 255), "[ok]");
            }
            ImGui::SameLine();
            Blam::DebugUI::Widgets::ShowHelpMarker("when enabled, exposes the raw values seen by directx\r\nwhen disabled, friendlier fields are displayed instead\r\n\r\nthe status indicator shows either [ok] or [warn] based on what the object height will be upon disabling real rect sizes");
            
            if (ImGui::BeginTabBar("rse_tabs", ImGuiTabBarFlags_NoTooltip))
            {
                if (ImGui::BeginTabItem("Information"))
                {
                    Widgets::ShowBasicHoveredTooltip("basic information about this object");
 
                    std::string item_type = "object type: " + active_object->GetType();
                    std::string item_index = "stack index: " + std::to_string(active_index);
                    std::string unique_id = "unique id: " + active_object->unique_id;
 
                    ImGui::Text(item_type.c_str());
                    ImGui::Text(item_index.c_str());
                    ImGui::Text(unique_id.c_str());
 
                    ImGui::EndTabItem();
                }
 
                // Properties that are part of all stack objects
                BasePropertiesTab();
 
                std::string unique_props_label = "Properties for " + active_object->GetType();
 
                // Properties unique to the given stack object
                if (ImGui::BeginTabItem(unique_props_label.c_str()))
                {
                    Widgets::ShowBasicHoveredTooltip("properties specific to this object type");
 
                    active_object->ShowImPropertyEditor();
 
                    ImGui::EndTabItem();
                }
 
 
                ImGui::EndTabBar();
            }
        }
 
        void BasePropertiesTab()
        {
            if (ImGui::BeginTabItem("Base Properties"))
            {
                Widgets::ShowBasicHoveredTooltip("properties applicable to all render stack items\r\nkeep in mind that some objects may not utilize all of these");
 
                if (use_raw_values)
                {
                    ImGui::Checkbox("compact area input", &compact_area_input);
 
                    if (compact_area_input)
                    {
                        ImGui::DragFloat4("area", (float*)&active_object->area);
                    }
                    else
                    {
                        ImGui::DragFloat("area left", &active_object->area.left);
                        ImGui::DragFloat("area top", &active_object->area.top);
                        ImGui::DragFloat("area right", &active_object->area.right);
                        ImGui::DragFloat("area bottom", &active_object->area.bottom);
                    }
 
                    std::string value_helper = "top: " + std::to_string(active_object->area.top)
                        + "\r\nbottom: " + std::to_string(active_object->area.bottom)
                        + "\r\nleft: " + std::to_string(active_object->area.left)
                        + "\r\nright: " + std::to_string(active_object->area.right);
 
                    ImGui::SameLine(); Blam::DebugUI::Widgets::ShowHelpMarker(value_helper.c_str());
                }
                else
                {
                    ImGui::DragFloat("width", &active_object->width, 1, 0, 2147483647, "width: %.3f");
                    ImGui::DragFloat("height", &active_object->height, 1, 0, 2147483647, "height: %.3f");
 
                    active_object->PokeSize();
                }
 
 
                ImGui::ColorEdit4("color", (float*)&active_object->color);
                ImGui::SliderInt("z order", &active_object->z_order, 0, 255);
 
                if (use_raw_values)
                {
                    //use hacky "shift" methods to allow moving object
                    if (ImGui::CollapsingHeader("shifting"))
                    {
                        D2D1_SIZE_F target_size = BlamRendering::DirectX::D2D::GetD2DRenderTarget()->GetSize();
 
                        ImGui::Checkbox("limit to window", &rect_limit_to_window);
 
 
                        float rect_shift[2] = { 0, 0 };
                        ImGui::SliderFloat2("shift", rect_shift, shift_limits[0], shift_limits[1]);
 
                        ImGui::InputFloat2("shift bounds", shift_limits);
 
                        ImGui::SameLine(); Blam::DebugUI::Widgets::ShowHelpMarker("this controls the min and max bounds of the above sliders \r\nlarger numbers means faster movement");
 
 
 
                        if (rect_limit_to_window)
                        {
                            if ((active_object->area.top > 0 || rect_shift[0] > 0) && (active_object->area.bottom < target_size.height || rect_shift[0] < 0))
                            {
                                active_object->area.top = active_object->area.top + rect_shift[0];
                                active_object->area.bottom = active_object->area.bottom + rect_shift[0];
                            }
 
                            if ((active_object->area.left > 0 || rect_shift[1] > 0) && (active_object->area.right < target_size.width || rect_shift[1] < 0))
                            {
                                active_object->area.left = active_object->area.left + rect_shift[1];
                                active_object->area.right = active_object->area.right + rect_shift[1];
                            }
                        }
                        else
                        {
                            active_object->area.top = active_object->area.top + rect_shift[0];
                            active_object->area.bottom = active_object->area.bottom + rect_shift[0];
                            active_object->area.left = active_object->area.left + rect_shift[1];
                            active_object->area.right = active_object->area.right + rect_shift[1];
                        }
                    }
                }
                else
                {
                    // Modify object translation
                    if (ImGui::CollapsingHeader("translation"))
                    {
                        D2D1_SIZE_F target_size = BlamRendering::DirectX::D2D::GetD2DRenderTarget()->GetSize();
 
                        ImGui::Checkbox("limit to window", &rect_limit_to_window);
 
 
 
                        float x = active_object->area.left;
                        float y = active_object->area.top;
 
                        float x_min = -2147483647;
                        float x_max = 2147483647;
 
                        float y_min = -2147483647;
                        float y_max = 2147483647;
 
                        if (rect_limit_to_window)
                        {
                            x_min = 0;
                            x_max = target_size.width - active_object->width;
 
                            y_min = 0;
                            y_max = target_size.height - active_object->height;
                        }
 
 
 
                        ImGui::InputFloat("drag speed", &translate_speed);
 
                        ImGui::DragFloat("x coord", &active_object->x, translate_speed, x_min, x_max, "x: %.3f");
                        ImGui::DragFloat("y coord", &active_object->y, translate_speed, y_min, y_max, "y: %.3f");
 
                        active_object->PokeTranslation();
 
                        if (active_object->type_label == STACKTYPE_ELLIPSE)
                        {
                            BlamRendering::RenderStack::Ellipse* ellipse_object = ((BlamRendering::RenderStack::Ellipse*)active_object);
 
                            ellipse_object->PokeEllipseTranslation();
                        }
 
                        if (active_object->type_label == STACKTYPE_ROUNDED_RECT)
                        {
                            BlamRendering::RenderStack::RoundedRectangle* rounded_rect_object = ((BlamRendering::RenderStack::RoundedRectangle*)active_object);
 
                            rounded_rect_object->PokeRoundedRectArea();
                        }
 
                        if (active_object->type_label == STACKTYPE_LINE)
                        {
                            BlamRendering::RenderStack::Line* line_object = ((BlamRendering::RenderStack::Line*)active_object);
 
                            line_object->PokeLineTranslation();
                        }
 
                        if (active_object->type_label == STACKTYPE_TEXT)
                        {
                            BlamRendering::RenderStack::Text* text_object = ((BlamRendering::RenderStack::Text*)active_object);
 
                            text_object->UpdateAllProperties();
                            text_object->RefreshTranslation();
                        }
                    }
                }
 
                if (active_object->type_label == STACKTYPE_DEBUG_MENU)
                {
                    BlamRendering::RenderStack::DebugMenu* debug_menu_object = ((BlamRendering::RenderStack::DebugMenu*)active_object);
 
                    debug_menu_object->PokePropertyChanges();
                }
 
                ImGui::EndTabItem();
            }
        }
 
        #pragma region dialogs
 
        void DeleteImGuiObjectPopup()
        {
            if (show_delete_imgui_popup)
            {
                ImGui::OpenPopup("WARNING");
                if (ImGui::BeginPopupModal("WARNING", &show_delete_imgui_popup, ImGuiWindowFlags_NoResize))
                {
                    ImGui::Text("you are trying to delete imgui stack object! this will remove imgui entirely, including stack editor!");
                    ImGui::NewLine();
                    ImGui::Text("do you wish to continue?");
                    ImGui::Text("tip: you can re-add by enabling the win32 menu bar and choosing Test > Restore ImGUI");
 
                    if (ImGui::Button("yes"))
                    {
                        RemoveFromStack(active_index);
                        show_delete_imgui_popup = false;
                    }
 
                    if (ImGui::Button("no"))
                    {
                        show_delete_imgui_popup = false;
                    }
 
                    ImGui::EndPopup();
                }
            }
        }
 
        void IndexOutOfBoundsPopup()
        {
            if (show_outofbounds_popup)
            {
                ImGui::OpenPopup("index out of bounds");
                if (ImGui::BeginPopupModal("index out of bounds", &show_outofbounds_popup, ImGuiWindowFlags_NoResize))
                {
                    ImGui::Text("selected render stack item index was out of bounds (most likely no object was selected)");
                    ImGui::NewLine();
 
                    std::string selected_index_text = "selected item index: " + active_index;
 
                    ImGui::Text(selected_index_text.c_str());
 
                    if (ImGui::Button("ok"))
                    {
                        show_outofbounds_popup = false;
                    }
 
                    ImGui::EndPopup();
                }
            }
        }
 
        void UnreciognizedTypePopup()
        {
            if (show_unreciognized_popup)
            {
                ImGui::OpenPopup("unreciognized or invalid type");
                if (ImGui::BeginPopupModal("unreciognized or invalid type", &show_unreciognized_popup, ImGuiWindowFlags_NoResize))
                {
                    ImGui::Text("invalid type specified, unreciognized type,\r\nor no object add functionality implemented");
                    ImGui::NewLine();
                    ImGui::Text("hint: look for 'render_stack_editor.cpp' and\r\ncheck there");
 
                    if (ImGui::Button("ok"))
                    {
                        show_unreciognized_popup = false;
                    }
 
                    ImGui::EndPopup();
                }
            }
        }
 
        void InvalidTypePopup()
        {
            if (show_invalid_popup)
            {
                ImGui::OpenPopup("invalid type");
                if (ImGui::BeginPopupModal("invalid type", &show_invalid_popup, ImGuiWindowFlags_NoResize))
                {
                    ImGui::Text("tried to add invalid object type!");
                    ImGui::Separator();
                    ImGui::Text("possible causes:");
                    ImGui::BulletText("imgui items can only be added once - as that object controls\r\nthe entirety of imgui - you can't have two of them");
                    ImGui::BulletText("generic stack objects have no drawing functionality and thus\r\nwould do nothing but waste memory");
                    ImGui::Separator();
                    ImGui::Text("if you tried to add another object type, then the functionality\r\nwas either deliberately disabled or something got borked - check\r\n'render_stack_editor.hpp' for clues");
 
                    ImGui::NewLine();
                    if (ImGui::Button("sure thing bro"))
                    {
                        show_invalid_popup = false;
                    }
 
                    ImGui::EndPopup();
                }
            }
        }
 
        #pragma endregion
    };
}