project_misth/include/app/app.h

#ifndef APP_H
#define APP_H

#include "bindings/ruby.h"
#include "localization/localization.h"
#include "utils.h"
#include "window/window.h"

enum Type { IMAGE,
            TEXT,
            RECT };

enum ClickMode { PASS,
                 BLOCK,
                 IGNORE };

namespace app {
struct Element {
  Type type;
  Vec2<float> position = {0, 0};
  float rotation = 0;
  Vec2<float> pivot = {0, 0};
  Vec2<float> scale = {1, 1};
  float alpha = 1.0f;
  float z = 0;
  ClickMode click_mode = ClickMode::BLOCK;
  Ruby::Block on_click;

  Element(Type type) : type(type) {}
  virtual ~Element() = default;
  virtual void render(Window &window, uint64_t abs_time) = 0;
  virtual Vec2<float> size() = 0;

  void click() {
    on_click.call();
  }
};

struct EImage : Element {
  uint64_t animation_id = UINT64_MAX;

  EImage(uint64_t animation_id) : Element(Type::IMAGE), animation_id(animation_id) {}

  ~EImage() {
    if (animation_id != UINT64_MAX)
      animation_pool.release(animation_id);
  }

  Vec2<float> size() override {
    Animation &animation = *animation_pool[animation_id];
    if (animation.frames.empty())
      return {0, 0};
    return window.get_image_size(animation.frames[0]);
  }

  void render(Window &window, uint64_t abs_time) override {
    Animation &animation = *animation_pool[animation_id];
    if (animation.frames.empty())
      return;
    int frame_index = (int)((abs_time * animation.frame_rate) / 1e9) % animation.frames.size();
    window.draw(animation.frames[frame_index], position, z, rotation, pivot, scale, alpha);
  }
};

struct EText : Element {
  Localization::Key key;
  uint64_t font_id = UINT64_MAX;
  Color color = {255, 255, 255};
  std::unordered_map<std::string, std::string> params;

  ~EText() {
    if (text_id != UINT64_MAX)
      text_pool.release(text_id);
    if (font_id != UINT64_MAX)
      font_pool.release(font_id);
  }

  EText(Localization::Key key, uint64_t font_id, Color color, std::unordered_map<std::string, std::string> params)
      : Element(Type::TEXT), key(key), font_id(font_id), color(color), params(params) {}

  Vec2<float> size() override {
    if (text_id == UINT64_MAX)
      return {0, 0};
    return window.get_text_size(text_id);
  }

  void reload_text() {
    if (text_id != UINT64_MAX) {
      text_pool.release(text_id);
      text_id = UINT64_MAX;
    }
  }

  void render(Window &window, uint64_t) override {
    if (
      last_language != Localization::current_language
      || last_key != key || text_id == UINT64_MAX
      || last_color != color
      || params_changed
    ) {
      std::string localized_str = Localization::get(key, params);
      if (text_id != UINT64_MAX)
        text_pool.release(text_id);
      text_id = window.create_text(font_id, localized_str.c_str(), localized_str.size(), color);
      last_language = Localization::current_language;
      last_key = key;
      last_color = color;
      params_changed = false;
    }
    window.write(text_id, position, z, rotation, pivot, scale, alpha);
  }

private:
  uint64_t text_id = UINT64_MAX;
  Color last_color = color;
  Localization::LanguageCode last_language = UINT32_MAX;
  Localization::Key last_key = UINT16_MAX;
  bool params_changed = true;
};

struct ERect : Element {
  Vec2<float> shape = {0, 0};
  Color color = {255, 255, 255};
  Vec2<float> size() override {
    return shape;
  };

  ERect(Vec2<float> shape, Color color) : Element(Type::RECT), shape(shape), color(color) {}

  void render(Window &window, uint64_t) override {
    window.draw_rect(Rect::from(position, shape), color, z, rotation, pivot, scale, alpha);
  }
};

inline Pool<Element> element_pool;

struct Scene {
  std::vector<uint64_t> element_ids;
  Ruby::Block update;

  ~Scene() {
    for (const uint64_t &id : element_ids)
      element_pool.release(id);
  }

  void add_element(uint64_t element_id) {
    auto it = std::lower_bound(
      element_ids.begin(),
      element_ids.end(),
      element_id,
      [](auto &a, auto &b) {
        auto e_a = element_pool[a];
        auto e_b = element_pool[b];
        return e_a->z < e_b->z || (e_a->z == e_b->z && a < b);
      }
    );
    element_pool.use(element_id);
    element_ids.insert(it, element_id);
  }

  void delete_element(uint64_t element_id) {
    auto it = std::find(element_ids.begin(), element_ids.end(), element_id);
    if (it != element_ids.end()) {
      element_pool.release(element_id);
      element_ids.erase(it);
    }
  }

  void update_scene(mrb_value dt_val) {
    if (mrb_nil_p(update.proc))
      return;
    update.call(1, &dt_val);
  }

