ray 0.1.0.pre1 → 0.1.0

data/ext/shader.c

@@ -0,0 +1,302 @@
+#include "ray.h"
+
+VALUE ray_cShader = Qnil;
+
+VALUE ray_shader2rb(say_shader *shader, VALUE owner) {
+  VALUE obj = Data_Wrap_Struct(rb_path2class("Ray::Shader"), NULL, NULL,
+                               shader);
+  rb_iv_set(obj, "@owner", owner);
+  rb_iv_set(obj, "@locations", rb_hash_new());
+  rb_iv_set(obj, "@images", rb_hash_new());
+  return obj;
+}
+
+say_shader *ray_rb2shader(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::Shader"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::Shader",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_shader *shader = NULL;
+  Data_Get_Struct(obj, say_shader, shader);
+
+  return shader;
+}
+
+static
+VALUE ray_shader_alloc(VALUE self) {
+  say_shader *obj = say_shader_create();
+  return Data_Wrap_Struct(self, NULL, say_shader_free, obj);
+}
+
+/*
+  Make Ray's shaders forcefully use old (deprecated) style shaders.
+  This should be called before the shaders get created (in the case of targets,
+  this means before the creations of those targets)
+*/
+static
+VALUE ray_shader_use_old(VALUE self) {
+  say_shader_force_old();
+  return Qnil;
+}
+
+/*
+ * @return [true, falsue] True if geometry shaders are available
+ */
+static
+VALUE ray_shader_geometry_available(VALUE self) {
+  return say_shader_is_geometry_available() ? Qtrue : Qfalse;
+}
+
+/*
+  @overload compile_frag(src)
+    Compiles the fragment shader with a new source code.
+    @param [String] src Source code
+*/
+static
+VALUE ray_shader_compile_frag(VALUE self, VALUE src) {
+  if (!say_shader_compile_frag(ray_rb2shader(self), StringValuePtr(src))) {
+    rb_raise(rb_path2class("Ray::Shader::CompileError"), "%s",
+             say_error_get_last());
+  }
+  return self;
+}
+
+/*
+  @overload compile_vertex(src)
+    Compiles the vertex shader with a new source code.
+    @param [String] src Source code
+*/
+static
+VALUE ray_shader_compile_vertex(VALUE self, VALUE src) {
+  if (!say_shader_compile_vertex(ray_rb2shader(self), StringValuePtr(src))) {
+    rb_raise(rb_path2class("Ray::Shader::CompileError"), "%s",
+             say_error_get_last());
+  }
+
+  return self;
+}
+
+
+/*
+ * @overload compile_vertex(src)
+ *   Compiles the geometry shader with a new source code.
+ *   @param [String] src Source code
+ */
+static
+VALUE ray_shader_compile_geometry(VALUE self, VALUE src) {
+  if (!say_shader_compile_geometry(ray_rb2shader(self), StringValuePtr(src))) {
+    rb_raise(rb_path2class("Ray::Shader::CompileError"), "%s",
+             say_error_get_last());
+  }
+
+  return self;
+}
+
+/*
+ * Detaches any geomtry shader attached to the shader.
+ */
+static
+VALUE ray_shader_detach_geometry(VALUE self) {
+  say_shader_detach_geometry(ray_rb2shader(self));
+  return self;
+}
+
+/*
+  Links the shader.
+  This is required once you have compiled the vertex and fragment shaders.
+*/
+static
+VALUE ray_shader_link(VALUE self) {
+  if (!say_shader_link(ray_rb2shader(self))) {
+    rb_raise(rb_path2class("Ray::Shader::LinkError"), "%s",
+             say_error_get_last());
+  }
+
+  return Qnil;
+}
+
+/*
+  @overload apply_vertex(klass)
+    Sets the vertex layout to use. It is required to link the vertex again for
+    this change to be applied.
+
+    @param [Class] klass Class of the vertex to use with this shader.
+*/
+static
+VALUE ray_shader_apply_vertex(VALUE self, VALUE klass) {
+  say_shader *shader = ray_rb2shader(self);
+
+  if (klass == rb_path2class("Ray::Vertex"))
+    say_shader_apply_vertex_type(shader, 0);
+  else
+    say_shader_apply_vertex_type(shader, ray_get_vtype(klass));
+
+  return klass;
+}
+
+/*
+  @overload locate(name)
+    @param [String, Symbol] name Name of the attribute
+    @return [Integer, nil] Location of the attribute
+*/
+static
+VALUE ray_shader_locate(VALUE self, VALUE attr) {
+  const char *str = rb_id2name(rb_to_id(attr));
+  int loc = say_shader_locate(ray_rb2shader(self), str);
+
+  if (loc >= 0)
+    return INT2FIX(loc);
+  else
+    return Qnil;
+}
+
+/* Binds the shader program */
+static
+VALUE ray_shader_bind(VALUE self) {
+  say_shader_bind(ray_rb2shader(self));
+  return Qnil;
+}
+
+static
+VALUE ray_shader_set_vector2(VALUE self, VALUE loc, VALUE val) {
+  rb_check_frozen(self);
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, Qnil);
+  say_shader_set_vector2_loc(ray_rb2shader(self), NUM2INT(loc),
+                             ray_convert_to_vector2(val));
+  return val;
+}
+
+static
+VALUE ray_shader_set_vector3(VALUE self, VALUE loc, VALUE val) {
+  rb_check_frozen(self);
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, Qnil);
+  say_shader_set_vector3_loc(ray_rb2shader(self), NUM2INT(loc),
+                             ray_convert_to_vector3(val));
+  return val;
+}
+
+static
+VALUE ray_shader_set_color(VALUE self, VALUE loc, VALUE val) {
+  rb_check_frozen(self);
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, Qnil);
+  say_shader_set_color_loc(ray_rb2shader(self), NUM2INT(loc), ray_rb2col(val));
+  return val;
+}
+
+
+static
+VALUE ray_shader_set_array(VALUE self, VALUE loc, VALUE val) {
+  rb_check_frozen(self);
+
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, Qnil);
+
+  size_t size = RARRAY_LEN(val);
+
+  float vector[4];
+  size_t id = 0;
+  switch (size) {
+  case 4:
+    vector[id] = NUM2DBL(RAY_ARRAY_AT(val, id));
+    id++;
+  case 3:
+    vector[id] = NUM2DBL(RAY_ARRAY_AT(val, id));
+    id++;
+  case 2:
+    vector[id] = NUM2DBL(RAY_ARRAY_AT(val, id));
+    id++;
+  case 1:
+    vector[id] = NUM2DBL(RAY_ARRAY_AT(val, id));
+    id++;
+    break;
+  default:
+    rb_raise(rb_eRuntimeError, "can't send %zu-sized vector",
+             size);
+    return Qnil;
+  }
+
+  say_shader_set_floats_loc(ray_rb2shader(self), NUM2INT(loc),
+                            size, vector);
+  return val;
+}
+
+static
+VALUE ray_shader_set_numeric(VALUE self, VALUE loc, VALUE val) {
+  rb_check_frozen(self);
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, Qnil);
+  say_shader_set_float_loc(ray_rb2shader(self), NUM2INT(loc),
+                           NUM2DBL(val));
+  return val;
+}
+
+static
+VALUE ray_shader_set_image(VALUE self, VALUE loc, VALUE val) {
+  rb_check_frozen(self);
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, val);
+  say_shader_set_image_loc(ray_rb2shader(self), NUM2INT(loc),
+                           ray_rb2image(val));
+  return val;
+}
+
+static
+VALUE ray_shader_set_current_texture(VALUE self, VALUE loc) {
+  rb_check_frozen(self);
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, Qnil);
+  say_shader_set_current_texture_loc(ray_rb2shader(self), NUM2INT(loc));
+  return Qnil;
+}
+
+static
+VALUE ray_shader_set_bool(VALUE self, VALUE loc, VALUE val) {
+  rb_check_frozen(self);
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, Qnil);
+  say_shader_set_bool_loc(ray_rb2shader(self), NUM2INT(loc),
+                          RTEST(val));
+  return val;
+}
+
+static
+VALUE ray_shader_set_matrix(VALUE self, VALUE loc, VALUE val) {
+  rb_check_frozen(self);
+  rb_hash_aset(rb_iv_get(self, "@images"), loc, Qnil);
+  say_shader_set_matrix_loc(ray_rb2shader(self), NUM2INT(loc),
+                          ray_rb2matrix(val));
+  return val;
+}
+
+void Init_ray_shader() {
+  ray_cShader = rb_define_class_under(ray_mRay, "Shader", rb_cObject);
+  rb_define_class_under(ray_cShader, "CompileError", rb_eStandardError);
+  rb_define_class_under(ray_cShader, "LinkError", rb_eStandardError);
+
+  rb_define_alloc_func(ray_cShader, ray_shader_alloc);
+
+  rb_define_singleton_method(ray_cShader, "use_old!", ray_shader_use_old, 0);
+  rb_define_singleton_method(ray_cShader, "geometry_available?",
+                             ray_shader_geometry_available, 0);
+
+  rb_define_method(ray_cShader, "compile_frag", ray_shader_compile_frag, 1);
+  rb_define_method(ray_cShader, "compile_vertex", ray_shader_compile_vertex, 1);
+  rb_define_method(ray_cShader, "compile_geometry", ray_shader_compile_geometry,
+                   1);
+  rb_define_method(ray_cShader, "detach_geometry", ray_shader_detach_geometry,
+                   0);
+
+  rb_define_method(ray_cShader, "link", ray_shader_link, 0);
+
+  rb_define_method(ray_cShader, "apply_vertex", ray_shader_apply_vertex, 1);
+
+  rb_define_method(ray_cShader, "locate", ray_shader_locate, 1);
+
+  rb_define_method(ray_cShader, "set_vector2", ray_shader_set_vector2, 2);
+  rb_define_method(ray_cShader, "set_vector3", ray_shader_set_vector3, 2);
+  rb_define_method(ray_cShader, "set_color", ray_shader_set_color, 2);
+  rb_define_method(ray_cShader, "set_matrix", ray_shader_set_matrix, 2);
+  rb_define_method(ray_cShader, "set_numeric", ray_shader_set_numeric, 2);
+  rb_define_method(ray_cShader, "set_array", ray_shader_set_array, 2);
+  rb_define_method(ray_cShader, "set_image", ray_shader_set_image, 2);
+  rb_define_method(ray_cShader, "set_current_texture", ray_shader_set_current_texture, 1);
+  rb_define_method(ray_cShader, "set_bool", ray_shader_set_bool, 2);
+
+  rb_define_method(ray_cShader, "bind", ray_shader_bind, 0);
+}

