chore: split monolithic header to proper program files, add vec2 ruby class to proxy element position etc., other cleanup

src/bindings/animation.cc

@@ -0,0 +1,187 @@
+#include "bindings/definitions.h"
+#include "window/window.h"
+
+namespace {
+void Animation_free(mrb_state *mrb, void *ptr) {
+  UNUSED(mrb);
+  uint64_t id = ((Wrapper *)ptr)->id;
+  animation_pool.release(id);
+  delete (Wrapper *)ptr;
+}
+
+const struct mrb_data_type Animation_type = {
+  "Animation", Animation_free
+};
+
+mrb_value Animation_init(mrb_state *mrb, mrb_value self) {
+  Wrapper *old = (Wrapper *)DATA_PTR(self);
+  if (old)
+    mrb_free(mrb, old);
+  mrb_data_init(self, nullptr, &Animation_type);
+  Wrapper *s = new Wrapper();
+
+  const mrb_value *frames_val;
+  mrb_int frames_len;
+  mrb_value kwargs;
+  mrb_get_args(mrb, "a|H", &frames_val, &frames_len, &kwargs);
+
+  float fps = 1.0f;
+  if (!mrb_nil_p(kwargs))
+    HASH_FLOAT(kwargs, fps, fps);
+
+  std::vector<uint64_t> frame_ids;
+  for (mrb_int i = 0; i < frames_len; i++) {
+    mrb_value frame_val = frames_val[i];
+    if (!mrb_obj_is_kind_of(mrb, frame_val, definitions::bindings.Image.cls)) {
+      mrb_raise(
+        mrb,
+        mrb_class_get(mrb, "Exception"),
+        "Expected an array of Image objects"
+      );
+      return mrb_nil_value();
+    }
+
+    Wrapper *image_wrapper = (Wrapper *)DATA_PTR(frame_val);
+    uint64_t frame_id = image_wrapper->id;
+    image_pool.use(frame_id);
+    frame_ids.push_back(frame_id);
+  }
+
+  Animation *animation = new Animation{frame_ids, fps};
+  s->id = animation_pool.acquire(animation);
+  animation_pool.use(s->id);
+
+  mrb_data_init(self, s, &Animation_type);
+  return self;
+}
+
+mrb_value static_image_animation(mrb_state *mrb, mrb_value) {
+  mrb_value image_val;
+  mrb_get_args(mrb, "o", &image_val);
+
+  if (!mrb_obj_is_kind_of(mrb, image_val, definitions::bindings.Image.cls)) {
+    mrb_raise(
+      mrb,
+      mrb_class_get(mrb, "Exception"),
+      "Expected an Image object"
+    );
+    return mrb_nil_value();
+  }
+
+  Wrapper *image_wrapper = (Wrapper *)DATA_PTR(image_val);
+  uint64_t frame_id = image_wrapper->id;
+  image_pool.use(frame_id);
+
+  std::vector<uint64_t> frames = {frame_id};
+  Animation *animation = new Animation{frames, 1.0f};
+  Wrapper *s = new Wrapper();
+  s->id = animation_pool.acquire(animation);
+  animation_pool.use(s->id);
+
+  return definitions::wrap(definitions::bindings.Animation, s->id);
+}
+
+mrb_value animation_equal(mrb_state *mrb, mrb_value self) {
+  mrb_value other;
+  mrb_get_args(mrb, "o", &other);
+
+  if (!mrb_obj_is_kind_of(mrb, other, definitions::bindings.Animation.cls))
+    return mrb_false_value();
+
+  Wrapper *self_wrapper = (Wrapper *)DATA_PTR(self);
+  uint64_t id_self = self_wrapper->id;
+  Wrapper *other_wrapper = (Wrapper *)DATA_PTR(other);
+  uint64_t id_other = other_wrapper->id;
+
+  return mrb_bool_value(id_self == id_other);
+}
+
+mrb_value animation_hash(mrb_state *, mrb_value self) {
+  Wrapper *wrapper = (Wrapper *)DATA_PTR(self);
+  return mrb_fixnum_value(wrapper->id);
+}
+
+mrb_value animation_frames_set(mrb_state *mrb, mrb_value self) {
+  const mrb_value *frames_val;
+  mrb_int frames_len;
+  mrb_get_args(mrb, "a", &frames_val, &frames_len);
+
+  Wrapper *self_wrapper = (Wrapper *)DATA_PTR(self);
+  uint64_t id = self_wrapper->id;
+  Animation *animation = animation_pool[id];
+
+  std::vector<uint64_t> new_frame_ids;
+  for (mrb_int i = 0; i < frames_len; i++) {
+    mrb_value frame_val = frames_val[i];
+    if (!mrb_obj_is_kind_of(mrb, frame_val, definitions::bindings.Image.cls)) {
+      mrb_raise(
+        mrb,
+        mrb_class_get(mrb, "Exception"),
+        "Expected an array of Image objects"
+      );
+      return mrb_nil_value();
+    }
+    Wrapper *image_wrapper = (Wrapper *)DATA_PTR(frame_val);
+    uint64_t frame_id = image_wrapper->id;
+    image_pool.use(frame_id);
+    new_frame_ids.push_back(frame_id);
+  }
+
+  // Release old frames
+  for (uint64_t frame_id : animation->frames)
+    image_pool.release(frame_id);
+
+  animation->frames = std::move(new_frame_ids);
+
+  return mrb_nil_value();
+}
+
+mrb_value animation_frames_get(mrb_state *mrb, mrb_value self) {
+  Wrapper *self_wrapper = (Wrapper *)DATA_PTR(self);
+  uint64_t id = self_wrapper->id;
+  Animation *animation = animation_pool[id];
+
+  mrb_value frames_array = mrb_ary_new_capa(mrb, animation->frames.size());
+  for (uint64_t frame_id : animation->frames) {
+    image_pool.use(frame_id);
+    mrb_value frame_obj = definitions::wrap(definitions::bindings.Image, frame_id);
+    mrb_ary_push(mrb, frames_array, frame_obj);
+  }
+
+  return frames_array;
+}
+
+mrb_value animation_fps_set(mrb_state *mrb, mrb_value self) {
+  mrb_float fps;
+  mrb_get_args(mrb, "f", &fps);
+
+  Wrapper *self_wrapper = (Wrapper *)DATA_PTR(self);
+  uint64_t id = self_wrapper->id;
+  Animation *animation = animation_pool[id];
+  animation->frame_rate = fps;
+
+  return mrb_nil_value();
+}
+
+mrb_value animation_fps_get(mrb_state *mrb, mrb_value self) {
+  Wrapper *self_wrapper = (Wrapper *)DATA_PTR(self);
+  uint64_t id = self_wrapper->id;
+  Animation *animation = animation_pool[id];
+  return mrb_float_value(mrb, animation->frame_rate);
+}
+} // namespace
+
+namespace definitions {
+void register_animation() {
+  DEF_CLASS(Animation, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
+  ADD_CLASS_METHOD(Animation, "from", static_image_animation, MRB_ARGS_REQ(1));
+  ADD_METHOD(Animation, "==", animation_equal, MRB_ARGS_REQ(1));
+  ADD_METHOD(Animation, "eql?", animation_equal, MRB_ARGS_REQ(1));
+  ADD_METHOD(Animation, "hash", animation_hash, MRB_ARGS_NONE());
+  ADD_METHOD(Animation, "fps=", animation_fps_set, MRB_ARGS_REQ(1));
+  ADD_METHOD(Animation, "fps", animation_fps_get, MRB_ARGS_NONE());
+  ADD_METHOD(Animation, "frames=", animation_frames_set, MRB_ARGS_REQ(1));
+  ADD_METHOD(Animation, "frames", animation_frames_get, MRB_ARGS_NONE());
+  bindings.Animation = {Animation_class, &Animation_type};
+}
+} // namespace definitions