  void click(Vec2<float> position) {
    std::vector<uint64_t> clicked_elements = elements_at(position);
    for (const uint64_t &id : clicked_elements)
      element_pool[id]->click();
  }

  void render(Window &window, uint64_t abs_time) {
    for (const uint64_t &e : element_ids)
      element_pool[e]->render(window, abs_time);
  }

  std::vector<uint64_t> elements_at(Vec2<float> position) {
    std::vector<uint64_t> result;

    for (auto it = element_ids.rbegin(); it != element_ids.rend(); ++it) {
      Element *e = element_pool[*it];
      Vec2<float> size = e->size();
      Rect rect = Rect::from(size);
      if (rect.contains(world_to_local(position, e))) {
        if (e->click_mode == ClickMode::PASS) {
          result.push_back(*it);
        } else if (e->click_mode == ClickMode::BLOCK) {
          result.push_back(*it);
          break;
        } else {
          continue;
        }
      }
    }

    return result;
  }

  Vec2<float> world_to_local(Vec2<float> p, Element *e) {
    Vec2<float> size = e->size();
    Vec2<float> pivot = e->pivot * size * e->scale;
    p = p - e->position;

    float rad = -e->rotation * (M_PI / 180.0f);
    float c = cos(rad);
    float s = sin(rad);

    p = p - pivot;
    p = {
      p.x * c - p.y * s,
      p.x * s + p.y * c
    };

    p = p + pivot;
    p = p / e->scale;

    return p;
  }
};

inline Pool<Scene> scene_pool;

struct App {
  uint64_t current_scene_id = 0;
  bool running = true;
  Vec2<float> mouse_position = {-1, -1};
  std::array<bool, 600> down_keys{};
  std::vector<Key> pressed_keys;
  std::vector<Key> released_keys;
  Vec2<float> scroll = {0, 0};
  std::string text = "";
  Ruby::Block update;

  void exit() {
    running = false;
  }

  void switch_to_scene(uint64_t scene_id) {
    scene_pool.release(current_scene_id);
    scene_pool.use(scene_id);
    current_scene_id = scene_id;
  }

  App(Vec2<float> size, const char *title) {
    window.update(size, title);
    Scene *loading_scene = new Scene{};
    current_scene_id = scene_pool.acquire(loading_scene);
  }

  void set_fps(float fps) {
    this->fps = fps;
    target_frame_time = 1e9 / fps;
  }

  uint64_t get_fps() const {
    return fps;
  }

  void loop() {
    uint64_t frame_start = window.get_time();
    uint64_t frame_end = window.get_time();
    uint64_t previous_frame_end = 0;

    while (running) {
      frame_start = window.get_time();
      uint64_t frame_time = frame_start - frame_end;

      if (frame_time <= target_frame_time) {
        struct timespec req;
        req.tv_sec = 0;
        req.tv_nsec = target_frame_time - frame_time;
        nanosleep(&req, nullptr);
      }

      previous_frame_end = frame_end;
      frame_end = window.get_time();

      float dt = frame_end - previous_frame_end;

      Scene *scene = scene_pool[current_scene_id];

      pressed_keys.clear();
      released_keys.clear();
      scroll = {0, 0};
      text = "";

      Event e;
      while (window.poll(e)) {
        switch (e.type) {
        case Event::QUIT:
          running = false;
          break;
        case Event::MOUSE_BUTTON_DOWN:
          scene->click(e.mouse_button.position);
          down_keys[e.mouse_button.button] = true;
          pressed_keys.push_back(e.mouse_button.button);
          break;
        case Event::MOUSE_BUTTON_UP:
          down_keys[e.mouse_button.button] = false;
          released_keys.push_back(e.mouse_button.button);
          break;
        case Event::MOUSE_MOVE:
          mouse_position = e.mouse_move.position;
          break;
        case Event::MOUSE_LEAVE:
          mouse_position = {-1, -1};
          break;
        case Event::KEY_DOWN:
          down_keys[e.key.key] = true;
          pressed_keys.push_back(e.key.key);
          break;
        case Event::KEY_UP:
          down_keys[e.key.key] = false;
          released_keys.push_back(e.key.key);
          break;
        case Event::SCROLL:
          scroll = e.scroll;
          break;
        case Event::TEXT_INPUT:
          text += *e.text_input;
          delete e.text_input;
          break;
        default:
          break;
        }
      }

      int ai = mrb_gc_arena_save(Ruby::mrb);
      mrb_value dt_val = mrb_float_value(Ruby::mrb, dt / 1e9);
      update.call(1, &dt_val);
      scene->update_scene(dt_val);
      mrb_gc_arena_restore(Ruby::mrb, ai);

      scene->render(window, window.get_time());

      window.render();

      window.clear();
    }
  }

private:
  uint64_t fps = 60;
  uint64_t target_frame_time = 1e9 / fps;
};
} // namespace app

inline app::App *app_ = nullptr;

#endif