data/ext/sound.c

@@ -0,0 +1,118 @@
+#include "ray.h"
+
+VALUE ray_cSound = Qnil;
+
+say_sound *ray_rb2sound(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::Sound"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::Sound",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_sound *snd;
+  Data_Get_Struct(obj, say_sound, snd);
+
+  return snd;
+}
+
+static
+VALUE ray_sound_alloc(VALUE self) {
+  say_sound *snd = say_sound_create();
+  return Data_Wrap_Struct(self, NULL, say_sound_free, snd);
+}
+
+/*
+  @overload buffer=(buf)
+    Sets a new buffer for the sound. Causes it to stop playing.
+    @param [Ray::SoundBuffer, nil] buf New buffer used by the sound.
+ */
+static
+VALUE ray_sound_set_buffer(VALUE self, VALUE buf) {
+  say_sound_set_buffer(ray_rb2sound(self), ray_rb2sound_buffer(buf));
+  rb_iv_set(self, "@buffer", buf);
+  return buf;
+}
+
+/* @return [Ray::SoundBuffer, nil] */
+static
+VALUE ray_sound_buffer(VALUE self) {
+  return rb_iv_get(self, "@buffer");
+}
+
+/* @return [true, false] True if the sound is looping */
+static
+VALUE ray_sound_is_looping(VALUE self) {
+  return say_sound_is_looping(ray_rb2sound(self)) ? Qtrue : Qfalse;
+}
+
+/* @overload looping=(val) */
+static
+VALUE ray_sound_set_looping(VALUE self, VALUE val) {
+  say_sound_set_looping(ray_rb2sound(self), RTEST(val));
+  return val;
+}
+
+/*
+  @overload seek(time)
+    Seeks to a specific time in the sound.
+    @param [Float] time Time in seconds
+*/
+static
+VALUE ray_sound_seek(VALUE self, VALUE time) {
+  say_sound_seek(ray_rb2sound(self), NUM2DBL(time));
+  return time;
+}
+
+/* @return [Float] current playing offset, in seconds */
+static
+VALUE ray_sound_time(VALUE self) {
+  return rb_float_new(say_sound_get_time(ray_rb2sound(self)));
+}
+
+/* @return [Float] Duration of the sound. 0 when no buffer is attached to the
+ *   sound.
+ */
+static
+VALUE ray_sound_duration(VALUE self) {
+  return rb_float_new(say_sound_get_duration(ray_rb2sound(self)));
+}
+
+/* Plays the sound (or resume from a pause) */
+static
+VALUE ray_sound_play(VALUE self) {
+  say_sound_play(ray_rb2sound(self));
+  return self;
+}
+
+/* Pauses the sound. Can be resumed using play. */
+static
+VALUE ray_sound_pause(VALUE self) {
+  say_sound_pause(ray_rb2sound(self));
+  return self;
+}
+
+/* Stops the sound */
+static
+VALUE ray_sound_stop(VALUE self) {
+  say_sound_stop(ray_rb2sound(self));
+  return self;
+}
+
+void Init_ray_sound() {
+  ray_cSound = rb_define_class_under(ray_mRay, "Sound", ray_cAudioSource);
+  rb_define_alloc_func(ray_cSound, ray_sound_alloc);
+
+  rb_define_method(ray_cSound, "buffer=", ray_sound_set_buffer, 1);
+  rb_define_method(ray_cSound, "buffer", ray_sound_buffer, 0);
+
+  rb_define_method(ray_cSound, "looping?", ray_sound_is_looping, 0);
+  rb_define_method(ray_cSound, "looping=", ray_sound_set_looping, 1);
+
+  rb_define_method(ray_cSound, "seek", ray_sound_seek, 1);
+  rb_define_method(ray_cSound, "time", ray_sound_time, 0);
+
+  rb_define_method(ray_cSound, "duration", ray_sound_duration, 0);
+
+  rb_define_method(ray_cSound, "play", ray_sound_play, 0);
+  rb_define_method(ray_cSound, "pause", ray_sound_pause, 0);
+  rb_define_method(ray_cSound, "stop", ray_sound_stop, 0);
+}

