ray 0.1.0.pre1 → 0.1.0

data/ext/ray.c

@@ -0,0 +1,59 @@
+#include "ray.h"
+
+VALUE ray_mRay = Qnil;
+
+static
+VALUE ray_clean_up(VALUE self) {
+  say_clean_up();
+  return Qnil;
+}
+
+/* @return [Ray::Vector2] Size of the screen */
+static
+VALUE ray_screen_size(VALUE self) {
+  return ray_vector2_to_rb(say_make_vector2(say_imp_screen_get_width(),
+                                            say_imp_screen_get_height()));
+}
+
+void Init_ray_ext() {
+#ifdef SAY_OSX
+  say_osx_flip_pool();
+#endif
+
+  ray_mRay = rb_define_module("Ray");
+
+  rb_define_private_method(rb_singleton_class(ray_mRay),
+                           "_clean_up!", ray_clean_up, 0);
+
+  rb_define_module_function(ray_mRay, "screen_size", ray_screen_size, 0);
+
+  Init_ray_vector();
+  Init_ray_rect();
+  Init_ray_matrix();
+  Init_ray_color();
+  Init_ray_vertex();
+  Init_ray_gl();
+  Init_ray_gl_vertex();
+  Init_ray_int_array();
+  Init_ray_gl_buffer();
+  Init_ray_gl_index_buffer();
+  Init_ray_image();
+  Init_ray_font();
+  Init_ray_shader();
+  Init_ray_view();
+  Init_ray_drawable();
+  Init_ray_polygon();
+  Init_ray_sprite();
+  Init_ray_text();
+  Init_ray_buffer_renderer();
+  Init_ray_target();
+  Init_ray_window();
+  Init_ray_image_target();
+  Init_ray_input();
+  Init_ray_event();
+  Init_ray_audio();
+  Init_ray_sound_buffer();
+  Init_ray_audio_source();
+  Init_ray_sound();
+  Init_ray_music();
+}

data/ext/ray.h

