ui.h

Go to the documentation of this file.

#pragma once
 
#include <Strings/components/resources/color/BlamColor.h>
#include <OGRE/Overlay/OgreTextAreaOverlayElement.h>
#include <OGRE/Overlay/OgreOverlayContainer.h>
#include <OGRE/Overlay/OgrePanelOverlayElement.h>
#include <OGRE/Overlay/OgreOverlay.h>
#include <OGRE/OgreManualObject2.h>
#include <OGRE/OgreSceneManager.h>
#include <bgfx/bgfx.h>
#include <vector>
#include <string>
 
#include "components/core/world/world.h"
#include "api/v1/types/tags/classes/cui_screen.h"
#include "components/content/fonts/fonts.h"
 
#ifndef BLAM
#define BLAM
#endif
 
class BlamUIWidget_Group;
class BlamUIWidget_BasicRectangle;
class BlamUIWidget_CrashScreen;
class BlamUIWidget_DebugMenu;
class BlamUIWidget_DefaultLoadScreen;
class BlamImGuiWindow_BlamUIEditor;
class BlamUIWidget_InfoDisplay;
 
enum class BlamWidgetAnchor : uint8_t
{
    TopCenter,    
    Center,       
    BottomCenter, 
 
    TopLeft,      
    CenterLeft,   
    BottomLeft,   
 
    TopRight,     
    CenterRight,  
    BottomRight,  
 
    TopFill,      
    LeftFill,     
    RightFill,    
    BottomFill,   
    Fill          
};
 
enum class BlamWidgetType
{
    Basic_Rectangle,    
    Basic_Ellipse,      
    Basic_Line,         
    Basic_Triangle,     
    Text,               
    Group,              
    Group_VLayout,      
    Group_HLayout,      
 
    Custom,               
    Unspecified         
};
 
class BlamUIWidget
{
private:
    BlamWidgetType widget_type = BlamWidgetType::Unspecified;    
    BlamWidgetAnchor anchor_position = BlamWidgetAnchor::Center; 
    bool update = false; 
    bool hidden = false; 
    std::string custom_type_name = "UNSPECIFIED";
 
    void ShowAnchorChangeButton(BlamWidgetAnchor new_anchor, int height_mul, int width_mul, bool text_multiline);
 
protected:
    BlamVector2 position_absolute = { 0, 0 }; 
    BlamVector2 size_absolute = { 100, 100 }; 
 
    int GetAdjustedZIndex();
 
public:
    std::string display_name = "unnamed"; 
    std::string description = ""; 
 
    BlamVector2 position = { 0, 0 }; 
    BlamVector2 size = { 100, 100 }; 
    float rotation = 0.0f;           
 
    int z_index = 0;          
    float z_size = 1.0f;      
    bool auto_update = false; 
 
    Ogre::HlmsDatablock* material = nullptr; 
    BlamUIWidget_Group* parent = nullptr;    
    bool ignore_layout = false;       
    bool hide_in_layout = false;      
    bool ignore_scale_factor = false; 
 
    BlamUIWidget(BlamWidgetType type);
 
    BlamUIWidget(BlamWidgetType type, BlamUIWidget_Group* _parent);
 
    BlamUIWidget(std::string type);
 
    BlamUIWidget(std::string type, BlamUIWidget_Group* _parent);
 
    virtual ~BlamUIWidget() {};
 
    virtual void Draw();
 
    virtual void ShowImGuiPropertyEditor();
 
    virtual void UpdateMetrics() {};
 
    BlamWidgetType GetType();
 
    virtual void RefreshRelativePosition();
 
    void RefreshRelativePosition(int viewport_width, int viewport_height, BlamVector2 initial_position);
 
    void SetSize(BlamVector2 new_size);
 
    virtual void SetPosition(BlamVector2 new_position);
 
    void SetRotation(float new_rotation);
 
    void SetAnchorPosition(BlamWidgetAnchor new_anchor_position);
 
    void MarkForUpdate();
 
    bool IsMarkedForUpdate();
 
    void SetMarkedForUpdate(bool _update);
 
    BlamVector2 GetAbsolutePosition();
 
    BlamWidgetAnchor GetAnchorPosition();
 
    virtual void SetHidden(bool new_hidden);
 
    bool IsHidden();
 
    std::string GetCustomType();
};
 