data/ext/sound_buffer.c

@@ -0,0 +1,75 @@
+#include "ray.h"
+
+VALUE ray_cSoundBuffer = Qnil;
+
+say_sound_buffer *ray_rb2sound_buffer(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::SoundBuffer"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::SoundBuffer",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_sound_buffer *buf;
+  Data_Get_Struct(obj, say_sound_buffer, buf);
+
+  return buf;
+}
+
+static
+VALUE ray_sound_buffer_alloc(VALUE self) {
+  say_sound_buffer *buf = say_sound_buffer_create();
+  return Data_Wrap_Struct(self, NULL, say_sound_buffer_free, buf);
+}
+
+/*
+  @overload initialize(io_or_string)
+    Loads the sound buffer out of an IO object or a string.
+ */
+static
+VALUE ray_sound_buffer_init(VALUE self, VALUE arg) {
+  say_sound_buffer *buf = ray_rb2sound_buffer(self);
+
+  if (rb_respond_to(arg, RAY_METH("read"))) {
+    arg = rb_funcall(arg, RAY_METH("read"), 0);
+
+    if (!say_sound_buffer_load_from_memory(buf, RSTRING_LEN(arg),
+                                           StringValuePtr(arg))) {
+      rb_raise(rb_eRangeError, "%s", say_error_get_last());
+    }
+  }
+  else {
+    if (!say_sound_buffer_load_from_file(buf, StringValuePtr(arg))) {
+      rb_raise(rb_eRangeError, "%s", say_error_get_last());
+    }
+  }
+
+  return self;
+}
+
+/* @return [Float] duration of the sound in seconds */
+static
+VALUE ray_sound_buffer_duration(VALUE self) {
+  return rb_float_new(say_sound_buffer_get_duration(ray_rb2sound_buffer(self)));
+}
+
+/* @return [Integer] amount of channels in the sound */
+static
+VALUE ray_sound_buffer_channel_count(VALUE self) {
+  return INT2FIX(say_sound_buffer_get_channel_count(ray_rb2sound_buffer(self)));
+}
+
+/* @return [Integer] sample rate */
+static
+VALUE ray_sound_buffer_sample_rate(VALUE self) {
+  return INT2FIX(say_sound_buffer_get_sample_rate(ray_rb2sound_buffer(self)));
+}
+
+void Init_ray_sound_buffer() {
+  ray_cSoundBuffer = rb_define_class_under(ray_mRay, "SoundBuffer", rb_cObject);
+
+  rb_define_alloc_func(ray_cSoundBuffer, ray_sound_buffer_alloc);
+  rb_define_method(ray_cSoundBuffer, "initialize", ray_sound_buffer_init, 1);
+
+  rb_define_method(ray_cSoundBuffer, "duration", ray_sound_buffer_duration, 0);
+  rb_define_method(ray_cSoundBuffer, "channel_count", ray_sound_buffer_channel_count, 0);
+  rb_define_method(ray_cSoundBuffer, "sample_rate", ray_sound_buffer_sample_rate, 0);
+}