UI.hpp

//
// Created by jibbo on 4/25/21.
//
 
#ifndef ENGINE_PROJ_UI_HPP
#define ENGINE_PROJ_UI_HPP
 
#include <utility>
 
#include "MeshRenderer.hpp"
#include "Components.hpp"
#include "Input.hpp"
#include "Font.hpp"
#include "Jobs.hpp"
 
namespace Engine {
 
  struct UIButton;
 
  struct ButtonHook : CollisionHook {
    UIButton * button; 
 
    explicit ButtonHook(UIButton *button) : button(button) {};
    void processCollision(const Ref<PhysicsEntity>& other) override;
  };
 
  struct UIElement : MeshRenderer {
    UIElement() = default;
 
    explicit UIElement(const Ref<Texture>& tex) {
      setImage(tex);
    }
 
    void setImage(const Ref<Texture>& tex) {
      texture = tex;
      map = tex->getDefaultMapping();
      setSize(texture->getWidth(), texture->getHeight());
      queueVisualUpdate();
    }
 
    void setImage(const Ref<TextureLookup>& lookup) {
      texture = lookup->tex;
      map = lookup->map;
      setSize(lookup->width, lookup->height);
      queueVisualUpdate();
    }
 
 
    void setSize(float width, float height) {
      this->width = width;
      this->height = height;
      queueVisualUpdate();
    }
 
    virtual void update() {
      updateVisual();
    };
 
    void queueVisualUpdate() {
      visualUpdate = true;
    }
 
    virtual void updateVisual() {
      if (!visualUpdate) {
        return;
      }
 
      glm::mat4 mat{1};
      glm::vec3 pos;
      switch (origin) {
        case Allignment::TOP_LEFT:
          pos = {.5f, .5f, .0f};
          break;
        case Allignment::TOP:
          pos = {.0f, .5f, .0f};
          break;
        case Allignment::TOP_RIGHT:
          pos = {-.5f, .5f, .0f};
          break;
 
        case Allignment::LEFT:
          pos = {.5f, .0f, .0f};
          break;
        case Allignment::CENTER:
          pos = {.0f, .0f, .0f};
          break;
        case Allignment::RIGHT:
          pos = {-.5f, .0f, .0f};
          break;
 
        case Allignment::BOTTOM_LEFT:
          pos = {.5f, -.5f, .0f};
          break;
        case Allignment::BOTTOM:
          pos = {.0f, -.5f, .0f};
          break;
        case Allignment::BOTTOM_RIGHT:
          pos = {.5f, -.5f, .0f};
          break;
      }
 
      mat *= glm::translate(pos);
      mat *= glm::scale(glm::vec3{width, height, 0.f});
      if (mesh == nullptr) {
        mesh = CreateRef<Mesh>();
      }
 
      mesh->verts = Mesh::quad(mat);
 
      if (collider != nullptr) {
        collider->verts = Mesh::quadVerts(mat);
      }
 
      visualUpdate = false;
    }
 
    static void Update(const Scene& scene) {
      for (auto e : scene.GetECS().GetEntitiesWith<UIElement>()) {
        scene.GetECS().GetComponent<UIElement>(e)->update();
      }
    }
 
    Ref<VertexCollider2D> collider = nullptr; 
    Allignment origin = CENTER; 
  private:
    float width = 0, height = 0;
    float x = 0, y = 0;
    bool visualUpdate = false;
  };
 
  enum ButtonState {
    DEFAULT, HOVER, PRESS
  };
 
  struct UIText : UIElement {
    Ref<Font> font;
    std::string text;
 
    UIText(const Ref<Engine::Font> &font, const std::string& text, Allignment origin = CENTER) : font(font) {
      this->origin = origin;
      setText(text);
    }
 
    void setText(const std::string& newString) {
      if (text != newString) {
        text = newString;
        font->renderText(newString, this, origin, 0.5f);
      }
    }
  };
 
  struct UIButton : UIElement {
    func clickFunc; 
    ButtonState state = DEFAULT; 
    ButtonState nextState = DEFAULT; 
    std::unordered_map<ButtonState, Ref<TextureLookup>> stateLookup 
      = std::unordered_map<ButtonState, Ref<TextureLookup>>();
 
    UIButton() {
      collider = CreateRef<VertexCollider2D>();
      collider->hook = CreateRef<ButtonHook>(this);
    }
 
    void loadTexture(const ButtonState key, const Ref<TextureLookup> &texture) {
      stateLookup[key] = texture;
      if (key == state) {
        setImage(stateLookup[key]);
      }
    }
 
    void setCallback(func f) {
      clickFunc = std::move(f);
    }
 
    void preformCallback() const {
      clickFunc();
    }
 
    void setState(ButtonState next) {
      this->nextState = next;
      if (this->state == next) {
        return;
      }
      this->state = next;
      setImage(stateLookup[next]);
    }
 
 
    void updateVisual() override {
      if (nextState != state) {
        setState(nextState);
        queueVisualUpdate();
      }
      UIElement::updateVisual();
    }
 
    void update() override {
      UIElement::update();
      nextState = DEFAULT;
    }
  };
}
 
#endif //ENGINE_PROJ_UI_HPP