ray 0.0.1 → 0.1.0.pre1

data/.yardopts

@@ -0,0 +1,4 @@
+--private
+-e ./yard_ext.rb
+-
+guide.md

data/README.md

@@ -4,24 +4,24 @@
 
     class HelloScene < Ray::Scene
       scene_name :hello
-  
+
       def setup
-        @font = font(path_of("VeraMono.ttf"), 12)
+        @font = font("VeraMono.ttf")
       end
-  
+
       def render(win)
-        @font.draw("Hello world!", :on => win, :at => [0, 0])
+        @font.draw("Hello world!", :on => win, :at => [0, 0], :size => 12)
       end
     end
 
     class HelloWorld < Ray::Game
       def initialize
         super("Hello world!")
-    
+
         HelloScene.bind(self)
         push_scene :hello
       end
-  
+
       def register
         add_hook :quit, method(:exit!)
       end
@@ -35,28 +35,24 @@
       register do
         add_hook :quit, method(:exit!)
       end
-  
+
       scene :hello do
-        @font = font(path_of("VeraMono.ttf"), 12)
-    
+        @font = font("VeraMono.ttf")
+
         render do |win|
-          @font.draw("Hello world", :on => win, :at => [0, 0])
+          @font.draw("Hello world", :on => win, :at => [0, 0], :size => 12)
         end
       end
-  
+
       push_scene :hello
     end
-# Installation
-Run the following command:
 
-    gem install ray
-
-This requires the SDL to be installed. SDL_TTF, SDL_image, SDL_gfx, and
-SDL_mixer are also needed for several features, though you can install ray
-without them.
 # Features
-* Hides the event loop where registred blocks or methods are run when something
+* Can hide the event loop where registred blocks or methods are run when something
   happens.
 * Provides a cache for resources like images, fonts, sounds, ...
