ruby2d 0.12.1 → 1.0.0

data/examples/ui_controls.rb

@@ -0,0 +1,163 @@
+# UI controls
+# A small control panel made from Ruby 2D shapes: tabs, buttons, toggle, sliders.
+#
+# Adjust the controls to change the preview shape.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 760         # window width in pixels
+HEIGHT = 500        # window height in pixels
+PULSE_RATE = 4.8    # preview pulse angular speed (rad/sec)
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ UI controls', width: WIDTH, height: HEIGHT, background: '#111827'
+set close_on_esc: true
+set render_mode: :on_demand
+
+# === UI build ===
+
+Rectangle.new(x: 0, y: 0, width: 260, height: HEIGHT, color: '#1f2937')
+preview = Circle.new(x: 510, y: 250, radius: 70, color: [0.25, 0.75, 1.0, 1])
+Text.new('Controls', x: 22, y: 18, size: 22, color: '#f9fafb')
+
+# Tabs and buttons are `Button`s — each centers its own label and hit-tests
+# itself, so there's no manual text offset or bounds math anywhere below.
+tabs = ['Circle', 'Square'].map.with_index do |name, i|
+  Button.new(x: 20 + i * 110, y: 62, width: 100, height: 34,
+             label: name, label_size: 15, color: '#374151', label_color: '#f9fafb')
+end
+
+# Pulse toggle — an iOS-style pill: a center bar capped by two circles, with a
+# knob that slides between the caps. The pill pieces (`toggle_bg`) recolor as
+# one; only the knob moves. A visual-less Button over the pill is the hit area.
+toggle_x, toggle_y, toggle_w, toggle_h = 20, 125, 56, 28
+cap_r = toggle_h / 2
+toggle_bg = [
+  Rectangle.new(x: toggle_x + cap_r, y: toggle_y,
+                width: toggle_w - 2 * cap_r, height: toggle_h, color: '#4b5563'),
+  Circle.new(x: toggle_x + cap_r, y: toggle_y + cap_r, radius: cap_r, color: '#4b5563'),
+  Circle.new(x: toggle_x + toggle_w - cap_r, y: toggle_y + cap_r, radius: cap_r, color: '#4b5563')
+]
+toggle_knob = Circle.new(x: toggle_x + cap_r, y: toggle_y + cap_r, radius: 10, color: '#f9fafb')
+toggle_btn = Button.new(x: toggle_x, y: toggle_y, width: toggle_w, height: toggle_h)
+Text.new('Pulse', x: 90, y: 128, size: 17, color: '#e5e7eb')
+
+slider_specs = [
+  ['Red', 0.25, '#ef4444'],
+  ['Green', 0.75, '#22c55e'],
+  ['Blue', 1.0, '#38bdf8'],
+  ['Size', 0.55, '#facc15']
+]
+sliders = slider_specs.map.with_index do |(name, value, color), i|
+  y = 190 + i * 58
+  {
+    name: name, value: value, color: color, y: y,
+    label: Text.new(name, x: 20, y: y - 24, size: 14, color: '#d1d5db'),
+    track: Rectangle.new(x: 20, y: y, width: 190, height: 6, color: '#374151'),
+    fill: Rectangle.new(x: 20, y: y, width: 190 * value, height: 6, color: color),
+    knob: Circle.new(x: 20 + 190 * value, y: y + 3, radius: 9, color: '#f9fafb')
+  }
+end
+
+reset_btn = Button.new(x: 20, y: 440, width: 100, height: 34,
+                       label: 'Reset', label_size: 15, color: '#374151', label_color: '#f9fafb')
+random_btn = Button.new(x: 134, y: 440, width: 106, height: 34,
+                        label: 'Random', label_size: 15, color: '#374151', label_color: '#f9fafb')
+
+mode = :circle
+pulse = false
+drag_slider = nil
+t = 0.0
+
+redraw = lambda do
+  tabs.each_with_index do |tab, i|
+    selected = (mode == :circle && i.zero?) || (mode == :square && i == 1)
+    tab.color = selected ? '#2563eb' : '#374151'
+  end
+
+  toggle_color = pulse ? '#16a34a' : '#4b5563'
+  toggle_bg.each { |part| part.color = toggle_color }
+  toggle_knob.x = pulse ? toggle_x + toggle_w - cap_r : toggle_x + cap_r
+
+  sliders.each do |s|
+    s[:fill].width = 190 * s[:value]
+    s[:knob].x = 20 + 190 * s[:value]
+  end
+
+  color = [sliders[0][:value], sliders[1][:value], sliders[2][:value], 1]
+  size = 35 + sliders[3][:value] * 95
+  preview.remove
+  preview = if mode == :circle
+              Circle.new(x: 510, y: 250, radius: size / 2, color: color)
+            else
+              Square.new(x: 510 - size / 2, y: 250 - size / 2, size: size, color: color)
+            end
+  request_render
+end
+
+# === Helpers ===
+
+set_slider = lambda do |slider, x|
+  slider[:value] = ((x - 20) / 190.0).clamp(0.0, 1.0)
+  redraw.call
+end
+
+# === Input ===
+
+# Buttons hit-test themselves and fire `:click`, so the clickable controls just
+# attach handlers — no coordinate math.
+tabs.each_with_index do |tab, i|
+  tab.on(:click) do
+    mode = i.zero? ? :circle : :square
+    redraw.call
+  end
+end
+
+toggle_btn.on(:click) do
+  pulse = !pulse
+  redraw.call
+end
+
+reset_btn.on(:click) do
+  slider_specs.each_with_index { |(_, value, _), i| sliders[i][:value] = value }
+  redraw.call
+end
+
+random_btn.on(:click) do
+  sliders.each { |s| s[:value] = rand }
+  redraw.call
+end
+
+# Sliders drag rather than click, so they stay on the window's mouse handlers.
+on :mouse_down do |event|
+  sliders.each do |s|
+    next unless event.x.between?(15, 215) && event.y.between?(s[:y] - 10, s[:y] + 16)
+
+    drag_slider = s
+    set_slider.call(s, event.x)
+  end
+end
+
+on :mouse_up do
+  drag_slider = nil
+end
+
+on :mouse_move do |event|
+  set_slider.call(drag_slider, event.x) if drag_slider
+end
+
+# === Update ===
+
+update do |dt|
+  next unless pulse
+
+  t += PULSE_RATE * dt
+  preview.opacity = 0.65 + Math.sin(t) * 0.25
+  request_render
+end
+
+redraw.call
+show

