mrb_rect.cxx

#include <mruby.h>
#include <mruby/class.h>
#include <mruby/data.h>
#include <mruby/numeric.h>
#include <SFML/Graphics/Rect.hpp>

static struct RClass *int_rect_class;
static struct RClass *float_rect_class;

static inline mrb_value
mrb_numeric_value(mrb_state *mrb, float value)
{
  return mrb_float_value(mrb, (mrb_float)value);
}

static inline mrb_value
mrb_numeric_value(mrb_state *mrb, int value)
{
  return mrb_fixnum_value((mrb_int)value);
}

static inline void
mrb_get_arg(mrb_state *mrb, mrb_float *value)
{
  mrb_get_args(mrb, "f", value);
}

static inline void
mrb_get_arg(mrb_state *mrb, mrb_int *value)
{
  mrb_get_args(mrb, "i", value);
}

template <typename T>
static void
rect_free(mrb_state *mrb, void *ptr)
{
  if (ptr) {
    sf::Rect<T> *rect = (sf::Rect<T>*)ptr;
    delete rect;
  }
}

extern "C" const struct mrb_data_type mrb_sfml_int_rect_type = { "sf::IntRect", rect_free<int> };
extern "C" const struct mrb_data_type mrb_sfml_float_rect_type = { "sf::FloatRect", rect_free<float> };

template <typename T> static inline sf::Rect<T>* get_rect(mrb_state *mrb, mrb_value self);

template <> sf::Rect<float>*
get_rect<float>(mrb_state *mrb, mrb_value self)
{
  return (sf::Rect<float>*)mrb_data_get_ptr(mrb, self, &mrb_sfml_float_rect_type);
}

template <> sf::Rect<int>*
get_rect<int>(mrb_state *mrb, mrb_value self)
{
  return (sf::Rect<int>*)mrb_data_get_ptr(mrb, self, &mrb_sfml_int_rect_type);
}

static mrb_value
float_rect_initialize(mrb_state *mrb, mrb_value self)
{
  sf::Rect<int> *rect;
  mrb_value o1;
  mrb_value o2;
  mrb_value o3;
  mrb_value o4;
  mrb_int argc = mrb_get_args(mrb, "oo|oo", &o1, &o2, &o3, &o4);
  if (argc == 0) {
    rect = new sf::Rect<int>();
  } else if (argc == 2) {
    rect = new sf::Rect<int>();
  } else if (argc == 4) {
    rect = new sf::Rect<int>();
  } else {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "Expected, 0, 2 or 4");
    return self;
  }
  mrb_data_init(self, rect, &mrb_sfml_int_rect_type);
  return self;
}

static mrb_value
int_rect_initialize(mrb_state *mrb, mrb_value self)
{
  sf::Rect<float> *rect;
  rect = new sf::Rect<float>();
  mrb_data_init(self, rect, &mrb_sfml_float_rect_type);
  return self;
}

template <typename T>
static mrb_value
rect_get_left(mrb_state *mrb, mrb_value self)
{
  return mrb_numeric_value(mrb, get_rect<T>(mrb, self)->left);
}

template <typename T>
static mrb_value
rect_get_top(mrb_state *mrb, mrb_value self)
{
  return mrb_numeric_value(mrb, get_rect<T>(mrb, self)->top);
}

template <typename T>
static mrb_value
rect_get_width(mrb_state *mrb, mrb_value self)
{
  return mrb_numeric_value(mrb, get_rect<T>(mrb, self)->width);
}

template <typename T>
static mrb_value
rect_get_height(mrb_state *mrb, mrb_value self)
{
  return mrb_numeric_value(mrb, get_rect<T>(mrb, self)->height);
}

template <typename T, typename MT>
static mrb_value
rect_set_top(mrb_state *mrb, mrb_value self)
{
  MT arg;
  mrb_get_arg(mrb, &arg);
  get_rect<T>(mrb, self)->top = (T)arg;
  return self;
}

template <typename T, typename MT>
static mrb_value
rect_set_left(mrb_state *mrb, mrb_value self)
{
  MT arg;
  mrb_get_arg(mrb, &arg);
  get_rect<T>(mrb, self)->left = (T)arg;
  return self;
}

template <typename T, typename MT>
static mrb_value
rect_set_width(mrb_state *mrb, mrb_value self)
{
  MT arg;
  mrb_get_arg(mrb, &arg);
  get_rect<T>(mrb, self)->width = (T)arg;
  return self;
}

template <typename T, typename MT>
static mrb_value
rect_set_height(mrb_state *mrb, mrb_value self)
{
  MT arg;
  mrb_get_arg(mrb, &arg);
  get_rect<T>(mrb, self)->height = (T)arg;
  return self;
}

//template <typename T, typename MT>
//static mrb_value
//rect_contains(mrb_state *mrb, mrb_value self)
//{
//  mrb_value a, b;
//  mrb_int argc = mrb_get_args(mrb, "o|o", &a, &b);
//  if (argc == 1) {
//  } else {
//    return mrb_bool_value(mrb, get_rect((T)0, mrb, self)->contains(a, b));
//  }
//}

//template <typename T, typename MT>
//static mrb_value
//rect_intersects(mrb_state *mrb, mrb_value self)
//{
//  mrb_value a, b;
//  mrb_int argc = mrb_get_args(mrb, "o|o", &a, &b);
//  if (argc == 1) {
//  } else {
//    return mrb_bool_value(mrb, get_rect((T)0, mrb, self)->intersects(a, b));
//  }
//}

template <typename T, typename MT>
static void
rect_bind_class(mrb_state *mrb, struct RClass *cls)
{
  mrb_define_method(mrb, cls, "top",        rect_get_top<T>,        MRB_ARGS_NONE());
  mrb_define_method(mrb, cls, "left",       rect_get_left<T>,       MRB_ARGS_NONE());
  mrb_define_method(mrb, cls, "width",      rect_get_width<T>,      MRB_ARGS_NONE());
  mrb_define_method(mrb, cls, "height",     rect_get_height<T>,     MRB_ARGS_NONE());
  mrb_define_method(mrb, cls, "top=",       rect_set_top<T, MT>,    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, cls, "left=",      rect_set_left<T, MT>,   MRB_ARGS_REQ(1));
  mrb_define_method(mrb, cls, "width=",     rect_set_width<T, MT>,  MRB_ARGS_REQ(1));
  mrb_define_method(mrb, cls, "height=",    rect_set_height<T, MT>, MRB_ARGS_REQ(1));
  //mrb_define_method(mrb, cls, "contains?",  rect_contains<T, MT>,   MRB_ARGS_ARG(1,1));
}

extern "C" void
mrb_sfml_rect_init_bind(mrb_state *mrb, struct RClass *mod)
{
  int_rect_class = mrb_define_class_under(mrb, mod, "IntRect", mrb->object_class);
  MRB_SET_INSTANCE_TT(int_rect_class, MRB_TT_DATA);
  mrb_define_method(mrb, int_rect_class, "initialize", int_rect_initialize, MRB_ARGS_ANY());
  rect_bind_class<int, mrb_int>(mrb, int_rect_class);

  float_rect_class = mrb_define_class_under(mrb, mod, "FloatRect", mrb->object_class);
  MRB_SET_INSTANCE_TT(float_rect_class, MRB_TT_DATA);
  mrb_define_method(mrb, float_rect_class, "initialize", float_rect_initialize, MRB_ARGS_ANY());
  rect_bind_class<float, mrb_float>(mrb, float_rect_class);
}