ray 0.1.1 → 0.2.0

data/ext/mo.h

@@ -0,0 +1,189 @@
+#ifndef MY_OWN_HEADER_GUARD
+#define MY_OWN_HEADER_GUARD 1
+
+/**
+ * My Own utilities.
+ * (Depending on My Own mood, may mean "Mon_Ouie's utilities")
+ *
+ * Includes the data stuctures that I usually need when programming in C.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+/**
+ * Function pointer types
+ */
+
+typedef void (*mo_init)(void *dst);
+typedef void (*mo_release)(void *dst);
+typedef void (*mo_copy)(void *dst, void *src);
+typedef int  (*mo_cmp)(const void *a, const void *b);
+typedef int  (*mo_hash_func)(void *obj);
+
+/**
+ * Dynamic array.
+ */
+
+typedef struct mo_array {
+  void   *buffer;
+  size_t  size;
+  size_t  capa;
+  size_t  el_size;
+
+  mo_init    init;
+  mo_release release;
+  mo_copy    copy;
+} mo_array;
+
+mo_array *mo_array_create(size_t el_size);
+void mo_array_free(mo_array *ary);
+
+void mo_array_init(mo_array *ary, size_t el_size);
+void mo_array_release(mo_array *ary);
+
+void *mo_array_quick_at(mo_array *ary, size_t i);
+void *mo_array_at(mo_array *ary, size_t i);
+
+#define mo_array_get_ptr(ary, i, type) ( (type*)mo_array_at(ary, i))
+#define mo_array_get_as(ary, i, type)  (*(type*)mo_array_at(ary, i))
+
+void *mo_array_begin(mo_array *ary);
+void *mo_array_end(mo_array *ary);
+
+void mo_array_next(mo_array *ary, void **ptr);
+
+void mo_array_set(mo_array *ary, size_t i, void *obj);
+
+void mo_array_insert(mo_array *ary, size_t i, void *obj);
+void mo_array_push(mo_array *ary, void *obj);
+void mo_array_delete(mo_array *ary, size_t i);
+
+mo_array mo_array_dup(mo_array *ary);
+void     mo_array_copy(mo_array *dst, mo_array *src);
+
+mo_array *mo_array_qsort(mo_array *ary, mo_cmp cmp);
+
+void mo_array_resize(mo_array *ary, size_t size);
+void mo_array_reserve(mo_array *ary, size_t size);
+void mo_array_shrink(mo_array *ary);
+
+/**
+ * Doubly linked list.
+ */
+
+typedef struct mo_list {
+  struct mo_list *prev, *next;
+
+  mo_release release;
+  mo_copy    copy;
+
+  size_t el_size;
+  uint8_t data[];
+} mo_list;
+
+mo_list *mo_list_create(size_t el_size);
+void mo_list_free(mo_list *list);
+
+mo_list *mo_list_prepend(mo_list *list, void *data);
+mo_list *mo_list_insert(mo_list *list, void *data);
+mo_list *mo_list_delete(mo_list *list);
+
+void mo_list_set(mo_list *list, void *data);
+
+#define mo_list_data_ptr(list, type) ( (type*)list->data)
+#define mo_list_data_as(list, type)  (*(type*)list->data)
+
+/**
+ * Hash table.
+ */
+
+typedef struct mo_hash {
+  mo_array buffer;
+
+  mo_release release;
+  mo_copy    copy;
+
+  mo_release key_release;
+  mo_copy    key_copy;
+  mo_cmp     key_cmp;
+
+  size_t size;
+
+  size_t el_size;
+  size_t key_size;
+
+  mo_hash_func hash_of;
+} mo_hash;
+
+typedef struct mo_hash_it {
+  mo_hash *hash;
+  mo_list *list;
+  size_t   id;
+} mo_hash_it;
+
+int mo_hash_of_pointer(void *ptr);
+int mo_hash_pointer_cmp(const void *a, const void *b);
+
+int mo_hash_of_u32(void *ptr);
+int mo_hash_u32_cmp(const void *a, const void *b);
+
+int mo_hash_of_size(void *ptr);
+int mo_hash_size_cmp(const void *a, const void *b);
+
+mo_hash *mo_hash_create(size_t key_size, size_t el_size);
+void     mo_hash_free(mo_hash *hash);
+
+bool mo_hash_has_key(mo_hash *hash, void *key);
+
+void *mo_hash_get(mo_hash *hash, void *key);
+void  mo_hash_set(mo_hash *hash, void *key, void *data);
+void  mo_hash_del(mo_hash *hash, void *key);
+
+#define mo_hash_get_ptr(hash, key, type) ( (type*)mo_hash_get(hash, key))
+#define mo_hash_get_as(hash, key, type)  (*(type*)mo_hash_get(hash, key))
+
+mo_hash_it mo_hash_begin(mo_hash *hash);
+
+bool mo_hash_it_is_end(mo_hash_it *it);
+
+void *mo_hash_it_key(mo_hash_it *it);
+void *mo_hash_it_val(mo_hash_it *it);
+
+#define mo_hash_it_key_ptr(it, type) ( (type*)mo_hash_it_key(it))
+#define mo_hash_it_key_as(it, type)  (*(type*)mo_hash_it_key(it))
+
+#define mo_hash_it_val_ptr(it, type) ( (type*)mo_hash_it_val(it))
+#define mo_hash_it_val_as(it, type)  (*(type*)mo_hash_it_val(it))
+
+void mo_hash_it_next(mo_hash_it *it);
+
+/**
+ * Set (macros atop a hash table).
+ */
+
+typedef mo_hash    mo_set;
+typedef mo_hash_it mo_set_it;
+
+#define mo_set_create(size) mo_hash_create(size, 0)
+#define mo_set_free(set)    mo_hash_delete(set)
+
+#define mo_set_includes(set) mo_hash_has_key(set)
+
+#define mo_set_add(set, el) mo_hash_set(set, el, NULL)
+#define mo_set_del(set, el) mo_hash_del(set, el)
+
+#define mo_set_begin(set) mo_hash_begin(set)
+
+#define mo_set_it_is_end(it) mo_hash_it_is_end(it)
+#define mo_set_it_val(it)    mo_hash_it_key(it)
+#define mo_set_it_next(it)   mo_hash_it_next(it)
+
+#define mo_set_it_val_ptr(it, type) mo_hash_it_key_ptr(it, type)
+#define mo_set_it_val_as(it, type)  mo_hash_it_key_as(it, type)
+
+#endif /* MY OWN HEADER'S GUARD! */

