openrw/rwgame/MenuSystem.hpp

#ifndef _GAME_MENUSYSTEM_HPP_
#define _GAME_MENUSYSTEM_HPP_
#include <algorithm>
#include <functional>
#include <glm/glm.hpp>
#include <memory>
#include <render/GameRenderer.hpp>
#include <string>

/**
 * Default values for menus that should match the look and feel of the original
 */
namespace MenuDefaults {
constexpr int kFont = 1;

constexpr const char* kStartGameId = "FET_SAN";
constexpr const char* kResumeGameId = "FEM_RES";
constexpr const char* kLoadGameId = "FET_LG";
constexpr const char* kDebugId = "FEM_DBG";
constexpr const char* kOptionsId = "FET_OPT";
constexpr const char* kQuitGameId = "FET_QG";
}

class Menu {
    int font;

public:
    Menu(int font = MenuDefaults::kFont) : font(font), activeEntry(-1) {
    }

    struct MenuEntry {
        GameString text;
        float _size;

        MenuEntry(const GameString& n, float size = 30.f)
            : text(n), _size(size) {
        }

        float getHeight() {
            return _size;
        }

        virtual void draw(int font, bool active, GameRenderer* r,
                          glm::vec2& basis) {
            TextRenderer::TextInfo ti;
            ti.font = font;
            ti.screenPosition = basis;
            ti.text = text;
            ti.size = getHeight();
            if (!active) {
                ti.baseColour = glm::u8vec3(255);
            } else {
                ti.baseColour = glm::u8vec3(255, 255, 0);
            }
            r->text.renderText(ti);
            basis.y += getHeight();
        }

        virtual void activate(float clickX, float clickY) = 0;
    };

    struct Entry : public MenuEntry {
        std::function<void(void)> callback;

        Entry(const GameString& title, std::function<void(void)> cb, float size)
            : MenuEntry(title, size), callback(cb) {
        }

        void activate(float clickX, float clickY) {
            RW_UNUSED(clickX);
            RW_UNUSED(clickY);
            callback();
        }
    };

    static std::shared_ptr<MenuEntry> lambda(const GameString& n,
                                             std::function<void(void)> callback,
                                             float size = 30.f) {
        return std::shared_ptr<MenuEntry>(new Entry(n, callback, size));
    }

    static std::shared_ptr<MenuEntry> lambda(const std::string& n,
                                             std::function<void(void)> callback,
                                             float size = 30.f) {
        return lambda(GameStringUtil::fromString(n), callback, size);
    }

    std::vector<std::shared_ptr<MenuEntry>> entries;

    /**
     * Active Entry index
     */
    int activeEntry;

    glm::vec2 offset;

    void addEntry(std::shared_ptr<MenuEntry> entry) {
        entries.push_back(entry);
    }

    void draw(GameRenderer* r) {
        glm::vec2 basis(offset);
        for (size_t i = 0; i < entries.size(); ++i) {
            bool active = false;
            if (activeEntry >= 0 && i == (unsigned)activeEntry) {
                active = true;
            }
            entries[i]->draw(font, active, r, basis);
        }
    }

    void hover(const float x, const float y) {
        glm::vec2 c(x - offset.x, y - offset.y);
        for (size_t i = 0; i < entries.size(); ++i) {
            if (c.y > 0.f && c.y < entries[i]->getHeight()) {
                activeEntry = i;
                return;
            } else {
                c.y -= entries[i]->getHeight();
            }
        }
    }

    void click(const float x, const float y) {
        glm::vec2 c(x - offset.x, y - offset.y);
        for (auto it = entries.begin(); it != entries.end(); ++it) {
            if (c.y > 0.f && c.y < (*it)->getHeight()) {
                (*it)->activate(c.x, c.y);
                return;
            } else {
                c.y -= (*it)->getHeight();
            }
        }
    }

    // Activates the menu entry at the current active index.
    void activate() {
        if (activeEntry >= 0 && (unsigned)activeEntry < entries.size()) {
            entries[activeEntry]->activate(0.f, 0.f);
        }
    }

    void move(int movement) {
        activeEntry += movement;
        if (activeEntry >= int(entries.size())) {
            activeEntry = 0;
        } else if (activeEntry < 0) {
            activeEntry = entries.size() - 1;
        }
    }
};

#endif