Menu.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
 
#pragma once
#include "Button.h"
#include "Framework/Component.h"
#include "Component/Transform.h"
 
enum class menuType
{
    mDefault = 0,
    mWrapped = 1
};

class Menu : public Component
{
public:
#pragma region static_functions
    static auto bindLuaTypes(sol::state& lua) -> void;
    static auto getEnum() -> ComponentTypeEnum
    {
        return cMenu;
    }
 
#pragma endregion
 
    Menu(float gapSize, int widthSize, int heightSize, menuType typeMenu);
 
    Menu()
        : Component(cMenu, "Menu")
    {
    }
 
    // If you have messages, you will need to un-default the copy and move constructor and call linkMessages in them
    Menu(const Menu&)                              = default;
    auto operator=(const Menu&) -> Menu&           = default;
    ~Menu() override                               = default;
    Menu(Menu&& other) noexcept                    = default;
    auto operator=(Menu&& other) noexcept -> Menu& = default;
 
#pragma region overriden_functions
 
    auto clone() const -> std::unique_ptr<GameObject> override { return std::make_unique<Menu>(*this); }
 
    auto componentShowMenu() -> void override;
    // for debug ImGUI
    auto onUpdate(float dt) -> void override;
 
    auto endWindow() -> void override {} // for debug ImGUI
    auto onRender() -> void override;
    auto onEnterEngine() -> void override;
    auto load(const Stream& stream) -> void override;
    auto save(Stream& stream) const -> void override;
 
    friend auto to_json(json& j, const Menu& m) -> void;
 
    friend auto from_json(const json& j, Menu& m) -> void;
 
 
#pragma endregion
 
#pragma region Menu_functions
 
#pragma endregion

    auto width() const -> int;

    auto sizeWidth() const -> int;
    
    auto height() const -> int;
    
    auto setOrigin(Vector4D newOrigin) -> void;
    
    auto setOrigin(float x, float y) -> void;
 
    
    auto setOriginX(float x) -> void;
    auto setOriginY(float y) -> void;
    
    auto moveOrigin(float x, float y) -> void;

    auto createEmptyButton() -> std::unique_ptr<Entity>;

    auto getTranslationOfIndex(int x, int y) -> Point2D;
 

    auto pushEntityHorizontal(Entity* entity) -> void;

    auto pushEntity(Entity* entity) -> bool;

    auto makeAndPush(const std::string& name) -> void;
    
    auto removeEntity(int x, int y) -> void;

    auto removeEntity(Entity* entity) -> void;
    
    auto getAboveEntity(Entity* entity) -> Entity*;
    auto getBelowEntity(Entity* entity) -> Entity*;
    auto getLeftEntity(Entity* entity) -> Entity*;
    auto getRightEntity(Entity* entity) -> Entity*;

    auto getMenuElementPosition(Entity* entity) const -> std::pair<int, int>;

    auto updateMenuChildren() -> void;

    auto compactMenu() -> void;

    auto horizontalCompactMenu() -> void;
    
    auto at(int x, int y) -> Entity*;
    
    auto getButtonRow(int x) const -> std::vector<Entity*>;
    
    auto getButtonColumn(int y) const -> std::vector<Entity*>;

    auto clear() const -> void;
 
 
    auto fillMenu() -> void;

    auto getChildScale() const -> Vector4D;

    auto setGapBetweenObjects(float newGap) -> void;
    
    auto drawDebugLines(AffineMatrix transform) -> void;
    
    auto getChildTranslation(Entity* child) const -> Vector4D;
    
 
#pragma region messaging_functions
    auto linkMessages() -> void;
 
#pragma endregion
 
private:
    
#pragma region helper_struct
    
    // Struct that contains a bunch of information for calculating where children should be positioned
    struct PositioningInformation
    {
        // Scale of children inside the menu
        float objectWidth;
        float objectHeight;
 
        // Position for where children start out
        Point2D start;
        // How far the children should be moved right to travel one space
        Vector4D right;
        // How far the children should be moved up to travel one space
        Vector4D up;
    };
 
#pragma endregion
 
#pragma region member_variables

    float gapBetweenObjects = 0.01f;
    int maxItemsWide = 3;
    int maxItemsHeight = 3;
 
    Vector4D originPoint{0.f, 0.f, 0, 1};
    Vector4D menuScale{1.f, 1.f, 0.f, 0.f};
  
    menuType type = menuType::mDefault;
    PositioningInformation posInfo;
    
    
    std::vector<std::vector<Entity*>> buttons;
 
#pragma endregion
 
#pragma region helper_functions

    auto returnWrappedMenuPosition(int x, int y) -> Point2D;
    auto returnDefaultMenuPosition(int x, int y) -> Point2D;

    auto returnButtonIndexWrapped(int x, int y) -> Entity*;
    auto returnButtonIndexDefault(int x, int y) -> Entity*;

    auto getButtonPosition(Entity* ent) -> std::pair<int, int>;

    void recalculatePositioning();

    void recalculateHorizontalPositioning();
    
    auto repositionItems(const std::vector<Entity*>& ent, int column) -> void;

    auto repositionHorizontalItems(const std::vector<Entity*>& ent, int column) -> void;
    
#pragma endregion
 
#pragma region static_variables
 
#pragma endregion
 
};