-* Documented, using YARD. You can check the documentation on
-  [rubydoc.info](http://rubydoc.info/github/Mon-Ouie/ray/master/frames)
+* Implements turtle graphics
+* Nothing more serious than a toy.
+
+# Installation & Getting started
+See [the guide](guide.md)

data/Rakefile

@@ -3,7 +3,7 @@ begin
   require 'yard'
 
   YARD::Rake::YardocTask.new do |t|
-    t.files = ['lib/**/*.rb', 'ext/**/*.c', 'psp/*.c']
+    t.files = ['lib/**/*.rb', 'ext/**/*.cpp']
     t.options |= ["--private", "-e", "./yard_ext.rb"]
   end
 rescue LoadError
@@ -25,42 +25,24 @@ begin
     s.authors = ["Mon ouïe"]
 
     s.files |= FileList["lib/**/*.rb"]
-    s.files |= FileList["ext/**/*.{c,h,m}"]
+    s.files |= FileList["ext/**/*.{cpp,h}"]
+    s.files |= FileList["*.md"]
+    s.files << ".gemtest" << "Rakefile"
 
     s.has_rdoc = "yard"
 
     s.extensions = ["ext/extconf.rb"]
-    
+
     s.add_development_dependency "jeweler"
     s.add_development_dependency "yard"
-    s.add_development_dependency "rspec"
-    s.add_development_dependency "psp_task"
+    s.add_development_dependency "riot"
+    s.add_development_dependency "rr"
   end
 rescue LoadError
   $stderr.puts("Jeweler is not installed. Please install it " +
                "with the following command: gem intall jeweler")
 end
 
-begin
-  begin
-    require 'spec/rake/spectask'
-    
-    Spec::Rake::SpecTask.new(:spec) do |t|
-      t.spec_files = FileList['spec/**/*_spec\.rb']
-      t.fail_on_error = false
-    end
-  rescue LoadError
-    require 'rspec/core/rake_task'
-  
-    RSpec::Core::RakeTask.new(:spec) do |t|
-      t.fail_on_error = false
-    end
-  end
-rescue LoadError
-  $stderr.puts("RSpec is not installed. Please install it " +
-               "with the following command: gem install rspec")
-end
-
 namespace :ext do
   desc "Rebuilds the C extension"
   task :rebuild do
@@ -78,123 +60,20 @@ end
 desc "Builds the C extension"
 task :ext => ["ext:build"]
 
-begin
-  require 'rake/psp_task'
-
-  libs = %w(socket/socket.c socket/getnameinfo.c socket/getaddrinfo.c
-          socket/pspsocket.c
-          bigdecimal/bigdecimal.c
-          digest/sha2/sha2init.c digest/sha2/sha2.c
-          digest/rmd160/rmd160.c digest/rmd160/rmd160init.c
-          digest/bubblebabble/bubblebabble.c
-          digest/sha1/sha1.c digest/sha1/sha1init.c
-          digest/md5/md5.c digest/md5/md5init.c
-          digest/digest.c
-          enumerator/enumerator.c
-          fcntl/fcntl.c
-          stringio/stringio.c
-          strscan/strscan.c
-          thread/thread.c
-          zlib/zlib.c
-          nkf/nkf.c
-          etc/etc.c
-          syck/bytecode.c syck/gram.c syck/implicit.c syck/rubyext.c
-          syck/token.c syck/emitter.c syck/handler.c syck/node.c syck/syck.c
-          syck/yaml2byte.c).map { |i| "psp/#{i}" }
-
-  static_libs = ["-lSDL_ttf", "-lSDL_mixer", "-lSDL_gfx", "-lSDL_image",
-                 "-lSDL", "-lGL", "-lpspvfpu", "-lfreetype", "-lvorbisfile",
-                 "-lvorbis", "-lmikmod", "-logg",
-                 "-lpspgu", "-lpspaudio", "-lpsprtc", "-lpsphprm", "-lpspwlan",
-                 "-lruby", "-lpng", "-ljpeg", "-lz","-lm", "-lc"]
-
-  flags = ["-Wall", "-Wno-unused-parameter", "-D_PSP_ -DHAVE_STRUCT_TIMESPEC",
-           "-DHAVE_SDL_SDL_IMAGE_H", "-G0", "-DHAVE_SDL_SDL_ROTOZOOM_H",
-           "-DHAVE_SDL_SDL_TTF_H", "-DHAVE_SDL_SDL_MIXER_H", "-DUSE_RWOPS"]
-
-  begin
-    PSPTask.new do |t|
-      t.objdir  = "./obj/"
-      t.srcs    = Dir['ext/*.c', 'psp/*.c'] | libs
-      t.libs    = static_libs | t.libs
-      t.cflags |= flags
-      t.incdir << "-I./ext" << "-I./psp"
-      t.target  = "ray_release"
-
-      t.build_prx   = true
-      t.build_eboot = true
-    end
-
-    PSPTask.new(:debug) do |t|
-      t.objdir  = "./obj_dbg/"
-      t.srcs    = Dir['ext/*.c', 'psp/*.c'] | libs
-      t.libs    = static_libs | t.libs
-      t.cflags |= (flags | ["-O0", "-g"])
-      t.incdir << "-I./ext" << "-I./psp"
-      t.target  = "ray"
-
-      t.build_prx = true
-    end
-  rescue
-    $stderr.puts "could not create PSP tasks"
-  end
-rescue LoadError
-  $stderr.puts("psp_task is not installed. Please install it " +
-               "with the following command: gem intall psp_task")
-end
-
-require 'net/ftp'
-
-file "ruby-1.8.7-p248.tar.bz2" do
-  ftp = Net::FTP.new
-  ftp.connect("ftp.ruby-lang.org", 21)
-  ftp.login("anonymous", "")
-  puts "Downloading ruby-1.8.7-p248.tar.bz2..."
-  ftp.getbinaryfile("pub/ruby/1.8/ruby-1.8.7-p248.tar.bz2",
-                    "ruby-1.8.7-p248.tar.bz2")
-  ftp.close
-end
+desc "Starts IRB"
+task :irb do
+  require 'irb'
+  ARGV.clear
 
-directory "ruby_stdlib"
-file "ruby_stdlib" => ["ruby-1.8.7-p248.tar.bz2"] do
-  sh "tar xvf ruby-1.8.7-p248.tar.bz2"
-  cp_r "ruby-1.8.7-p248/lib", "ruby_stdlib"
+  $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "ext"))
+  $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "lib"))
 