class BlamUIWidget_Group : public BlamUIWidget
{
private:
    BlamUIWidget_BasicRectangle* bounds_border = nullptr; 
    BlamImGuiWindow_BlamUIEditor* editor_window = nullptr; 
 
public:
    std::vector<BlamUIWidget*> children = std::vector<BlamUIWidget*>(); 
    bool show_bounds = false; 
 
    BlamUIWidget_Group(BlamUIWidget_Group* _parent);
 
    BlamUIWidget_Group(BlamWidgetType _type, BlamUIWidget_Group* _parent);
 
    BlamUIWidget_Group(std::string _type, BlamUIWidget_Group* _parent);
    ~BlamUIWidget_Group();
 
    void Draw() override;
    void ShowImGuiPropertyEditor() override;
    void RefreshRelativePosition() override;
    void UpdateMetrics() override;
    void SetHidden(bool new_hidden) override;
 
    void ShowImGuiEditorWindow();
 
    void ClearChildren();
};
 
class BlamUIWidget_VLayoutGroup : public BlamUIWidget_Group
{
private:
    int cached_child_count = 0; 
 
public:
    BlamVector4 padding = { 0, 0, 0, 0 }; 
    int item_spacing = 0;     
    bool auto_height = false; 
 
    BlamUIWidget_VLayoutGroup(BlamUIWidget_Group* _parent);
    ~BlamUIWidget_VLayoutGroup();
 
    void Draw() override;
    void ShowImGuiPropertyEditor() override;
    void RefreshRelativePosition() override;
};
 
class BlamUIWidget_2DPrimitive : public BlamUIWidget
{
protected:
#pragma pack(push, 1)
    struct Blam2DVertex
    {
        BlamVector3 position;
        BlamVector4 color;
        BlamVector3 uv;
    };
 
    struct Blam2DTriangle
    {
        uint16_t idx;
        uint16_t idy;
        uint16_t idz;
    };
 
    struct Blam2DLine
    {
        uint16_t idx;
        uint16_t idy;
    };
#pragma pack(pop)
 
private:
    void PreGenerateManualObject();
 
    void PostGenerateManualObject();
 
    void VerifyManualObjectValid();
 
protected:
    bgfx::VertexLayout vertex_layout; 
    std::vector<Blam2DVertex> vertices = std::vector<Blam2DVertex>();
    std::vector<Blam2DTriangle> triangles = std::vector<Blam2DTriangle>();
    std::vector<Blam2DLine> lines = std::vector<Blam2DLine>();
    bgfx::VertexBufferHandle vertex_buffer = { bgfx::kInvalidHandle };
    bgfx::IndexBufferHandle index_buffer = { bgfx::kInvalidHandle };
    uint64_t state_flags = 0;
 
    Ogre::ManualObject* manual_object = nullptr;   
    Ogre::HlmsUnlitDatablock* datablock = nullptr; 
    Ogre::SceneNode* node = nullptr; 
    bool last_hide_state = false;    
    bool needs_regen = true;         
 
    void AddVertex(float x, float y, float z);
    void AddTriangle(uint16_t x, uint16_t y, uint16_t z);
    void AddLine(uint16_t x, uint16_t y);
 
public:
    BlamColor color = BlamColor(255, 255, 255); 
 
    BlamUIWidget_2DPrimitive(BlamWidgetType _type, BlamUIWidget_Group* _parent);
    ~BlamUIWidget_2DPrimitive();
 
    void Draw() override;
    void ShowImGuiPropertyEditor() override;
    void UpdateMetrics() override;
    void SetHidden(bool new_hidden) override;
 
    virtual void GenerateManualObject() {};
};
 
class BlamUIWidget_BasicRectangle : public BlamUIWidget_2DPrimitive
{
public:
    bool solid = true; 
    int thickness = 1; 
 
    BlamUIWidget_BasicRectangle(BlamUIWidget_Group* _parent);
    void ShowImGuiPropertyEditor() override;
    void GenerateManualObject() override;
};
 
class BlamUIWidget_BasicEllipse : public BlamUIWidget_2DPrimitive
{
public:
    bool solid = false;  
    int thickness = 1;   
    int resolution = 10; 
    BlamVector2 radius = { 10, 10 }; 
 
    BlamUIWidget_BasicEllipse(BlamUIWidget_Group* _parent);
 
    void ShowImGuiPropertyEditor() override;
    void GenerateManualObject() override;
};
 