data/examples/wireframe_3d.rb

@@ -0,0 +1,139 @@
+# 3D wireframe
+# A wireframe sphere drawn entirely from 2D `Polyline` primitives.
+#
+# Each frame, the sphere's vertices are rotated in 3D, perspective-
+# projected onto the screen, and every latitude / longitude line is
+# laid down as a depth-shaded polyline so the back of the sphere reads
+# as further away. Click and drag to spin it; let go and it keeps
+# rotating.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+N_LAT = 9                # number of latitude rings between the poles
+N_LON = 18               # longitudes / segments per ring
+RADIUS = 220             # sphere radius in pixels
+CAMERA = 4.0             # camera distance in unit-sphere coordinates
+AUTO_ROT_X = 0.30        # idle rotation rate around X (rad/sec)
+AUTO_ROT_Y = 0.55        # idle rotation rate around Y (rad/sec)
+DRAG_SENS = 0.006        # screen-pixels → radians for mouse drag
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ 3D wireframe',
+    width: WIDTH, height: HEIGHT, background: '#06081a'
+set close_on_esc: true
+
+# === Geometry: sphere ===
+
+# Lat row i sits at theta = π·(i+1)/(N_LAT+1) so it lies between, but
+# never on, the poles. The poles are stored as their own vertices and
+# referenced by every longitude line.
+SPHERE = []
+N_LAT.times do |i|
+  theta = Math::PI * (i + 1) / (N_LAT + 1)
+  N_LON.times do |j|
+    phi = 2 * Math::PI * j / N_LON
+    SPHERE << [Math.sin(theta) * Math.cos(phi),
+               Math.cos(theta),
+               Math.sin(theta) * Math.sin(phi)]
+  end
+end
+NORTH = SPHERE.length;     SPHERE << [0,  1, 0]
+SOUTH = SPHERE.length;     SPHERE << [0, -1, 0]
+SPHERE.freeze
+
+# === State ===
+
+rot_x = 0.4
+rot_y = 0.0
+drag_from = nil
+
+# === Input ===
+
+on :mouse_down do |event|
+  drag_from = [event.x, event.y]
+end
+
+on :mouse_up do
+  drag_from = nil
+end
+
+on :mouse_move do |event|
+  next unless drag_from
+
+  rot_y += (event.x - drag_from[0]) * DRAG_SENS
+  rot_x += (event.y - drag_from[1]) * DRAG_SENS
+  drag_from[0] = event.x
+  drag_from[1] = event.y
+end
+
+# === Per-frame update ===
+
+update do |dt|
+  unless drag_from
+    rot_x += AUTO_ROT_X * dt
+    rot_y += AUTO_ROT_Y * dt
+  end
+end
+
+# === Render ===
+
+CX = WIDTH  / 2
+CY = HEIGHT / 2
+
+# Per-vertex color is derived from projected depth so the polylines
+# brighten as they wrap toward the camera and dim into navy on the far
+# side. `Polyline` interpolates the colors along the path.
+def shade(z)
+  t = ((z + 1.0) * 0.5).clamp(0.0, 1.0)  # z in [-1, 1] → t in [0, 1]
+  [0.30 + 0.65 * t, 0.55 + 0.40 * t, 0.85 + 0.15 * t, 0.30 + 0.70 * t]
+end
+
+render do
+  cx_a = Math.cos(rot_x); sx_a = Math.sin(rot_x)
+  cy_a = Math.cos(rot_y); sy_a = Math.sin(rot_y)
+
+  # Project every sphere vertex once.
+  proj = SPHERE.map do |v|
+    x, y, z = v
+    y2 =  y * cx_a - z * sx_a
+    z2 =  y * sx_a + z * cx_a
+    x3 =  x * cy_a + z2 * sy_a
+    z3 = -x * sy_a + z2 * cy_a
+    f  = CAMERA / (CAMERA - z3)
+    [CX + x3 * RADIUS * f, CY + y2 * RADIUS * f, z3]
+  end
+
+  # Latitude rings — closed polylines around each row.
+  N_LAT.times do |i|
+    pts = []
+    colors = []
+    N_LON.times do |j|
+      p = proj[i * N_LON + j]
+      pts << [p[0], p[1]]
+      colors << shade(p[2])
+    end
+    Polyline.render(points: pts, color: colors, stroke_width: 1.5, closed: true)
+  end
+
+  # Longitude arcs — each runs from the north pole down through one
+  # column of lat vertices to the south pole.
+  N_LON.times do |j|
+    pts = [[proj[NORTH][0], proj[NORTH][1]]]
+    colors = [shade(proj[NORTH][2])]
+    N_LAT.times do |i|
+      p = proj[i * N_LON + j]
+      pts << [p[0], p[1]]
+      colors << shade(p[2])
+    end
+    pts << [proj[SOUTH][0], proj[SOUTH][1]]
+    colors << shade(proj[SOUTH][2])
+    Polyline.render(points: pts, color: colors, stroke_width: 1.5)
+  end
+end
+
+show