-  cp_r "psp/bigdecimal/lib/bigdecimal", "ruby_stdlib/lib"
+  require 'ray'
 
-  mkdir_p "ruby_stdlib/lib/digest" unless File.exist? "ruby_stdlib/lib/digest"
-  cp "psp/digest/lib/digest.rb", "ruby_stdlib/lib"
-  cp "psp/digest/lib/sha1.rb", "ruby_stdlib/lib/digest"
-  cp "psp/digest/lib/md5.rb", "ruby_stdlib/lib/digest"
-
-  cp "psp/nkf/lib/kconv.rb", "ruby_stdlib/lib"
+  IRB.start
 end
 
-ruby_libs = ["socket.rb", "bigdecimal.rb", "digest/bubblebabble.rb",
-             "fcntl.rb", "stringio.rb", "strscan.rb", "thread.rb",
-             "zlib.rb", "nkf.rb", "etc.rb", "syck.rb", "enumerator.rb"]
-
-ruby_libs.each do |filename|
-  ext_name = case filename
-             when /(\w+)\.rb/
-               $1
-             when /\w+\/(\w+)\.rb/
-               $1
-             else
-               filename
-             end
-
-  dir = File.dirname("ruby_stdlib/lib/#{filename}")
-
-  directory dir
-  file "ruby_stdlib/lib/#{filename}" => ["ruby_stdlib", dir] do
-    open("ruby_stdlib/lib/#{filename}", 'w') do |file|
-      file.puts "Ray.init_internal(\"#{ext_name}\")"
-    end
-  end
+desc "Runs tests"
+task :test do
+  load File.expand_path(File.join(File.dirname(__FILE__), "test", "run_all.rb"))
 end
-
-ruby_libs.map! { |i| "ruby_stdlib/lib/#{i}" }
-
-desc "Builds dependencies for running the specs on a PSP"
-task :psp_spec => (['debug:prx'] | ruby_libs)

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0.pre1

data/ext/audio.cpp