class BlamUIWidget_BasicLine : public BlamUIWidget_2DPrimitive
{
public:
    int thickness = 1; 
    BlamVector2 start = { 0, 0 }; 
    BlamVector2 end = { 0, 0 };   
 
    BlamUIWidget_BasicLine(BlamUIWidget_Group* _parent);
    
    void ShowImGuiPropertyEditor() override;
    void GenerateManualObject() override;
};
 
class BlamUIWidget_BasicTriangle : public BlamUIWidget_2DPrimitive
{
private:
    void GenerateManualObject() override;
 
public:
    bool solid = false; 
    int thickness = 1;  
 
    bool use_custom_points = false; 
    BlamVector2 point_x = { 0, 0 }; 
    BlamVector2 point_y = { 0, 0 }; 
    BlamVector2 point_z = { 0, 0 }; 
 
    BlamUIWidget_BasicTriangle(BlamUIWidget_Group* _parent);
 
    void ShowImGuiPropertyEditor() override;
};
 
class BlamUIWidget_Text : public BlamUIWidget
{
private:
#pragma pack(push, 1)
    struct Blam2DTextVertex
    {
        BlamVector3 position;
        BlamVector4 color;
        BlamVector3 uv;
    };
 
    struct Blam2DTextTriangle
    {
        uint16_t idx;
        uint16_t idy;
        uint16_t idz;
    };
#pragma pack(pop)
 
    bgfx::VertexLayout vertex_layout; 
    std::vector<Blam2DTextVertex> vertices = std::vector<Blam2DTextVertex>();
    std::vector<Blam2DTextTriangle> triangles = std::vector<Blam2DTextTriangle>();
    bgfx::VertexBufferHandle vertex_buffer = { bgfx::kInvalidHandle };
    bgfx::IndexBufferHandle index_buffer = { bgfx::kInvalidHandle };
    uint64_t state_flags = 0;
 
    Ogre::SceneNode* node = nullptr; 
    Ogre::ManualObject* manual_object = nullptr; 
 
    std::string previous_text = ""; 
    bool last_hide_state = false;   
    BlamColor last_color = BlamColor(255, 255, 255);  
    BlamColor last_shadow_color = BlamColor(0, 0, 0); 
 
    std::vector<Ogre::HlmsDatablock*> datablocks = std::vector<Ogre::HlmsDatablock*>();        
    std::vector<Ogre::HlmsDatablock*> shadow_datablocks = std::vector<Ogre::HlmsDatablock*>(); 
    bool needs_new_datablocks = true; 
 
    void ReleaseOldDatablocks();
 
    void GenerateManualObject();
 
    void GenerateManualObjectSection(bool is_shadow);
 
    void GenerateManualObjectSection_bgfx(bool is_shadow);
 
    void AddVertex(float x, float y, float uvx, float uvy, bool is_shadow = false);
    void AddTriangle(uint16_t x, uint16_t y, uint16_t z);
 
public:
    bool debug_region = false;
    bool auto_scale_shadow = true; 
    int character_height = 16;     
    BlamVector2 shadow_offset = { 1, 1 };        
    BlamColor color = BlamColor(255, 255, 255);  
    BlamColor shadow_color = BlamColor(0, 0, 0); 
    std::string font_name = "fixedsys";      
    BlamFontPackage* font_package = nullptr; 
    std::string text = "blam!";              
 
    BlamUIWidget_Text(BlamUIWidget_Group* _parent);
    ~BlamUIWidget_Text();
 
    void Draw() override;
    void ShowImGuiPropertyEditor() override;
    void UpdateMetrics() override;
    void SetHidden(bool new_hidden) override;
    
    void RebuildTextObject();
};
 
namespace Blam::UI
{
    BLAM bool Initialize();
 
    BLAM void Render();
 
    BLAM void Shutdown();
 
    BLAM BlamUIWidget_Group* GetUIRoot();
 
    BLAM std::string GetWidgetAnchorLabel(BlamWidgetAnchor anchor_position);
 
    BLAM bool LoadFromCUIScreenTag(std::string tag_path, cui_screen* cusc_tag);
 
    BLAM BlamUIWidget_CrashScreen* GetCrashScreenWidget();
 
    BLAM BlamUIWidget_DebugMenu* GetDebugMenuWidget();
 
    BLAM BlamUIWidget_DefaultLoadScreen* GetLoadScreenWidget();
 
    BLAM BlamUIWidget_InfoDisplay* GetInfoDisplayWidget();
}