data/ext/ruby2d/audio.c

@@ -0,0 +1,324 @@
+// audio.c
+//
+// SDL_mixer wrappers + Ruby2D::Ext bindings for audio. The Audio Ruby class
+// (lib/ruby2d/audio.rb) holds an opaque @ext_audio handle returned by
+// Ext.audio_load and passes it back to the other Ext.audio_* methods.
+
+#include "ruby2d.h"
+
+R2D_DEFINE_DATA_TYPE(R2D_Audio);
+
+// Mixer device — created once in R2D_Init, used by audio bindings.
+static MIX_Mixer *r2d_mixer = NULL;
+
+void R2D_SetMixer(MIX_Mixer *mixer) { r2d_mixer = mixer; }
+MIX_Mixer *R2D_GetMixer(void)       { return r2d_mixer; }
+
+
+/*
+ * Lazily initialize SDL_mixer and open the default playback device. Separated
+ * from R2D_Init so a machine with no/blocked audio device can still open a
+ * graphics window — only actual audio use triggers (and can fail) here.
+ * Idempotent: returns true immediately once a mixer exists.
+ */
+bool R2D_InitAudio() {
+  if (r2d_mixer) return true;
+
+  // Ensure SDL's subsystems (incl. the audio subsystem) are up first.
+  if (!R2D_Init()) return false;
+
+  // Initialize SDL_mixer (SDL3 style: returns true on success)
+  if (!MIX_Init()) {
+    R2D_Error("MIX_Init", "%s", SDL_GetError());
+    return false;
+  }
+
+  // Open the default playback device (SDL3)
+  MIX_Mixer *mixer = MIX_CreateMixerDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, NULL);
+  if (!mixer) {
+    R2D_Error("MIX_CreateMixerDevice", "%s", SDL_GetError());
+    return false;
+  }
+  r2d_mixer = mixer;
+  return true;
+}
+
+
+// Clamp a gain value to the SDL-accepted [0.0, 1.0] range.
+static inline float clamp01(float v) {
+  if (v < 0.0f) return 0.0f;
+  if (v > 1.0f) return 1.0f;
+  return v;
+}
+
+
+/*
+ * Ruby2D::Ext.audio_load(path) → opaque handle (or raises on failure)
+ */
+R_VAL ruby2d_ext_audio_load(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 1) r_raise("Ruby2D::Ext.audio_load expects 1 arg (path), got %d", (int)argc);
+
+  // Open the mixer device lazily if an Audio object is the first thing created.
+  // R2D_InitAudio is idempotent; it fails only when no playback device exists.
+  if (!R2D_InitAudio()) r_error("Failed to initialize audio: %s", SDL_GetError());
+
+  const char *path = RSTRING_PTR(argv[0]);
+
+  if (!R2D_FileExists(path)) {
+    r_error("Audio file `%s` not found", path);
+    return R_NIL;
+  }
+
+  R2D_Audio *aud = ALLOC(R2D_Audio);
+
+  // On failure, raise rather than returning nil: the Audio object would
+  // otherwise store a nil handle and segfault on the first play/pause/etc.
+  // when the binding unwraps it.
+  MIX_Audio *mix_audio = MIX_LoadAudio(r2d_mixer, path, false);
+  if (!mix_audio) {
+    xfree(aud);
+    r_error("Failed to load audio `%s`: %s", path, SDL_GetError());
+    return R_NIL;
+  }
+
+  MIX_Track *mix_track = MIX_CreateTrack(r2d_mixer);
+  if (!mix_track) {
+    MIX_DestroyAudio(mix_audio);
+    xfree(aud);
+    r_error("Failed to load audio `%s`: %s", path, SDL_GetError());
+    return R_NIL;
+  }
+
+  aud->mix_audio = mix_audio;
+  aud->mix_track = mix_track;
+
+  return r_wrap_struct(R2D_Audio, aud);
+}
+
+
+/*
+ * Ruby2D::Ext.audio_play(handle, loop)
+ */
+R_VAL ruby2d_ext_audio_play(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 2) r_raise("Ruby2D::Ext.audio_play expects 2 args, got %d", (int)argc);
+
+  R2D_Audio *aud = r_unwrap_struct(argv[0], R2D_Audio);
+
+  // Assign input to this track before playing (required in SDL3_mixer)
+  if (!MIX_SetTrackAudio(aud->mix_track, aud->mix_audio)) {
+    R2D_Error("MIX_SetTrackAudio", "%s", SDL_GetError());
+  }
+
+  // The loop count must be passed as a play option: MIX_PlayTrack's second arg
+  // is an SDL_PropertiesID, not a loop count, and MIX_SetTrackLoops has no
+  // effect on a stopped track. -1 loops forever, 0 plays once. A failed
+  // property set degrades to play-once (props == 0 → default loops).
+  SDL_PropertiesID props = SDL_CreateProperties();
+  if (props) {
+    SDL_SetNumberProperty(props, MIX_PROP_PLAY_LOOPS_NUMBER, r_test(argv[1]) ? -1 : 0);
+  }
+  if (!MIX_PlayTrack(aud->mix_track, props)) {
+    R2D_Error("MIX_PlayTrack", "%s", SDL_GetError());
+  }
+  SDL_DestroyProperties(props);
+
+  return R_TRUE;
+}
+
+
+/*
+ * Ruby2D::Ext.audio_pause(handle)
+ */
+R_VAL ruby2d_ext_audio_pause(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 1) r_raise("Ruby2D::Ext.audio_pause expects 1 arg, got %d", (int)argc);
+
+  R2D_Audio *aud = r_unwrap_struct(argv[0], R2D_Audio);
+
+  if (!MIX_PauseTrack(aud->mix_track)) {
+    R2D_Error("MIX_PauseTrack", "%s", SDL_GetError());
+  }
+
+  return R_TRUE;
+}
+
+
+/*
+ * Ruby2D::Ext.audio_resume(handle)
+ */
+R_VAL ruby2d_ext_audio_resume(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 1) r_raise("Ruby2D::Ext.audio_resume expects 1 arg, got %d", (int)argc);
+
+  R2D_Audio *aud = r_unwrap_struct(argv[0], R2D_Audio);
+
+  if (!MIX_ResumeTrack(aud->mix_track)) {
+    R2D_Error("MIX_ResumeTrack", "%s", SDL_GetError());
+  }
+
+  return R_TRUE;
+}
+
+
+/*
+ * Ruby2D::Ext.audio_stop(handle, ms_fade)
+ */
+R_VAL ruby2d_ext_audio_stop(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 2) r_raise("Ruby2D::Ext.audio_stop expects 2 args, got %d", (int)argc);
+
+  R2D_Audio *aud = r_unwrap_struct(argv[0], R2D_Audio);
+
+  int fade_ms = NUM2INT(argv[1]);
+  if (fade_ms < 0) fade_ms = 0;
+
+  if (!MIX_StopTrack(aud->mix_track, MIX_TrackMSToFrames(aud->mix_track, fade_ms))) {
+    R2D_Error("MIX_StopTrack", "%s", SDL_GetError());
+  }
+
+  return R_TRUE;
+}
+
+
+/*
+ * Ruby2D::Ext.audio_set_loop(handle, loop)
+ */
+R_VAL ruby2d_ext_audio_set_loop(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 2) r_raise("Ruby2D::Ext.audio_set_loop expects 2 args, got %d", (int)argc);
+
+  R2D_Audio *aud = r_unwrap_struct(argv[0], R2D_Audio);
+  MIX_SetTrackLoops(aud->mix_track, r_test(argv[1]) ? -1 : 0);
+
+  return argv[1];
+}
+
+
+/*
+ * Ruby2D::Ext.audio_length(handle) → duration in seconds, 0 if unknown/infinite
+ */
+R_VAL ruby2d_ext_audio_length(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 1) r_raise("Ruby2D::Ext.audio_length expects 1 arg, got %d", (int)argc);
+
+  R2D_Audio *aud = r_unwrap_struct(argv[0], R2D_Audio);
+
+  Sint64 frames = MIX_GetAudioDuration(aud->mix_audio);
+  if (frames == MIX_DURATION_UNKNOWN || frames == MIX_DURATION_INFINITE) {
+    return INT2NUM(0);
+  }
+
+  Sint64 ms = MIX_AudioFramesToMS(aud->mix_audio, frames);
+  // Round to nearest second instead of truncating
+  int seconds = (int)((ms + 500) / 1000);
+
+  return INT2NUM(seconds);
+}
+
+
+/*
+ * Ruby2D::Ext.audio_get_volume(handle) → 0.0..1.0
+ */
+R_VAL ruby2d_ext_audio_get_volume(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 1) r_raise("Ruby2D::Ext.audio_get_volume expects 1 arg, got %d", (int)argc);
+
+  R2D_Audio *aud = r_unwrap_struct(argv[0], R2D_Audio);
+
+  float gain = clamp01(MIX_GetTrackGain(aud->mix_track));  // SDL gain, 0.0 .. 1.0
+
+  return DBL2NUM(gain);
+}
+
+
+/*
+ * Ruby2D::Ext.audio_set_volume(handle, volume) — volume 0.0..1.0
+ */
+R_VAL ruby2d_ext_audio_set_volume(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 2) r_raise("Ruby2D::Ext.audio_set_volume expects 2 args, got %d", (int)argc);
+
+  R2D_Audio *aud = r_unwrap_struct(argv[0], R2D_Audio);
+
+  float gain = clamp01((float) NUM2DBL(argv[1]));
+
+  if (!MIX_SetTrackGain(aud->mix_track, gain)) {
+    R2D_Error("MIX_SetTrackGain", "%s", SDL_GetError());
+  }
+
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Ext.audio_get_mixer_volume → 0.0..1.0
+ */
+R_VAL ruby2d_ext_audio_get_mixer_volume(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  (void)argc; (void)argv;
+
+  // Open the mixer device lazily. R2D_InitAudio is idempotent.
+  if (!R2D_InitAudio()) r_error("Failed to initialize audio: %s", SDL_GetError());
+
+  float gain = clamp01(MIX_GetMixerGain(r2d_mixer));
+
+  return DBL2NUM(gain);
+}
+
+
+/*
+ * Ruby2D::Ext.audio_set_mixer_volume(volume) — volume 0.0..1.0
+ */
+R_VAL ruby2d_ext_audio_set_mixer_volume(RUBY2D_METHOD_ARGS_VARIADIC) {
+  RUBY2D_EXTRACT_VARIADIC;
+  if (argc != 1) r_raise("Ruby2D::Ext.audio_set_mixer_volume expects 1 arg, got %d", (int)argc);
+
+  // Open the mixer device lazily. R2D_InitAudio is idempotent.
+  if (!R2D_InitAudio()) r_error("Failed to initialize audio: %s", SDL_GetError());
+
+  float gain = clamp01((float) NUM2DBL(argv[0]));
+
+  if (!MIX_SetMixerGain(r2d_mixer, gain)) {
+    R2D_Error("MIX_SetMixerGain", "%s", SDL_GetError());
+  }
+
+  return R_NIL;
+}
+
+
+/*
+ * Initialize — register Ext audio bindings.
+ */
+void R2D_Audio_Init() {
+  r_define_class_method(ruby2d_ext_module, "audio_load",             ruby2d_ext_audio_load,             r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_play",             ruby2d_ext_audio_play,             r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_pause",            ruby2d_ext_audio_pause,            r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_resume",           ruby2d_ext_audio_resume,           r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_stop",             ruby2d_ext_audio_stop,             r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_set_loop",         ruby2d_ext_audio_set_loop,         r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_length",           ruby2d_ext_audio_length,           r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_get_volume",       ruby2d_ext_audio_get_volume,       r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_set_volume",       ruby2d_ext_audio_set_volume,       r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_get_mixer_volume", ruby2d_ext_audio_get_mixer_volume, r_args_variadic);
+  r_define_class_method(ruby2d_ext_module, "audio_set_mixer_volume", ruby2d_ext_audio_set_mixer_volume, r_args_variadic);
+}
+
+
+/*
+ * Free the audio
+ */
+static void R2D_Audio_free(void *p) {
+  if (!p) return;
+  R2D_Audio *aud = (R2D_Audio *)p;
+  if (aud->mix_track) {
+    MIX_DestroyTrack(aud->mix_track);
+    aud->mix_track = NULL;
+  }
+  if (aud->mix_audio) {
+    MIX_DestroyAudio(aud->mix_audio);
+    aud->mix_audio = NULL;
+  }
+  xfree(aud);
+}