fields.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <d2d1.h>
 
#include "tags.h"
#include "components/3rdparty/imgui/imgui.h"
#include "components/ui/imgui/imgui_widgets/widgets.h"
#include "components/3rdparty/imgui/extensions/imgui_extensions.h"
#include "components/diagnostics/logger/logger.h"
#include "components/core/utils/string/string.h"
 
#ifndef BLAM
#define BLAM
#endif
 
typedef bool bitfield8[8];    
typedef bool bitfield16[16];  
typedef bool bitfield32[32];  
typedef char ascii[32];       
 
namespace Blam::Content::Tags
{
    class TagField
    {
    public:
        std::string display_name; 
        std::string extra_info;   
 
        void* read_address;       
        int read_length;          
 
        virtual void ShowImPropertyControl() 
        {
            ImGui::TextColored(ImVec4(1.0, 0.0, 0.0, 1.0), std::string("<field '" + display_name + "' has no imgui control available>").c_str());
        }
 
        virtual void SetMemoryLocation(void* new_address)
        {
            read_address = new_address;
        }
 
        virtual std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<unknown id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"false\" />";
 
            return field_string;
        }
    };
 
    class AsciiField : public TagField
    {
    public:
        AsciiField(std::string _display_name, std::string _extra_info)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(ascii);
        }
 
        void ShowImPropertyControl()
        {
            ImGui::InputText(display_name.c_str(), (char*)read_address, read_length);
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<ascii id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" length=\"" + std::to_string(read_length) + "\" visible=\"true\" />";
 
            return field_string;
        }
    };
 
    class Int32Field : public TagField
    {
    public:
        Int32Field(std::string _display_name, std::string _extra_info)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(int);
        }
 
        void ShowImPropertyControl()
        {
            ImGui::DragInt(display_name.c_str(), (int*)read_address, 1.0f);
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<int32 id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\" />";
 
            return field_string;
        }
    };
 
    class Int16Field : public TagField
    {
    public:
        Int16Field(std::string _display_name, std::string _extra_info)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(short);
        }
 
        void ShowImPropertyControl()
        {
            int value_expand = *(short*)read_address;
 
            ImGui::DragInt(display_name.c_str(), &value_expand, 1.0f, -32768, 32767);
 
            *(short*)read_address = value_expand;
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<int16 id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\" />";
 
            return field_string;
        }
    };
 
    class Int8Field : public TagField
    {
    public:
        Int8Field(std::string _display_name, std::string _extra_info)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(byte);
        }
 
        void ShowImPropertyControl()
        {
            int value_expand = *(byte*)read_address;
 
            ImGui::DragInt(display_name.c_str(), &value_expand, 1.0f, 0, 255);
 
            *(byte*)read_address = value_expand;
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<int8 id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\" />";
 
            return field_id;
        }
    };
 
    class BooleanField : public TagField
    {
    public:
        BooleanField(std::string _display_name, std::string _extra_info)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(bool);
        }
 
        void ShowImPropertyControl()
        {
            ImGui::Checkbox(display_name.c_str(), (bool*)read_address);
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<boolean id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\" />";
        
            return field_string;
        }
    };
 
    class ColorFloatField : public TagField
    {
    public:
        ColorFloatField(std::string _display_name, std::string _extra_info)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(D2D1_COLOR_F);
        }
 
        void ShowImPropertyControl()
        {
            ImGui::ColorEdit4(display_name.c_str(), (float*)read_address);
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<colorf id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\" format=\"rgba\" />";
            
            return field_string;
        }
    };
 
    class EnumField : public TagField
    {
    private:
        std::vector<std::string> options;  
        int* active_item = 0;              
 
    public:
        EnumField(std::string _display_name, std::string _extra_info, std::vector<std::string> _options)
        {
            display_name = _display_name;
            extra_info = _extra_info;
            options = _options;
 
            read_length = sizeof(int);
        }
 
        void ShowImPropertyControl()
        {
            active_item = (int*)read_address;
 
            if (ImGui::BeginCombo(display_name.c_str(), options.at(*active_item).c_str()))
            {
                for (int i = 0; i < options.size(); i++)
                {
                    if (ImGui::Selectable(options.at(i).c_str()))
                    {
                        *active_item = i;
                    }
                }
 
                ImGui::EndCombo();
            }
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<enum id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\">";
 
            for (int i = 0; i < options.size(); i++)
            {
                field_string += "<option id=\"" + field_id + "\" name=\"" + display_name + "\" value=\"" + std::to_string(i) + "\" visible=\"true\"/>";
            }
 
            field_string += "</enum>";
 
            return field_string;
        }
    };
 
    class Bitfield8Field : public TagField
    {
    public:
        std::vector<std::string> options;   
        int max_items_to_show = 8;          
 
        Bitfield8Field(std::string _display_name, std::string _extra_info, std::vector<std::string> _options)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(bitfield8);
 
            options = _options;
        }
 
        void ShowImPropertyControl()
        {
            int region_height = (ImGui::GetStyle().WindowPadding.y * 2) + (max_items_to_show * 21) + ((max_items_to_show - 1) * ImGui::GetStyle().ItemSpacing.y);
            int region_width = ImGui::CalcItemWidth();
 
 
            ImGui::BeginChild(display_name.c_str(), ImVec2(region_width, region_height), true, ImGuiWindowFlags_HorizontalScrollbar);
 
            int max_bits_available = 0;
 
            if (options.size() > max_items_to_show)
            {
                max_bits_available = max_items_to_show;
            }
            else
            {
                max_bits_available = options.size();
            }
 
            for (int i = 0; i < options.size(); i++)
            {
                void* prop_address = (char*)read_address + i;
 
                ImGui::Checkbox(options.at(i).c_str(), (bool*)prop_address);
            }
 
            if (options.size() < max_items_to_show)
            {
                int unused_options = max_items_to_show - options.size();
 
                for (int i = 0; i < unused_options; i++)
                {
                    bool helper_value = false;
 
                    ImGui::Checkbox("", &helper_value);
                    ImGui::SameLine();
                    ImGui::TextDisabled("unused bit");
                }
            }
 
            ImGui::EndChild();
 
            ImGui::SameLine();
            ImGui::Text(display_name.c_str());
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<bitfield8 id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\">";
 
            for (int i = 0; i < options.size(); i++)
            {
                field_string += "<bit id=\"" + field_id + "\" name=\"" + display_name + "\" index=\"" + std::to_string(i) + "\" visible=\"true\"/>";
            }
 
            field_string += "</bitfield8>";
 
            return field_string;
        }
    };
 
    class Bitfield16Field : public TagField
    {
    public:
        std::vector<std::string> options;   
        int max_items_to_show = 16;         
 
        Bitfield16Field(std::string _display_name, std::string _extra_info, std::vector<std::string> _options)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(bitfield16);
 
            options = _options;
        }
 
        void ShowImPropertyControl()
        {
            int region_height = (ImGui::GetStyle().WindowPadding.y * 2) + (max_items_to_show * 21) + ((max_items_to_show - 1) * ImGui::GetStyle().ItemSpacing.y);
            int region_width = ImGui::CalcItemWidth();
 
 
            ImGui::BeginChild(display_name.c_str(), ImVec2(region_width, region_height), true, ImGuiWindowFlags_HorizontalScrollbar);
 
            int max_bits_available = 0;
 
            if (options.size() > max_items_to_show)
            {
                max_bits_available = max_items_to_show;
            }
            else
            {
                max_bits_available = options.size();
            }
 
            for (int i = 0; i < options.size(); i++)
            {
                void* prop_address = (char*)read_address + i;
 
                ImGui::Checkbox(options.at(i).c_str(), (bool*)prop_address);
            }
 
            if (options.size() < max_items_to_show)
            {
                int unused_options = max_items_to_show - options.size();
 
                for (int i = 0; i < unused_options; i++)
                {
                    bool helper_value = false;
 
                    ImGui::Checkbox("", &helper_value);
                    ImGui::SameLine();
                    ImGui::TextDisabled("unused bit");
                }
            }
 
            ImGui::EndChild();
 
            ImGui::SameLine();
            ImGui::Text(display_name.c_str());
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<bitfield16 id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\">";
 
            for (int i = 0; i < options.size(); i++)
            {
                field_string += "<bit id=\"" + field_id + "\" name=\"" + display_name + "\" index=\"" + std::to_string(i) + "\" visible=\"true\"/>";
            }
 
            field_string += "</bitfield16>";
 
            return field_string;
        }
    };
 
    class Bitfield32Field : public TagField
    {
    public:
        std::vector<std::string> options;   
        int max_items_to_show = 32;         
 
        Bitfield32Field(std::string _display_name, std::string _extra_info, std::vector<std::string> _options)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = sizeof(bitfield32);
 
            options = _options;
        }
 
        void ShowImPropertyControl()
        {
            int region_height = (ImGui::GetStyle().WindowPadding.y * 2) + (max_items_to_show * 21) + ((max_items_to_show - 1) * ImGui::GetStyle().ItemSpacing.y);
            int region_width = ImGui::CalcItemWidth();
 
 
            ImGui::BeginChild(display_name.c_str(), ImVec2(region_width, region_height), true, ImGuiWindowFlags_HorizontalScrollbar);
 
            int max_bits_available = 0;
 
            if (options.size() > max_items_to_show)
            {
                max_bits_available = max_items_to_show;
            }
            else
            {
                max_bits_available = options.size();
            }
 
            for (int i = 0; i < options.size(); i++)
            {
                void* prop_address = (char*)read_address + i;
 
                ImGui::Checkbox(options.at(i).c_str(), (bool*)prop_address);
            }
 
            if (options.size() < max_items_to_show)
            {
                int unused_options = max_items_to_show - options.size();
 
                for (int i = 0; i < unused_options; i++)
                {
                    bool helper_value = false;
 
                    ImGui::Checkbox("", &helper_value);
                    ImGui::SameLine();
                    ImGui::TextDisabled("unused bit");
                }
            }
 
            ImGui::EndChild();
 
            ImGui::SameLine();
            ImGui::Text(display_name.c_str());
 
            if (extra_info.length() > 0)
            {
                ImGui::SameLine();
                Blam::DebugUI::Widgets::ShowHelpMarker(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<bitfield32 id=\"" + field_id + "\" name=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" visible=\"true\">";
 
            for (int i = 0; i < options.size(); i++)
            {
                field_string += "<bit id=\"" + field_id + "\" name=\"" + display_name + "\" index=\"" + std::to_string(i) + "\" visible=\"true\"/>";
            }
 
            field_string += "</bitfield32>";
 
            return field_string;
        }
    };
 
    class CommentField : public TagField
    {
    public:
        CommentField(std::string _display_name)
        {
            display_name = _display_name;
            extra_info = "";
 
            read_length = 0;
        }
 
        CommentField(std::string _display_name, std::string _extra_info)
        {
            display_name = _display_name;
            extra_info = _extra_info;
 
            read_length = 0;
        }
 
        void ShowImPropertyControl()
        {
            ImGui::Text(display_name.c_str());
            ImGui::NewLine();
 
            if (extra_info.length() > 0)
            {
                ImGui::Text(extra_info.c_str());
            }
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<comment title=\"" + display_name + "\" visible=\"true\">";
 
            field_string += extra_info;
 
            field_string += "</comment>";
 
            return field_string;
        }
    };
 
    class TagReference : public TagField
    {
    private:
        std::vector<std::string> valid_classes;
        int active_class_index = 0;
        std::string active_tag_class_label;
 
        std::vector<tag_memory_data> filtered_tag_list;
        int active_tag_index = 0;
    public:
        TagReference(std::string _display_name, std::string _extra_info, std::vector<std::string> _valid_classes)
        {
            display_name = _display_name;
            extra_info = _extra_info;
            valid_classes = _valid_classes;
 
            read_length = sizeof(tag_reference);
        }
 
        std::string GetFieldXMLString(int offset);
        void ShowImPropertyControl();
    };
 
    class Block : public TagField
    {
    private:
        float indent = 22.0f;                  
 
    public:
        std::vector<TagField*> block_template; 
        int active_entry = 0;                  
        tag_block* block_info;                 
        
        int entry_size = 0;                    
 
        Block(int _entry_size, std::string _display_name, std::string _extra_info, std::vector<TagField*> _block_template)
        {
            display_name = _display_name;
            extra_info = _extra_info;
            block_template = _block_template;
            entry_size = _entry_size;
 
            read_length = sizeof(tag_block);
        }
 
        void SetMemoryLocation(void* new_address)
        {
            read_address = (char*)new_address/* + 1*/;
        }
 
        std::string GetFieldXMLString(int offset)
        {
            std::string field_id = Blam::Utils::String::ToLower(display_name);
            field_id = Blam::Utils::String::Replace(field_id, " ", "_");
 
            std::string field_string = "<reflexive id=\"" + field_id + "\" title=\"" + display_name + "\" offset=\"" + std::to_string(offset) + "\" entrySize=\"" + std::to_string(entry_size) + "\" visible=\"true\">";
 
            int field_offset = 0;
 
            for (int i = 0; i < block_template.size(); i++)
            {
                field_string += block_template.at(i)->GetFieldXMLString(field_offset);
                field_offset += block_template.at(i)->read_length;
            }
 
            field_string += "</reflexive>";
 
            return field_string;
        }
 
        void ShowImPropertyControl()
        {
            block_info = (tag_block*)read_address;
            block_info->entry_size = entry_size;
            block_info->block_identifier[0] = 't';
            block_info->block_identifier[1] = 'b';
            block_info->block_identifier[2] = 'f';
            block_info->block_identifier[3] = 'd';
            block_info->block_identifier[4] = NULL;
 
            if (active_entry > block_info->entry_count)
            {
                active_entry = block_info->entry_count - 1;
            }
            else if (active_entry < 0)
            {
                active_entry = 0;
            }
 
 
            if (ImGui::CollapsingHeader(display_name.c_str()))
            {
                ImGui::Indent(indent);
 
                std::string block_id = "block_" + display_name;
 
                ImGui::PushID(block_id.c_str());
                if (ImGui::Button("Add"))
                {
                    if (block_info->entry_count == 0)
                    {
                        // For the first entry, we can simply allocate a new block without having to free
                        // anything beforehand.
 
                        void* new_entry_address = calloc(1, entry_size * (block_info->entry_count + 1));
 
                        block_info->entry_data_address = new_entry_address;
 
                        block_info->entry_count++;
                    }
                    else
                    {
                        // If we already have existing entries, we need to allocate a new block of memory and
                        // copy the original data to it - then free the old memory block.
 
                        void* new_data_address = calloc(1, entry_size * (block_info->entry_count + 1));
 
                        void* old_address = block_info->entry_data_address;
 
                        memcpy(new_data_address, block_info->entry_data_address, (entry_size * block_info->entry_count));
 
                        block_info->entry_data_address = new_data_address;
 
                        free(old_address);
 
                        block_info->entry_count++;
                    }
                }
 
                ImGui::SameLine();
 
                if (ImGui::Button("Insert"))
                {
                    Blam::Logger::LogEvent("not yet implemented");
                }
 
                ImGui::SameLine();
 
                if (ImGui::Button("Duplicate"))
                {
                    Blam::Logger::LogEvent("not yet implemented");
                }
 
                ImGui::SameLine();
 
                if (ImGui::Button("Delete"))
                {
                    Blam::Logger::LogEvent("not yet implemented");
                }
 
                ImGui::SameLine();
 
                if (ImGui::Button("Delete All"))
                {
                    Blam::Logger::LogEvent("not yet implemented");
                }
 
                ImGui::SameLine();
 
                ImGui::PushItemWidth(70.0f);
                if (ImGui::BeginCombo("entry", std::to_string(active_entry).c_str()))
                {
                    for (int i = 0; i < block_info->entry_count; i++)
                    {
                        std::string label = "entry " + std::to_string(i);
 
                        if (ImGui::Selectable(label.c_str()))
                        {
                            active_entry = i;
                        }
                    }
 
                    ImGui::EndCombo();
                }
                ImGui::PopItemWidth();
 
                if (block_info->entry_count != 0)
                {
                    void* entry_start_address = (char*)block_info->entry_data_address + (entry_size * active_entry);
 
                    void* next_field_address = entry_start_address;
 
                    for (int i = 0; i < block_template.size(); i++)
                    {
                        block_template[i]->SetMemoryLocation(next_field_address);
 
                        block_template[i]->ShowImPropertyControl();
 
                        next_field_address = (char*)block_template[i]->read_address + block_template[i]->read_length;
                    }
                }
                else
                {
                    ImGui::Text("no entries found");
                }
 
                ImGui::Unindent(indent);
 
                ImGui::PopID();
            }
        }
    };
}