ray 0.1.0.pre1 → 0.1.0

data/ext/audio_source.c

@@ -0,0 +1,197 @@
+#include "ray.h"
+
+VALUE ray_cAudioSource = Qnil;
+
+say_audio_source *ray_rb2audio_source(VALUE obj) {
+  if (RAY_IS_A(obj, rb_path2class("Ray::Sound")))
+    return ray_rb2sound(obj)->src;
+  if (RAY_IS_A(obj, rb_path2class("Ray::Music")))
+    return ray_rb2music(obj)->src;
+  else {
+    rb_raise(rb_eTypeError, "can't get audio source pointer from %s",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  return NULL;
+}
+
+
+/* @return [Float] Volume of the source, between 0 and 100. */
+static
+VALUE ray_audio_source_volume(VALUE self) {
+  say_audio_source *source = ray_rb2audio_source(self);
+  return rb_float_new(say_audio_source_get_volume(source));
+}
+
+/*
+  @overload volume=(vol)
+  Sets the volume of the source.
+  @param [Float] vol The new volume of the source.
+*/
+static
+VALUE ray_audio_source_set_volume(VALUE self, VALUE value) {
+  rb_check_frozen(self);
+
+  say_audio_source *source = ray_rb2audio_source(self);
+  say_audio_source_set_volume(source, NUM2DBL(value));
+
+  return value;
+}
+
+/* @return [Float] The pitch of the source. */
+static
+VALUE ray_audio_source_pitch(VALUE self) {
+  say_audio_source *source = ray_rb2audio_source(self);
+  return rb_float_new(say_audio_source_get_pitch(source));
+}
+
+/*
+  @overload pitch=(pitch)
+    Sets the pitch of the sound.
+    @param [Float] pitch the pitch value, which makes a sound more acute
+      or grave and also affects playing speed. Defaulted to 1.
+*/
+static
+VALUE ray_audio_source_set_pitch(VALUE self, VALUE pitch) {
+  rb_check_frozen(self);
+
+  say_audio_source *source = ray_rb2audio_source(self);
+  say_audio_source_set_pitch(source, NUM2DBL(pitch));
+
+  return pitch;
+}
+
+/* @return [Ray::Vector3] The position of the source. */
+static
+VALUE ray_audio_source_pos(VALUE self) {
+  say_audio_source *source = ray_rb2audio_source(self);
+  return ray_vector3_to_rb(say_audio_source_get_pos(source));
+}
+
+/*
+  @overload pos=(pos)
+    Sets the position of the sound.
+    @param [Ray::Vector3, #to_vector3] pos The position of the source.
+*/
+static
+VALUE ray_audio_source_set_pos(VALUE self, VALUE pos) {
+  rb_check_frozen(self);
+
+  say_audio_source *source = ray_rb2audio_source(self);
+  say_audio_source_set_pos(source, ray_convert_to_vector3(pos));
+
+  return pos;
+}
+
+/*
+  @return [true, false] True if the source position is relative to the listener,
+  as opposed to being absolute.
+*/
+static
+VALUE ray_audio_source_is_relative(VALUE self) {
+  say_audio_source *source = ray_rb2audio_source(self);
+  return say_audio_source_get_relative(source) ? Qtrue : Qfalse;
+}
+
+/*
+  @overload relative=(rel)
+    Sets whether the sound should be relative.
+    @param [true, false] rel Whether the source position should be relative
+      to the listener's.
+*/
+static
+VALUE ray_audio_source_set_relative(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_audio_source *source = ray_rb2audio_source(self);
+  say_audio_source_set_relative(source, RTEST(val));
+
+  return val;
+}
+
+/* @return [Float] the source's minimal distance. */
+static
+VALUE ray_audio_source_min_distance(VALUE self) {
+  say_audio_source *source = ray_rb2audio_source(self);
+  return rb_float_new(say_audio_source_get_min_distance(source));
+}
+
+/*
+  @overload min_distance=(dist)
+    Sets the sounds minimal distance.
+    @param [Float] dist the distance beyond which the source's volume will
+      decrease. Defaulted to 1.
+*/
+static
+VALUE ray_audio_source_set_min_distance(VALUE self, VALUE dist) {
+  rb_check_frozen(self);
+
+  say_audio_source *source = ray_rb2audio_source(self);
+  say_audio_source_set_min_distance(source, NUM2DBL(dist));
+
+  return dist;
+}
+
+/* @return [Float] The source's attenuation */
+static
+VALUE ray_audio_source_attenuation(VALUE self) {
+  say_audio_source *source = ray_rb2audio_source(self);
+  return rb_float_new(say_audio_source_get_attenuation(source));
+}
+
+/*
+  @overload attenuation=(attenuation)
+    Sets the attenuation of a sound.
+    @param [Float] atenuation New attenuation factor of the sound.
+      0 will prevent the sound from being attenuated, 100 would
+      make the sound be attenuated much more quickly.
+*/
+static
+VALUE ray_audio_source_set_attenuation(VALUE self, VALUE att) {
+  rb_check_frozen(self);
+  say_audio_source_set_attenuation(ray_rb2audio_source(self), NUM2DBL(att));
+  return att;
+}
+
+/* @return [Symbol] Playing status. One of playing, paused, stopped. */
+static
+VALUE ray_audio_source_status(VALUE self) {
+  switch (say_audio_source_get_status(ray_rb2audio_source(self))) {
+  case SAY_STATUS_PAUSED:  return RAY_SYM("paused");
+  case SAY_STATUS_PLAYING: return RAY_SYM("playing");
+  case SAY_STATUS_STOPPED: return RAY_SYM("stopped");
+  }
+
+  return Qnil; /* should never happen */
+}
+
+void Init_ray_audio_source() {
+  ray_cAudioSource = rb_define_class_under(ray_mRay, "AudioSource", rb_cObject);
+
+  rb_define_method(ray_cAudioSource, "volume", ray_audio_source_volume, 0);
+  rb_define_method(ray_cAudioSource, "volume=", ray_audio_source_set_volume, 1);
+
+  rb_define_method(ray_cAudioSource, "pitch", ray_audio_source_pitch, 0);
+  rb_define_method(ray_cAudioSource, "pitch=", ray_audio_source_set_pitch, 1);
+
+  rb_define_method(ray_cAudioSource, "pos", ray_audio_source_pos, 0);
+  rb_define_method(ray_cAudioSource, "pos=",
+                   ray_audio_source_set_pos, 1);
+
+  rb_define_method(ray_cAudioSource, "relative?", ray_audio_source_is_relative,
+                   0);
+  rb_define_method(ray_cAudioSource, "relative=", ray_audio_source_set_relative,
+                   1);
+
+  rb_define_method(ray_cAudioSource, "min_distance",
+                   ray_audio_source_min_distance, 0);
+  rb_define_method(ray_cAudioSource, "min_distance=",
+                   ray_audio_source_set_min_distance, 1);
+
+  rb_define_method(ray_cAudioSource, "attenuation",
+                   ray_audio_source_attenuation, 0);
+  rb_define_method(ray_cAudioSource, "attenuation=",
+                   ray_audio_source_set_attenuation, 1);
+
+  rb_define_method(ray_cAudioSource, "status", ray_audio_source_status, 0);
+}

data/ext/buffer_renderer.c

@@ -0,0 +1,130 @@
+#include "ray.h"
+
+VALUE ray_cBufferRenderer = Qnil;
+
+GLenum ray_buf_type(VALUE type) {
+  if (type == RAY_SYM("static"))
+    return SAY_STATIC;
+  else if (type == RAY_SYM("stream"))
+    return SAY_STREAM;
+  else if (type == RAY_SYM("dynamic"))
+    return SAY_DYNAMIC;
+  else {
+    rb_raise(rb_eRuntimeError, "unknown buffer type");
+    return 0;
+  }
+}
+
+say_buffer_renderer *ray_rb2buf_renderer(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::BufferRenderer"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::BufferRenderer",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_buffer_renderer **ptr;
+  Data_Get_Struct(obj, say_buffer_renderer*, ptr);
+
+  if (!*ptr) {
+    rb_raise(rb_eRuntimeError, "trying to use an uninitialized renderer");
+  }
+
+  return *ptr;
+}
+
+static
+void ray_buffer_renderer_free(say_buffer_renderer **ptr) {
+  if (*ptr)
+    say_buffer_renderer_free(*ptr);
+}
+
+static
+VALUE ray_buffer_renderer_alloc(VALUE self) {
+  say_buffer_renderer **ptr = malloc(sizeof(say_buffer_renderer*));
+  return Data_Wrap_Struct(self, NULL, ray_buffer_renderer_free, ptr);
+}
+
+/*
+ * @overload initialize(type, vtype)
+ *   @param [Symbol] type Type of the buffer (:static, :stream, :dynamic).
+ *   @param [Class] vtype Class of vertices.
+ *
+ *   Creates a new buffer renderer.
+ *
+ *   The type argument indicates how often you may need to update the
+ *   buffer. Stream, working in most cases, means you are going to update the
+ *   stream once and use it once. Static means you will just push your data once
+ *   and use them many times. Dynamic, lastly, means your data will be both
+ *   updated and drawn often.
+ */
+static
+VALUE ray_buffer_renderer_init(VALUE self, VALUE type, VALUE vtype) {
+  rb_iv_set(self, "@drawables", rb_ary_new());
+
+  say_buffer_renderer **ptr;
+  Data_Get_Struct(self, say_buffer_renderer*, ptr);
+
+  *ptr = say_buffer_renderer_create(ray_buf_type(type),
+                                    ray_get_vtype(vtype));
+
+  return self;
+}
+
+/* Removes all the drawables from the renderer. */
+static
+VALUE ray_buffer_renderer_clear(VALUE self) {
+  say_buffer_renderer_clear(ray_rb2buf_renderer(self));
+  rb_ary_clear(rb_iv_get(self, "@drawables"));
+  return self;
+}
+
+/*
+ * @overload push(object)
+ *   @param [Ray::Drawable] object
+ *
+ *   Adds a drawable to render. It won't be rendered correctly until you call
+ *   update.
+ */
+static
+VALUE ray_buffer_renderer_push(VALUE self, VALUE obj) {
+  rb_check_frozen(self);
+
+  if (!say_buffer_renderer_push(ray_rb2buf_renderer(self),
+                                ray_rb2drawable(obj))) {
+    rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  rb_ary_push(rb_iv_get(self, "@drawables"), obj);
+
+  return self;
+}
+
+/* Upadates the buffer */
+static
+VALUE ray_buffer_renderer_update(VALUE self) {
+  say_buffer_renderer_update(ray_rb2buf_renderer(self));
+  return self;
+}
+
+/*
+ * Document-class: Ray::BufferRenderer
+ *
+ * Buffer renderers are a way to draw many drawable quickly, assuming they are
+ * not updated too often. It makes things quite faster if you have many
+ * drawables that won't need to be updated for a loong time.
+ *
+ * It simply uses drawables to fill its own buffer, and ask those drawables to
+ * draw themselves from it.
+ */
+void Init_ray_buffer_renderer() {
+  ray_cBufferRenderer = rb_define_class_under(ray_mRay, "BufferRenderer",
+                                              rb_cObject);
+
+  rb_define_alloc_func(ray_cBufferRenderer, ray_buffer_renderer_alloc);
+  rb_define_method(ray_cBufferRenderer, "initialize", ray_buffer_renderer_init,
+                   2);
+
+  rb_define_method(ray_cBufferRenderer, "clear", ray_buffer_renderer_clear, 0);
+  rb_define_method(ray_cBufferRenderer, "push", ray_buffer_renderer_push, 1);
+  rb_define_method(ray_cBufferRenderer, "update", ray_buffer_renderer_update,
+                   0);
+}

data/ext/color.c

@@ -0,0 +1,179 @@
+#include "ray.h"
+
+VALUE ray_cColor = Qnil;
+
+#define ray_color_clamp(col) ray_byte_clamp(col)
+
+say_color ray_rb2col(VALUE object) {
+  if (!RAY_IS_A(object, rb_path2class("Ray::Color"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::Color",
+             RAY_OBJ_CLASSNAME(object));
+  }
+
+  say_color *ret = NULL;
+  Data_Get_Struct(object, say_color, ret);
+
+  return *ret;
+}
+
+VALUE ray_col2rb(say_color color) {
+  say_color *ptr = malloc(sizeof(say_color));
+  *ptr = color;
+  return Data_Wrap_Struct(rb_path2class("Ray::Color"), 0, free, ptr);
+}
+
+static
+VALUE ray_color_alloc(VALUE self) {
+  say_color *ptr = malloc(sizeof(say_color));
+  return Data_Wrap_Struct(self, 0, free, ptr);
+}
+
+/*
+  @overload initialize(red, green, blue, alpha = 255)
+    Creates a new color. All the parameters must be integers between
+    0 and 255. Alpha is the transparency (255: opaque, 0: invisible).
+*/
+static
+VALUE ray_color_init(int argc, VALUE *argv, VALUE self) {
+  VALUE r, g, b, a;
+  rb_scan_args(argc, argv, "31", &r, &g, &b, &a);
+  if (a == Qnil) a = INT2FIX(255);
+
+  say_color *ret = NULL;
+  Data_Get_Struct(self, say_color, ret);
+
+  ret->r = ray_color_clamp(NUM2INT(r));
+  ret->g = ray_color_clamp(NUM2INT(g));
+  ret->b = ray_color_clamp(NUM2INT(b));
+  ret->a = ray_color_clamp(NUM2INT(a));
+
+  return Qnil;
+}
+
+static
+VALUE ray_color_init_copy(VALUE self, VALUE other) {
+  say_color *color = NULL, *source = NULL;
+  Data_Get_Struct(self,  say_color, color);
+  Data_Get_Struct(other, say_color, source);
+
+  *color = *source;
+
+  return self;
+}
+
+/* @return [Integer] Red intensity. */
+static
+VALUE ray_color_r(VALUE self) {
+  say_color *ret;
+  Data_Get_Struct(self, say_color, ret);
+
+  return INT2FIX(ret->r);
+}
+
+/* @return [Integer] Green intensity. */
+static
+VALUE ray_color_g(VALUE self) {
+  say_color *ret;
+  Data_Get_Struct(self, say_color, ret);
+
+  return INT2FIX(ret->g);
+}
+
+/* @return [Integer] Blue intensity. */
+static
+VALUE ray_color_b(VALUE self) {
+  say_color *ret;
+  Data_Get_Struct(self, say_color, ret);
+
+  return INT2FIX(ret->b);
+}
+
+/* @return [Integer] Alpha opacity. */
+static
+VALUE ray_color_a(VALUE self) {
+  say_color *ret;
+  Data_Get_Struct(self, say_color, ret);
+
+  return INT2FIX(ret->a);
+}
+
+/*
+  @overload r=(val)
+    Sets the red intensity.
+    @param [Integer] The new red intensity.
+*/
+static
+VALUE ray_color_set_r(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_color *ret;
+  Data_Get_Struct(self, say_color, ret);
+
+  ret->r = ray_color_clamp(NUM2INT(val));
+  return val;
+}
+
+/*
+  @overload r=(val)
+    Sets the red intensity.
+    @param [Integer] The new red intensity.
+*/
+static
+VALUE ray_color_set_g(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_color *ret;
+  Data_Get_Struct(self, say_color, ret);
+
+  ret->g = ray_color_clamp(NUM2INT(val));
+  return val;
+}
+
+/*
+  @overload b=(val)
+    Sets the blue intensity.
+    @param [Integer] The new blue intensity.
+*/
+static
+VALUE ray_color_set_b(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_color *ret;
+  Data_Get_Struct(self, say_color, ret);
+
+  ret->b = ray_color_clamp(NUM2INT(val));
+  return val;
+}
+
+/*
+  @overload a=(val)
+    Sets the alpha opacity.
+    @param [Integer] The new alpha opacity.
+*/
+static
+VALUE ray_color_set_a(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+
+  say_color *ret;
+  Data_Get_Struct(self, say_color, ret);
+
+  ret->a = ray_color_clamp(NUM2INT(val));
+  return val;
+}
+
+void Init_ray_color() {
+  ray_cColor = rb_define_class_under(ray_mRay, "Color", rb_cObject);
+  rb_define_alloc_func(ray_cColor, ray_color_alloc);
+  rb_define_method(ray_cColor, "initialize", ray_color_init, -1);
+  rb_define_method(ray_cColor, "initialize_copy", ray_color_init_copy, 1);
+
+  rb_define_method(ray_cColor, "r", ray_color_r, 0);
+  rb_define_method(ray_cColor, "g", ray_color_g, 0);
+  rb_define_method(ray_cColor, "b", ray_color_b, 0);
+  rb_define_method(ray_cColor, "a", ray_color_a, 0);
+
+  rb_define_method(ray_cColor, "r=", ray_color_set_r, 1);
+  rb_define_method(ray_cColor, "g=", ray_color_set_g, 1);
+  rb_define_method(ray_cColor, "b=", ray_color_set_b, 1);
+  rb_define_method(ray_cColor, "a=", ray_color_set_a, 1);
+}