@@ -0,0 +1,168 @@
+#ifndef RAY_H_
+#define RAY_H_
+
+#include "ruby.h"
+#include "say.h"
+
+#ifdef __cplusplus
+extern "C" {
+# if 0
+}
+# endif
+#endif
+
+typedef struct {
+  say_drawable *drawable;
+  VALUE         obj;
+
+  size_t vsize;
+} ray_drawable;
+
+/* Classes and modules */
+extern VALUE ray_mRay;
+
+extern VALUE ray_cVector2;
+extern VALUE ray_cVector3;
+extern VALUE ray_cRect;
+extern VALUE ray_cMatrix;
+extern VALUE ray_cColor;
+extern VALUE ray_cVertex;
+extern VALUE ray_mGL;
+extern VALUE ray_cGLVertex;
+extern VALUE ray_cIntArray;
+extern VALUE ray_cGLBuffer;
+extern VALUE ray_cGLIndexBuffer;
+extern VALUE ray_cImage;
+extern VALUE ray_cFont;
+extern VALUE ray_cShader;
+extern VALUE ray_cView;
+extern VALUE ray_cDrawable;
+extern VALUE ray_cPolygon;
+extern VALUE ray_cSprite;
+extern VALUE ray_cText;
+extern VALUE ray_cBufferRenderer;
+extern VALUE ray_cTarget;
+extern VALUE ray_cWindow;
+extern VALUE ray_cImageTarget;
+extern VALUE ray_cInput;
+extern VALUE ray_cEvent;
+extern VALUE ray_mAudio;
+extern VALUE ray_cSoundBuffer;
+extern VALUE ray_cAudioSource;
+extern VALUE ray_cSound;
+extern VALUE ray_cMusic;
+
+/* Macros for Ruby's C API */
+
+#define RAY_IS_A(obj, klass) (RTEST(rb_obj_is_kind_of(obj, klass)))
+
+#define RAY_OBJ_CLASSNAME(obj) (rb_class2name(rb_class_of(obj)))
+
+#define RAY_SYM(string) (ID2SYM(rb_intern(string)))
+#define RAY_METH(string) (rb_intern(string))
+
+#define RAY_ARRAY_AT(ary, i) (rb_funcall(ary, RAY_METH("[]"), 1, INT2FIX(i)))
+
+void Init_ray_ext();
+void Init_ray_vector();
+void Init_ray_rect();
+void Init_ray_matrix();
+void Init_ray_color();
+void Init_ray_vertex();
+void Init_ray_gl();
+void Init_ray_gl_vertex();
+void Init_ray_int_array();
+void Init_ray_gl_buffer();
+void Init_ray_gl_index_buffer();
+void Init_ray_image();
+void Init_ray_font();
+void Init_ray_shader();
+void Init_ray_view();
+void Init_ray_drawable();
+void Init_ray_polygon();
+void Init_ray_sprite();
+void Init_ray_text();
+void Init_ray_buffer_renderer();
+void Init_ray_target();
+void Init_ray_window();
+void Init_ray_image_target();
+void Init_ray_input();
+void Init_ray_event();
+void Init_ray_audio();
+void Init_ray_sound_buffer();
+void Init_ray_audio_source();
+void Init_ray_sound();
+void Init_ray_music();
+
+/* Conversions */
+
+say_vector2 *ray_rb2vector2_ptr(VALUE obj);
+say_vector2 ray_rb2vector2(VALUE obj);
+say_vector2 ray_convert_to_vector2(VALUE obj);
+VALUE ray_vector2_to_rb(say_vector2 obj);
+
+say_vector3 *ray_rb2vector3_ptr(VALUE obj);
+say_vector3 ray_rb2vector3(VALUE obj);
+say_vector3 ray_convert_to_vector3(VALUE obj);
+VALUE ray_vector3_to_rb(say_vector3 obj);
+
+say_rect *ray_rb2rect_ptr(VALUE obj);
+say_rect ray_rb2rect(VALUE obj);
+say_rect ray_convert_to_rect(VALUE obj);
+VALUE ray_rect2rb(say_rect rect);
+
+VALUE ray_matrix2rb(say_matrix *matrix);
+say_matrix *ray_rb2matrix(VALUE matrix);
+
+VALUE ray_view2rb(say_view *view);
+say_view *ray_rb2view(VALUE self);
+
+say_color ray_rb2col(VALUE object);
+VALUE ray_col2rb(say_color color);
+
+say_vertex *ray_rb2vertex(VALUE obj);
+
+say_image *ray_rb2image(VALUE obj);
+say_font *ray_rb2font(VALUE obj);
+
+VALUE ray_shader2rb(say_shader *shader, VALUE owner);
+say_shader *ray_rb2shader(VALUE obj);
+
+say_drawable *ray_rb2drawable(VALUE obj);
+say_polygon *ray_rb2polygon(VALUE obj);
+say_sprite *ray_rb2sprite(VALUE obj);
+say_text *ray_rb2text(VALUE obj);
+
+say_target *ray_rb2target(VALUE obj);
+say_window *ray_rb2window(VALUE obj);
+say_image_target *ray_rb2image_target(VALUE obj);
+
+say_event *ray_rb2event(VALUE obj);
+
+say_input *ray_rb2input(VALUE obj);
+VALUE ray_input2rb(say_input *input, VALUE owner);
+
+say_sound_buffer *ray_rb2sound_buffer(VALUE obj);
+
+say_audio_source *ray_rb2audio_source(VALUE obj);
+say_sound *ray_rb2sound(VALUE obj);
+say_music *ray_rb2music(VALUE obj);
+
+say_array *ray_rb2int_array(VALUE obj);
+
+say_buffer_renderer *ray_rb2buf_renderer(VALUE obj);
+
+uint8_t ray_byte_clamp(int color);
+
+VALUE ray_get_vertex_class(size_t id);
+size_t ray_get_vtype(VALUE class);
+GLenum ray_buf_type(VALUE type);
+
+#ifdef __cplusplus
+# if 0
+{
+# endif
+}
+#endif
+
+#endif

data/ext/rect.c