data/ext/music.c

@@ -21,9 +21,9 @@ VALUE ray_music_alloc(VALUE self) {
 }
 
 /*
-  @overload open(filename)
-    @param [String] filename Name of the file containing the music to load.
-*/
+ * @overload open(filename)
+ *   @param [String] filename Name of the file containing the music to load.
+ */
 static
 VALUE ray_music_open(VALUE self, VALUE arg) {
   say_music *music = ray_rb2music(self);
@@ -48,10 +48,10 @@ VALUE ray_music_set_looping(VALUE self, VALUE val) {
 }
 
 /*
-  @overload seek(time)
-    Seeks to a specific time in the music.
-    @param [Float] time Time in seconds
-*/
+ * @overload seek(time)
+ *   Seeks to a specific time in the music
+ *   @param [Float] time Time in seconds
+ */
 static
 VALUE ray_music_seek(VALUE self, VALUE time) {
   say_music_seek(ray_rb2music(self), NUM2DBL(time));
@@ -64,7 +64,8 @@ VALUE ray_music_time(VALUE self) {
   return rb_float_new(say_music_get_time(ray_rb2music(self)));
 }
 
-/* @return [Float] Duration of the music. 0 when no buffer is attached to the
+/*
+ * @return [Float] Duration of the music. 0 when no buffer is attached to the
  *   music.
  */
 static

data/ext/pixel_bus.c

@@ -0,0 +1,349 @@
+#include "ray.h"
+
+VALUE ray_cPixelBus = Qnil;
+
+say_pixel_bus *ray_rb2pixel_bus(VALUE obj) {
+  if (!rb_obj_is_kind_of(obj, rb_path2class("Ray::PixelBus"))) {
+    rb_raise(rb_eTypeError, "can't convert %s into Ray::PixelBus",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_pixel_bus **ptr = NULL;
+  Data_Get_Struct(obj, say_pixel_bus*, ptr);
+
+  if (!*ptr)
+    rb_raise(rb_eRuntimeError, "trying to use uninitialized pixel bus");
+
+  return *ptr;
+}
+
+static
+void ray_pixel_bus_free(say_pixel_bus **ptr) {
+  if (*ptr) say_pixel_bus_free(*ptr);
+}
+
+static
+VALUE ray_pixel_bus_alloc(VALUE self) {
+  say_pixel_bus **obj = malloc(sizeof(say_pixel_bus*));
+  *obj = NULL;
+
+  return Data_Wrap_Struct(self, NULL, ray_pixel_bus_free, obj);
+}
+
+/*
+ * @overload initialize(type = :stream)
+ *   @param type (see Ray::BufferRenderer#initialize)
+ */
+static
+VALUE ray_pixel_bus_init(int argc, VALUE *argv, VALUE self) {
+  if (!say_pixel_bus_is_available())
+    rb_raise(rb_eRuntimeError, "pixel buses aren't available on this platform");
+
+  GLenum mode = SAY_STREAM;
+
+  VALUE rb_mode = Qnil;
+  rb_scan_args(argc, argv, "01", &rb_mode);
+
+  if (!NIL_P(rb_mode)) mode = ray_buf_type(rb_mode);
+
+  say_pixel_bus **ptr = NULL;
+  Data_Get_Struct(self, say_pixel_bus*, ptr);
+
+  *ptr = say_pixel_bus_create(mode);
+
+  return self;
+}
+
+/*
+ * @return [Boolean] True if pixel buses are available on this platform
+ */
+static
+VALUE ray_pixel_bus_available(VALUE self) {
+  return say_pixel_bus_is_available() ? Qtrue : Qfalse;
+}
+
+/*
+ * @return [Integer] The capacity of the pixel bus, in pixels
+ */
+static
+VALUE ray_pixel_bus_size(VALUE self) {
+  return ULONG2NUM(say_pixel_bus_get_size(ray_rb2pixel_bus(self)));
+}
+
+/*
+ * @overload resize(new_size)
+ *   Changes the capacity of the buffer
+ *
+ *   This method needs to copy the buffers content onto client memory, and is
+ *   thus signinficantly slower than {#resize!}. It should not be called if the
+ *   current content of the buffer doesn't need to be read anymore.
+ *
+ *   @param [Integer] new_size New capacity of the buffer
+ *   @see PixelBus#resize!
+ */
+static
+VALUE ray_pixel_bus_resize(VALUE self, VALUE size) {
+  say_pixel_bus_resize(ray_rb2pixel_bus(self), NUM2ULONG(size));
+  return self;
+}
+
+/*
+ * @overload resize!(new_size)
+ *   Changes the capacity of the buffer without preserving content
+ *
+ *   This method allows to quickly resize the buffer used by the pixel bus. The
+ *   content of the buffer is however undefined after this call.
+ *
+ *   @param new_size (see #resize)
+ *   @see PixelBus#resize
+ */
+static
+VALUE ray_pixel_bus_resize_fast(VALUE self, VALUE size) {
+  say_pixel_bus_resize_fast(ray_rb2pixel_bus(self), NUM2ULONG(size));
+  return self;
+}
+
+/*
+ * @overload pull(object, opts = {})
+ *   Pulls data from an object
+ *
+ *   This method reads a rectangle from an image on a target and stores it in
+ *   the buffer, at a given offset. A rect can optionally be specified for
+ *   targets. Otherwise, the whole object will be copied.
+ *
+ *   @param [Ray::Image, Ray::Target] object Object to read pixels from
+ *   @option opts [Integer] :offset (0) Offset from the buffer
+ *   @option opts [Ray::Rect, nil] :rect Rect of pixels to read for targets
+ *
+ *   @raise [RangeError] If this method attempts to write outside of the buffer
+ *     boundaries.
+ *
+ *   @return [Integer] Offset of the last read element, plus one.
+ */
+static
+VALUE ray_pixel_bus_pull(int argc, VALUE *argv, VALUE self) {
+  say_pixel_bus *bus = ray_rb2pixel_bus(self);
+
+  VALUE object, opts = Qnil;
+  rb_scan_args(argc, argv, "11", &object, &opts);
+
+  say_rect rect   = say_make_rect(0, 0, 0, 0);
+  size_t   offset = 0;
+
+  say_target *target = NULL;
+  say_image  *image  = NULL;
+
+  if (RAY_IS_A(object, rb_path2class("Ray::Target")))
+    target = ray_rb2target(object);
+  else
+    image = ray_rb2image(object);
+
+  say_vector2 size;
+
+  if (target)
+    size = say_target_get_size(target);
+  else
+    size = say_image_get_size(image);
+
+  if (!NIL_P(opts)) {
+    if (!RAY_IS_A(opts, rb_cHash)) {
+      rb_raise(rb_eTypeError, "can't convert %s into Hash",
+               RAY_OBJ_CLASSNAME(opts));
+    }
+
+    VALUE rb_rect   = rb_hash_aref(opts, RAY_SYM("rect"));
+    VALUE rb_offset = rb_hash_aref(opts, RAY_SYM("offset"));
+
+    if (target) {
+      if (!NIL_P(rb_rect))
+        rect = ray_convert_to_rect(rb_rect);
+      else
+        rect = say_make_rect(0, 0, size.x, size.y);
+    }
+
+    if (!NIL_P(rb_offset))
+      offset = NUM2ULONG(rb_offset);
+  }
+  else if (target) {
+    say_vector2 size = say_target_get_size(target);
+    rect = say_make_rect(0, 0, size.x, size.y);
+  }
+
+  size_t ret = offset + (size_t)size.x * (size_t)size.y;
+  if (ret > say_pixel_bus_get_size(bus))
+    rb_raise(rb_eRangeError, "trying to write outside of buffer boundaries");
+
+  if (target) {
+    say_pixel_bus_pull_target(bus, target, offset,
+                              rect.x, rect.y, rect.w, rect.h);
+  }
+  else {
+    say_pixel_bus_pull_image(bus, image, offset);
+  }
+
+  return ULONG2NUM(ret);
+}
+
+/*
+ * @overload push(image, opts = {})
+ *   Pushes data from the buffer onto an image
+ *
+ *   This method reads pixels from the buffer at a given offset, and copies them
+ *   onto an image. A rect of pixels that must be replaced can be
+ *   specifed. Otherwise, the whole texture will be replaced.
+ *
+ *   @param [Ray::Image] image Image to copy the rect to
+ *   @option opts :offset (see #pull)
+ *   @option opts [Ray::Rect] :rect Rect of pixels to replace in the image
+ *
+ *   @return [Ray::PixelBus] self
+ *
+ *   @raise [RangeError] If this method tries to read pixels outside of the
+ *     buffer boundaries or to write oustide of the image boundaries.
+ */
+static
+VALUE ray_pixel_bus_push(int argc, VALUE *argv, VALUE self) {
+  say_pixel_bus *bus = ray_rb2pixel_bus(self);
+
+  VALUE object, opts = Qnil;
+  rb_scan_args(argc, argv, "11", &object, &opts);
+
+  say_image *image = ray_rb2image(object);
+
+  say_vector2 size = say_image_get_size(image);
+
+  size_t offset = 0;
+  say_rect rect = say_make_rect(0, 0, size.x, size.y);
+
+  if (!NIL_P(opts)) {
+    if (!RAY_IS_A(opts, rb_cHash)) {
+      rb_raise(rb_eTypeError, "can't convert %s into Hash",
+               RAY_OBJ_CLASSNAME(opts));
+    }
+
+    VALUE rb_rect   = rb_hash_aref(opts, RAY_SYM("rect"));
+    VALUE rb_offset = rb_hash_aref(opts, RAY_SYM("offset"));
+
+    if (!NIL_P(rb_rect))
+      rect = ray_convert_to_rect(rb_rect);
+
+    if (!NIL_P(rb_offset))
+      offset = NUM2ULONG(rb_offset);
+  }
+
+  size_t ret = offset + ((size_t)rect.w * (size_t)rect.h);
+  if (ret > say_pixel_bus_get_size(bus))
+    rb_raise(rb_eRangeError, "trying to read outside of pixel bus boundaries");
+
+  if (rect.x + rect.w > size.x || rect.y + rect.h > size.y)
+    rb_raise(rb_eRangeError, "trying to write outsied of image boundaries");
+
+  say_pixel_bus_push_image(bus, image, offset, rect.x, rect.y, rect.w, rect.h);
+  return self;
+}
+
+/*
+ * Binds the pixel bus for packing and unpacking
+ */
+static
+VALUE ray_pixel_bus_bind(VALUE self) {
+  say_pixel_bus_bind(ray_rb2pixel_bus(self));
+  return self;
+}
+
+/*
+ * Binds the pixel bus for packing
+ */
+static
+VALUE ray_pixel_bus_bind_pack(VALUE self) {
+  say_pixel_bus_bind_pack(ray_rb2pixel_bus(self));
+  return self;
+}
+
+/*
+ * Binds the pixel bus for unpacking
+ */
+static
+VALUE ray_pixel_bus_bind_unpack(VALUE self) {
+  say_pixel_bus_bind_unpack(ray_rb2pixel_bus(self));
+  return self;
+}
+
+/*
+ * Unbinds any pixel bus bound for either packing or unpacking
+ */
+static
+VALUE ray_pixel_bus_unbind(VALUE self) {
+  say_pixel_bus_unbind();
+  return Qnil;
+}
+
+/*
+ * Unbinds any pixel bus bound for packing
+ */
+static
+VALUE ray_pixel_bus_unbind_pack(VALUE self) {
+  say_pixel_bus_unbind_pack();
+  return Qnil;
+}
+
+/*
+ * Unbinds any pixel bus bound for unpacking
+ */
+static
+VALUE ray_pixel_bus_unbind_unpack(VALUE self) {
+  say_pixel_bus_unbind_unpack();
+  return Qnil;
+}
+
+/*
+ * @return [Integer] The identifier of the OpenGL buffer used by the PixelBus.
+ */
+static
+VALUE ray_pixel_bus_pbo(VALUE self) {
+  return ULONG2NUM(say_pixel_bus_get_pbo(ray_rb2pixel_bus(self)));
+}
+
+/*
+ * Document-class: Ray::PixelBus
+ *
+ * Pixel buses are a way to copy pixels from a target or an image onto an image
+ * without having to copy them to client memory, and possibly
+ * asynchronously. They may unfortunately not be available on some platforms.
+ *
+ * Notice that pixels are stored from bottom to top in the buffer. You may have
+ * to rely on this when computing offsets manually.
+ */
+void Init_ray_pixel_bus() {
+  ray_cPixelBus = rb_define_class_under(ray_mRay, "PixelBus", rb_cObject);
+
+  rb_define_alloc_func(ray_cPixelBus, ray_pixel_bus_alloc);
+  rb_define_method(ray_cPixelBus, "initialize", ray_pixel_bus_init, -1);
+
+  rb_define_singleton_method(ray_cPixelBus, "available?",
+                             ray_pixel_bus_available, 0);
+
+  /* @group Manipulating buffer size */
+  rb_define_method(ray_cPixelBus, "size", ray_pixel_bus_size, 0);
+  rb_define_method(ray_cPixelBus, "resize", ray_pixel_bus_resize, 1);
+  rb_define_method(ray_cPixelBus, "resize!", ray_pixel_bus_resize_fast, 1);
+  /* @endgroup */
+
+  /* @group Copying data */
+  rb_define_method(ray_cPixelBus, "pull", ray_pixel_bus_pull, -1);
+  rb_define_method(ray_cPixelBus, "push", ray_pixel_bus_push, -1);
+  /* @endgroup */
+
+  /* @group OpenGL access */
+  rb_define_method(ray_cPixelBus, "bind", ray_pixel_bus_bind, 0);
+  rb_define_method(ray_cPixelBus, "bind_pack", ray_pixel_bus_bind_pack, 0);
+  rb_define_method(ray_cPixelBus, "bind_unpack", ray_pixel_bus_bind_unpack, 0);
+  rb_define_method(ray_cPixelBus, "pbo", ray_pixel_bus_pbo, 0);
+
+  rb_define_singleton_method(ray_cPixelBus, "unbind", ray_pixel_bus_unbind, 0);
+  rb_define_singleton_method(ray_cPixelBus, "unbind_pack",
+                             ray_pixel_bus_unbind_pack, 0);
+  rb_define_singleton_method(ray_cPixelBus, "unbind_unpack",
+                             ray_pixel_bus_unbind_unpack, 0);
+  /* @endgroup */
+}