@@ -0,0 +1,723 @@
+#include "ray.hpp"
+
+void ray_audio_source::set_pitch(float value) {
+   source().SetPitch(value);
+}
+
+float ray_audio_source::pitch() const {
+   return source().GetPitch();
+}
+
+void ray_audio_source::set_position(const ray_vector3 &vector) {
+   source().SetPosition(vector);
+}
+
+ray_vector3 ray_audio_source::position() const {
+   return source().GetPosition();
+}
+
+void ray_audio_source::set_relative(bool value) {
+   source().SetRelativeToListener(value);
+}
+
+bool ray_audio_source::is_relative() const {
+   return source().IsRelativeToListener();
+}
+
+void ray_audio_source::set_min_distance(float value) {
+   source().SetMinDistance(value);
+}
+
+float ray_audio_source::min_distance() const {
+   return source().GetMinDistance();
+}
+
+void ray_audio_source::set_attenuation(float value) {
+   source().SetAttenuation(value);
+}
+
+float ray_audio_source::attenuation() const {
+   return source().GetAttenuation();
+}
+
+float ray_audio_source::volume() const {
+   return source().GetVolume();
+}
+
+void ray_audio_source::set_volume(float value) {
+   source().SetVolume(value);
+}
+
+void ray_sound::set_loop(bool value) {
+   sound.SetLoop(value);
+}
+
+bool ray_sound::is_looping() const {
+   return sound.GetLoop();
+}
+
+bool ray_sound::load_from_io(VALUE io) {
+   VALUE string  = rb_funcall2(io, RAY_METH("read"), 0, NULL);
+   char *content = StringValuePtr(string);
+
+   if (!sound_buffer.LoadFromMemory(content, RSTRING_LEN(string)))
+      return false;
+
+   sound.SetBuffer(sound_buffer);
+   return true;
+}
+
+bool ray_sound::load_from_filename(const std::string &filename) {
+   if (!sound_buffer.LoadFromFile(filename))
+      return false;
+   sound.SetBuffer(sound_buffer);
+   return true;
+}
+
+bool ray_sound::create_from_sound(const ray_sound &source) {
+   sound_buffer = source.sound_buffer;
+   sound = source.sound;
+
+   sound.SetBuffer(sound_buffer);
+
+   return true;
+}
+
+void ray_sound::play() {
+   sound.Play();
+}
+
+void ray_sound::pause() {
+   sound.Pause();
+}
+
+void ray_sound::stop() {
+   sound.Stop();
+}
+
+sf::SoundSource::Status ray_sound::status() const {
+   return sound.GetStatus();
+}
+
+float ray_sound::current_time() const {
+   return sound.GetPlayingOffset();
+}
+
+void ray_sound::set_current_time(float value) {
+   sound.SetPlayingOffset(value);
+}
+
+sf::SoundSource &ray_sound::source() {
+   return sound;
+}
+
+const sf::SoundSource &ray_sound::source() const {
+   return sound;
+}
+
+bool ray_music::load_from_io(VALUE self, VALUE io) {
+   VALUE string  = rb_funcall2(io, RAY_METH("read"), 0, NULL);
+   rb_iv_set(self, "@content", string);
+
+   char *content = StringValuePtr(string);
+   return music.OpenFromMemory(content, RSTRING_LEN(string));
+}
+
+bool ray_music::load_from_filename(const std::string &filename) {
+   return music.OpenFromFile(filename);
+}
+
+void ray_music::play() {
+   music.Play();
+}
+
+void ray_music::pause() {
+   music.Pause();
+}
+
+void ray_music::stop() {
+   music.Stop();
+}
+
+sf::SoundSource::Status ray_music::status() const {
+   return music.GetStatus();
+}
+
+void ray_music::set_loop(bool value) {
+   music.SetLoop(value);
+}
+
+bool ray_music::is_looping() const {
+   return music.GetLoop();
+}
+
+float ray_music::current_time() const {
+   return music.GetPlayingOffset();
+}
+
+void ray_music::set_current_time(float value) {
+   music.SetPlayingOffset(value);
+}
+
+float ray_music::duration() const {
+   return music.GetDuration();
+}
+
+int ray_music::sample_rate() const {
+   return music.GetSampleRate();
+}
+
+int ray_music::channel_count() const {
+   return music.GetChannelsCount();
+}
+
+sf::SoundSource &ray_music::source() {
+   return music;
+}
+
+const sf::SoundSource &ray_music::source() const {
+   return music;
+}
+
+VALUE ray_mAudio       = Qnil;
+VALUE ray_cSound       = Qnil;
+VALUE ray_cMusic       = Qnil;
+VALUE ray_cAudioSource = Qnil;
+
+/*
+  @return [Float] The global volume. 0 is the minimum volume, whereas 100
+    is the maximum.
+*/
+VALUE ray_audio_volume(VALUE self) {
+   float volume = sf::Listener::GetGlobalVolume();
+   return rb_float_new(volume * 100);
+}
+
+/* Sets the global volume */
+VALUE ray_audio_set_volume(VALUE self, VALUE value) {
+   float volume = (float)NUM2DBL(value);
+   sf::Listener::SetGlobalVolume(volume);
+
+   return value;
+}
+
+/*
+  @return [Ray::Vector3] The position of the listener.
+*/
+VALUE ray_audio_pos(VALUE self) {
+   sf::Vector3f pos = sf::Listener::GetPosition();
+   return ray_vector3_to_rb(pos);
+}
+
+/*
+  @overload pos=(pos)
+    @param [Ray::Vector3, #to_vector3] pos The [x, y, z] position of the listener.
+*/
+VALUE ray_audio_set_pos(VALUE self, VALUE pos) {
+   sf::Listener::SetPosition(ray_convert_to_vector3(pos));
+   return pos;
+}
+
+/*
+  @return [Ray::Vector3] The orientation of the listener.
+*/
+VALUE ray_audio_direction(VALUE self) {
+   sf::Vector3f dir = sf::Listener::GetDirection();
+   return ray_vector3_to_rb(dir);
+}
+
+/*
+  @overload direction=(dir)
+    @param [Ray::Vector3, #to_vector3] dir The orientation of the listener.
+*/
+VALUE ray_audio_set_direction(VALUE self, VALUE dir) {
+   sf::Listener::SetDirection(ray_convert_to_vector3(dir));
+   return dir;
+}
+
+ray_audio_source *ray_rb2source(VALUE object) {
+   if (!RAY_IS_A(object, ray_cAudioSource)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::AudioSource",
+               RAY_OBJ_CLASSNAME(object));
+   }
+
+   ray_audio_source *ptr = NULL;
+   Data_Get_Struct(object, ray_audio_source, ptr);
+
+   return ptr;
+}
+
+/* @return [Float] Volume of the source, between 0 and 100. */
+VALUE ray_audio_source_volume(VALUE self) {
+   ray_audio_source *source = ray_rb2source(self);
+   return rb_float_new(source->volume());
+}
+
+/* Sets the volume of the source. */
+VALUE ray_audio_source_set_volume(VALUE self, VALUE value) {
+   rb_check_frozen(self);
+
+   ray_audio_source *source = ray_rb2source(self);
+   float volume = (float)NUM2DBL(value);
+   source->set_volume(volume);
+
+   return value;
+}
+
+/* @return [Float] The pitch of the source. */
+VALUE ray_audio_source_pitch(VALUE self) {
+   ray_audio_source *source = ray_rb2source(self);
+   return rb_float_new(source->pitch());
+}
+
+/*
+  @overload pitch=(pitch)
+    @param [Float] pitch the pitch value, which makes a sound more acute
+      or grave and also affects playing speed. Defaulted to 1.
+*/
+VALUE ray_audio_source_set_pitch(VALUE self, VALUE pitch) {
+   rb_check_frozen(self);
+
+   ray_audio_source *source = ray_rb2source(self);
+   source->set_pitch(NUM2DBL(pitch));
+
+   return pitch;
+}
+
+/* @return [Ray::Vector3] The position of the source */
+VALUE ray_audio_source_pos(VALUE self) {
+   ray_audio_source *source = ray_rb2source(self);
+   return ray_vector3_to_rb(source->position());
+}
+
+/*
+  @overload pos=(pos)
+    @param [Ray::Vector3, #to_vector3] pos The position of the source
+*/
+VALUE ray_audio_source_set_pos(VALUE self, VALUE pos) {
+   rb_check_frozen(self);
+
+   ray_audio_source *source = ray_rb2source(self);
+   source->set_position(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.
+*/
+VALUE ray_audio_source_is_relative(VALUE self) {
+   ray_audio_source *source = ray_rb2source(self);
+   return source->is_relative() ? Qtrue : Qfalse;
+}
+
+/*
+  @overload relative=(rel)
+    @param [true, false] rel Whether the source position should be relative
+      to the listener's.
+*/
+VALUE ray_audio_source_set_relative(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
+   ray_audio_source *source = ray_rb2source(self);
+   source->set_relative(RTEST(val));
+   return val;
+}
+
+/* @return [Float] the source's minimal distance */
+VALUE ray_audio_source_min_distance(VALUE self) {
+   ray_audio_source *source = ray_rb2source(self);
+   return rb_float_new(source->min_distance());
+}
+
+/*
+  @overload min_distance=(dist)
+    @param [Float] dist the distance beyond which the source's volume will
+    decrease. Defaulted to 1.
+ */
+VALUE ray_audio_source_set_min_distance(VALUE self, VALUE dist) {
+   rb_check_frozen(self);
+
+   ray_audio_source *source = ray_rb2source(self);
+   source->set_min_distance(NUM2DBL(dist));
+   return dist;
+}
+
+/* @return [Float] The source's attenuation */
+VALUE ray_audio_source_attenuation(VALUE self) {
+   ray_audio_source *source = ray_rb2source(self);
+   return rb_float_new(source->attenuation());
+}
+
+/*
+  @overload attenuation=(attenuation)
+    @param [Float] atenuation Attenuation factor of the sound.
+      0 will prevent the sound from being attenuated, 100 would
+      make the sound be attenuated much more quickly.
+*/
+VALUE ray_audio_source_set_attenuation(VALUE self, VALUE attenuation) {
+   rb_check_frozen(self);
+
+   ray_audio_source *source = ray_rb2source(self);
+   source->set_attenuation(NUM2DBL(attenuation));
+   return attenuation;
+}
+
+ray_sound *ray_rb2sound(VALUE object) {
+   if (!RAY_IS_A(object, ray_cSound)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Sound",
+               RAY_OBJ_CLASSNAME(object));
+   }
+
+   ray_sound *ptr = NULL;
+   Data_Get_Struct(object, ray_sound, ptr);
+
+   return ptr;
+}
+
+void ray_free_sound(ray_sound *sound) {
+   delete sound;
+}
+
+VALUE ray_alloc_sound(VALUE self) {
+   ray_sound *ptr = new ray_sound;
+   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_sound, ptr);
+
+   return ret;
+}
+
+/*
+  @overload initialize(io_or_string)
+    Creates a new sound from an IO object or a filename.
+*/
+VALUE ray_init_sound(VALUE self, VALUE arg) {
+   int res = false;
+   ray_sound *sound = ray_rb2sound(self);
+
+   if (rb_respond_to(arg, RAY_METH("to_str"))) {
+      arg = rb_String(arg);
+      res = sound->load_from_filename(StringValuePtr(arg));
+   }
+   else if (rb_respond_to(arg, RAY_METH("read")))
+      res = sound->load_from_io(arg);
+   else {
+      rb_raise(rb_eTypeError, "Can't convert %s into String",
+               RAY_OBJ_CLASSNAME(arg));
+   }
+
+   if (!res)
+      rb_raise(rb_eRuntimeError, "Could not load sound");
+
+   return Qnil;
+}
+
+VALUE ray_init_sound_copy(VALUE self, VALUE other) {
+   ray_sound *sound  = ray_rb2sound(self);
+   ray_sound *source = ray_rb2sound(other);
+
+   if (!sound->create_from_sound(*source))
+      rb_raise(rb_eRuntimeError, "Couldn't copy the sound");
+
+   return self;
+}
+
+/* Plays the sound. */
+VALUE ray_sound_play(VALUE self) {
+   rb_check_frozen(self);
+   ray_rb2sound(self)->play();
+   return self;
+}
+
+/* Pauses the sound. */
+VALUE ray_sound_pause(VALUE self) {
+   rb_check_frozen(self);
+   ray_rb2sound(self)->pause();
+   return self;
+}
+
+/* Stops the sound. */
+VALUE ray_sound_stop(VALUE self) {
+   rb_check_frozen(self);
+   ray_rb2sound(self)->stop();
+   return self;
+}
+
+/*
+  @return [Symbol] :playing, :paused, or :stopped.
+*/
+VALUE ray_sound_status(VALUE self) {
+   ray_sound *sound = ray_rb2sound(self);
+
+   switch (sound->status()) {
+      case sf::SoundSource::Playing: return RAY_SYM("playing");
+      case sf::SoundSource::Paused:  return RAY_SYM("paused");
+      case sf::SoundSource::Stopped: return RAY_SYM("stopped");
+   }
+
+   return Qnil;
+}
+
+/* Sets whether the sound should loop */
+VALUE ray_sound_set_loop(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+   ray_rb2sound(self)->set_loop(RTEST(val));
+   return val;
+}
+
+/* @return [true, false] True if the sound loops */
+VALUE ray_sound_loop(VALUE self) {
+   return ray_rb2sound(self)->is_looping() ? Qtrue : Qfalse;
+}
+
+/* @return [Float] The current position in the sound */
+VALUE ray_sound_current_time(VALUE self) {
+   return rb_float_new(ray_rb2sound(self)->current_time());
+}
+
+/* Sets the cursor to a given position */
+VALUE ray_sound_set_current_time(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+   ray_rb2sound(self)->set_current_time(NUM2DBL(val));
+   return val;
+}
+
+ray_music *ray_rb2music(VALUE object) {
+   if (!RAY_IS_A(object, ray_cMusic)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Music",
+               RAY_OBJ_CLASSNAME(object));
+   }
+
+   ray_music *ptr = NULL;
+   Data_Get_Struct(object, ray_music, ptr);
+
+   return ptr;
+}
+
+void ray_free_music(ray_music *music) {
+   delete music;
+}
+
+VALUE ray_alloc_music(VALUE self) {
+   ray_music *ptr = new ray_music;
+   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_music, ptr);
+
+   return ret;
+}
+
+bool ray_init_music_with_filename(VALUE self, VALUE filename) {
+   ray_music *music = ray_rb2music(self);
+   return music->load_from_filename(StringValuePtr(filename));
+}
+
+bool ray_init_music_with_io(VALUE self, VALUE io) {
+   ray_music *music = ray_rb2music(self);
+   return music->load_from_io(self, io);
+}
+
+/*
+  @overload initialize(io_or_string)
+    Creates a new music from an IO object or a filename.
+*/
+VALUE ray_init_music(VALUE self, VALUE arg) {
+   bool res = false;
+
+   if (rb_respond_to(arg, RAY_METH("to_str")))
+      res = ray_init_music_with_filename(self, rb_String(arg));
+   else if (rb_respond_to(arg, RAY_METH("read")))
+      res = ray_init_music_with_io(self, arg);
+   else {
+      rb_raise(rb_eTypeError, "Can't convert %s into String",
+               RAY_OBJ_CLASSNAME(arg));
+   }
+
+   if (!res)
+      rb_raise(rb_eRuntimeError, "Could not load music");
+
+   return Qnil;
+}
+
+/*
+  Plays the music.
+*/
+VALUE ray_music_play(VALUE self) {
+   rb_check_frozen(self);
+
+   ray_music *music = ray_rb2music(self);
+   music->play();
+
+   return Qnil;
+}
+
+/*
+  Pauses the music.
+*/
+VALUE ray_music_pause(VALUE self) {
+   rb_check_frozen(self);
+
+   ray_music *music = ray_rb2music(self);
+   music->pause();
+
+   return Qnil;
+}
+
+/*
+  Stops the music.
+*/
+VALUE ray_music_stop(VALUE self) {
+   rb_check_frozen(self);
+
+   ray_music *music = ray_rb2music(self);
+   music->stop();
+
+   return Qnil;
+}
+
+/*
+  @return [Symbol] :playing, :paused, or :stopped.
+*/
+VALUE ray_music_status(VALUE self) {
+   ray_music *music = ray_rb2music(self);
+
+   switch (music->status()) {
+      case sf::SoundSource::Playing: return RAY_SYM("playing");
+      case sf::SoundSource::Paused:  return RAY_SYM("paused");
+      case sf::SoundSource::Stopped: return RAY_SYM("stopped");
+   }
+
+   return Qnil;
+}
+
+/* Sets whether the music should loop */
+VALUE ray_music_set_loop(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+   ray_rb2music(self)->set_loop(RTEST(val));
+   return val;
+}
+
+/* @return [true, false] True if the music loops */
+VALUE ray_music_loop(VALUE self) {
+   return ray_rb2music(self)->is_looping() ? Qtrue : Qfalse;
+}
+
+/* @return [Float] The current position in the music */
+VALUE ray_music_current_time(VALUE self) {
+   return rb_float_new(ray_rb2music(self)->current_time());
+}
+
+/* Sets the cursor to a given position */
+VALUE ray_music_set_current_time(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+   ray_rb2music(self)->set_current_time(NUM2DBL(val));
+   return val;
+}
+
+/* @return [Float] The duration of the music, in second */
+VALUE ray_music_duration(VALUE self) {
+   return rb_float_new(ray_rb2music(self)->duration());
+}
+
+/* @return [Integer] The sample rate of the music */
+VALUE ray_music_sample_rate(VALUE self) {
+   return INT2FIX(ray_rb2music(self)->sample_rate());
+}
+
+/* @return [Integer] The amount of channels */
+VALUE ray_music_channel_count(VALUE self) {
+   return INT2FIX(ray_rb2music(self)->channel_count());
+}
+
+/*
+  Document-class: Ray::AudioSource
+  Represents an object emitting sound. The only point of having
+  this class is to avoid repetitions between Ray::Music and Ray:Audio.
+*/
+
+/*
+  Document-class: Ray::Music
+  Class used to stream music.
+*/
+
+/*
+  Document-class: Ray::Sound
+  Class used to represent short sounds.
+*/
+
+void Init_ray_audio() {
+   ray_mAudio = rb_define_module_under(ray_mRay, "Audio");
+
+   rb_define_module_function(ray_mAudio, "volume", ray_audio_volume, 0);
+   rb_define_module_function(ray_mAudio, "volume=", ray_audio_set_volume, 1);
+
+   rb_define_module_function(ray_mAudio, "pos", ray_audio_pos, 0);
+   rb_define_module_function(ray_mAudio, "pos=", ray_audio_set_pos, 1);
+
+   rb_define_module_function(ray_mAudio, "direction", ray_audio_direction, 0);
+   rb_define_module_function(ray_mAudio, "direction=", ray_audio_set_direction,
+                             1);
+
+   ray_cAudioSource = rb_define_class_under(ray_mRay, "AudioSource", rb_cObject);
+
+   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, "volume", ray_audio_source_volume, 0);
+   rb_define_method(ray_cAudioSource, "volume=", ray_audio_source_set_volume, 1);
+
+   ray_cSound = rb_define_class_under(ray_mRay, "Sound", ray_cAudioSource);
+   rb_define_alloc_func(ray_cSound, ray_alloc_sound);
+   rb_define_method(ray_cSound, "initialize", ray_init_sound, 1);
+   rb_define_method(ray_cSound, "initialize_copy", ray_init_sound_copy, 1);
+
+   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);
+
+   rb_define_method(ray_cSound, "status", ray_sound_status, 0);
+
+   rb_define_method(ray_cSound, "loop=", ray_sound_set_loop, 1);
+   rb_define_method(ray_cSound, "loop?", ray_sound_loop, 0);
+
+   rb_define_method(ray_cSound, "current_time==", ray_sound_set_current_time, 1);
+   rb_define_method(ray_cSound, "current_time", ray_sound_current_time, 0);
+
+   ray_cMusic = rb_define_class_under(ray_mRay, "Music", ray_cAudioSource);
+   rb_define_alloc_func(ray_cMusic, ray_alloc_music);
+   rb_define_method(ray_cMusic, "initialize", ray_init_music, 1);
+
+   rb_define_method(ray_cMusic, "play", ray_music_play, 0);
+   rb_define_method(ray_cMusic, "pause", ray_music_pause, 0);
+   rb_define_method(ray_cMusic, "stop", ray_music_stop, 0);
+
+   rb_define_method(ray_cMusic, "status", ray_music_status, 0);
+
+   rb_define_method(ray_cMusic, "loop=", ray_music_set_loop, 1);
+   rb_define_method(ray_cMusic, "loop?", ray_music_loop, 0);
+
+   rb_define_method(ray_cMusic, "current_time==", ray_music_set_current_time, 1);
+   rb_define_method(ray_cMusic, "current_time", ray_music_current_time, 0);
+
+   rb_define_method(ray_cMusic, "duration", ray_music_duration, 0);
+
+   rb_define_method(ray_cMusic, "sample_rate", ray_music_sample_rate, 0);
+   rb_define_method(ray_cMusic, "channel_count", ray_music_channel_count, 0);
+}