@@ -0,0 +1,255 @@
+#include "ray.h"
+
+VALUE ray_cRect = Qnil;
+
+say_rect *ray_rb2rect_ptr(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::Rect"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::Rect",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_rect *rect;
+  Data_Get_Struct(obj, say_rect, rect);
+
+  return rect;
+}
+
+say_rect ray_rb2rect(VALUE obj) {
+  return *ray_rb2rect_ptr(obj);
+}
+
+say_rect ray_convert_to_rect(VALUE obj) {
+  obj = rb_funcall(obj, RAY_METH("to_rect"), 0);
+  return ray_rb2rect(obj);
+}
+
+VALUE ray_rect2rb(say_rect rect) {
+  say_rect *obj = malloc(sizeof(say_rect));
+  *obj = rect;
+
+  return Data_Wrap_Struct(ray_cRect, 0, free, obj);
+}
+
+static
+VALUE ray_alloc_rect(VALUE self) {
+  say_rect *rect = malloc(sizeof(say_rect));
+  *rect = say_make_rect(0, 0, 0, 0);
+
+  return Data_Wrap_Struct(self, 0, free, rect);
+}
+
+/*
+  @overload initialize(x, y)
+    Creates a new rect with size set to 0, 0.
+
+  @overload initialize(x, y, w, h)
+    Creates a new rect with the specified size.
+
+  @overload initialize(hash)
+    Creates a new rect according to the keys specified in hash.
+
+    @option hash [Float] :x
+    @option hash [Float] :y
+    @option hash [Float] (0) :width
+    @option hash [Float] (0) :height required if width is set
+
+    @option hash [Float] (0) :w alias for :width
+    @option hash [Float] (0) :h alias for :height
+*/
+static
+VALUE ray_init_rect(int argc, VALUE *argv, VALUE self) {
+  VALUE x_or_hash, y, w, h;
+  rb_scan_args(argc, argv, "13", &x_or_hash, &y, &w, &h);
+
+  int type = TYPE(x_or_hash);
+  if (type == T_HASH) {
+    if (!NIL_P(y)) {
+      rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
+               argc);
+    }
+
+    VALUE hash = x_or_hash;
+
+    x_or_hash = rb_hash_aref(hash, RAY_SYM("x"));
+    y = rb_hash_aref(hash, RAY_SYM("y"));
+
+    w = rb_hash_aref(hash, RAY_SYM("width"));
+    h = rb_hash_aref(hash, RAY_SYM("height"));
+
+    if (NIL_P(w)) w = rb_hash_aref(hash, RAY_SYM("w"));
+    if (NIL_P(h)) h = rb_hash_aref(hash, RAY_SYM("h"));
+
+    if (NIL_P(y)) {
+      rb_raise(rb_eArgError, "missing option :y");
+    }
+
+    if (!NIL_P(w) && NIL_P(h)) {
+      rb_raise(rb_eArgError, "missing option :height");
+    }
+  }
+
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  rect->x = NUM2DBL(x_or_hash);
+  rect->y = NUM2DBL(y);
+
+  if (!NIL_P(w)) {
+    rect->w = NUM2DBL(w);
+    rect->h = NUM2DBL(h);
+  }
+  else {
+    rect->w = 0;
+    rect->h = 0;
+  }
+
+  return Qnil;
+}
+
+static
+VALUE ray_init_rect_copy(VALUE self, VALUE other) {
+  say_rect *rect = NULL, *source = NULL;
+  Data_Get_Struct(self,  say_rect, rect);
+  Data_Get_Struct(other, say_rect, source);
+
+  *rect = *source;
+  return self;
+}
+
+/* @return [Float] X position of the rect */
+static
+VALUE ray_rect_x(VALUE self) {
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  return rb_float_new(rect->x);
+}
+
+/* @return [Float] Y position of the rect */
+static
+VALUE ray_rect_y(VALUE self) {
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  return rb_float_new(rect->y);
+}
+
+/* @return [Float] width of the rect */
+static
+VALUE ray_rect_w(VALUE self) {
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  return rb_float_new(rect->w);
+}
+
+/* @return [Float] height of the rect */
+static
+VALUE ray_rect_h(VALUE self) {
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  return rb_float_new(rect->h);
+}
+
+/*
+  @overload x=(val)
+    Sets the x position of the rect
+
+    @param [Float] val The new x position of the rect
+    @return [void]
+*/
+static
+VALUE ray_rect_set_x(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  rect->x = NUM2DBL(val);
+
+  return val;
+}
+
+/*
+  @overload y=(val)
+    Changes the y position of the rect.
+
+    @param [Float] val The new y position of the rect.
+    @return [void]
+*/
+static
+VALUE ray_rect_set_y(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  rect->y = NUM2DBL(val);
+
+  return val;
+}
+
+/*
+  @overload w=(val)
+    Changes the with of the rect
+
+    @param [Float] val The new width of the rect.
+    @return [void]
+*/
+static
+VALUE ray_rect_set_w(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  rect->w = NUM2DBL(val);
+
+  return val;
+}
+
+/*
+  @overload h=(val)
+    Sets the height of the rect
+
+    @param [Float] val The new height of the rect.
+    @return [void]
+*/
+static
+VALUE ray_rect_set_h(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_rect *rect;
+  Data_Get_Struct(self, say_rect, rect);
+
+  rect->h = NUM2DBL(val);
+
+  return val;
+}
+
+/*
+  Document-class: Ray::Rect
+
+  Rects are used to represent a part of an image, using
+  two attributes to represent its position, and two
+  others to represent its size.
+*/
+
+void Init_ray_rect() {
+  ray_cRect = rb_define_class_under(ray_mRay, "Rect", rb_cObject);
+
+  rb_define_alloc_func(ray_cRect, ray_alloc_rect);
+  rb_define_method(ray_cRect, "initialize", ray_init_rect, -1);
+  rb_define_method(ray_cRect, "initialize_copy", ray_init_rect_copy, 1);
+
+  rb_define_method(ray_cRect, "x", ray_rect_x, 0);
+  rb_define_method(ray_cRect, "y", ray_rect_y, 0);
+  rb_define_method(ray_cRect, "width", ray_rect_w, 0);
+  rb_define_method(ray_cRect, "height", ray_rect_h, 0);
+
+  rb_define_method(ray_cRect, "x=", ray_rect_set_x, 1);
+  rb_define_method(ray_cRect, "y=", ray_rect_set_y, 1);
+  rb_define_method(ray_cRect, "width=", ray_rect_set_w, 1);
+  rb_define_method(ray_cRect, "height=", ray_rect_set_h, 1);
+}