allegro4r 0.0.1

data/examples/extimer.rb

@@ -0,0 +1,84 @@
+#
+# Example program (C Version) for the Allegro library, by Shawn Hargreaves.
+#   (Ruby port by Jason Frey)
+#
+# This program demonstrates how to use the timer routines.
+# These can be a bit of a pain, because you have to be sure
+# you lock all the memory that is used inside your interrupt
+# handlers.  The first part of the example shows a basic use of
+# timing using the blocking function rest(). The second part
+# shows how to use three timers with different frequencies in
+# a non blocking way.
+#
+# JF - Counters based on timer interrupts cannot be done directly though Ruby,
+# so instead, we can use predefined timer counters. They can be installed by
+# name with install_int or install_int_ex. The values can be retrieved through
+# timer_counter_get.
+#
+
+require 'rubygems'
+require 'allegro4r'
+include Allegro4r::API
+
+exit 1 if allegro_init != 0
+install_keyboard
+install_timer
+
+if set_gfx_mode(GFX_AUTODETECT, 320, 200, 0, 0) != 0
+  if set_gfx_mode(GFX_SAFE, 320, 200, 0, 0) != 0
+    set_gfx_mode(GFX_TEXT, 0, 0, 0, 0)
+    allegro_message("Unable to set any graphic mode\n%s\n" % allegro_error)
+    exit 1
+  end
+end
+
+set_palette(desktop_palette)
+clear_to_color(screen, makecol(255, 255, 255))
+
+textprintf_centre_ex(screen, font, SCREEN_W()/2, 8, makecol(0, 0, 0), makecol(255, 255, 255), "Driver: %s" % timer_driver.name)
+
+# use rest to delay for a specified number of milliseconds
+textprintf_centre_ex(screen, font, SCREEN_W()/2, 48, makecol(0, 0, 0), makecol(255, 255, 255), "Timing five seconds:")
+
+(1..5).each do |c|
+  textprintf_centre_ex(screen, font, SCREEN_W()/2, 62 + c * 10, makecol(0, 0, 0), makecol(255, 255, 255), "%d" % c)
+  rest(1000)
+end
+
+textprintf_centre_ex(screen, font, SCREEN_W()/2, 142, makecol(0, 0, 0), makecol(255, 255, 255), "Press a key to set up interrupts")
+readkey
+
+# JF - Since we are using predefined timer routines, LOCK_VARIABLE and
+# LOCK_FUNCTION do nothing, and are here simply for API consistency. They will
+# raise warnings if the Ruby script is run with -w.
+
+# all variables and code used inside interrupt handlers must be locked
+LOCK_VARIABLE(:x)
+LOCK_VARIABLE(:y)
+LOCK_VARIABLE(:z)
+LOCK_FUNCTION(:inc_x)
+LOCK_FUNCTION(:inc_y)
+LOCK_FUNCTION(:inc_z)
+
+# JF - install_int and install_int_ex take a name as their first parameter
+# which can then be used to subsequent calls to timer_counter_get.
+
+# the speed can be specified in milliseconds (this is once a second)
+install_int(:inc_x, 1000)
+
+# or in beats per second (this is 10 ticks a second)
+install_int_ex(:inc_y, BPS_TO_TIMER(10))
+
+# or in seconds (this is 10 seconds a tick)
+install_int_ex(:inc_z, SECS_TO_TIMER(10))
+
+# the interrupts are now active...
+while !keypressed
+  # JF - Get the values from the timer interrupt counters with
+  # timer_counter_get
+  x = timer_counter_get(:inc_x)
+  y = timer_counter_get(:inc_y)
+  z = timer_counter_get(:inc_z)
+
+  textprintf_centre_ex(screen, font, SCREEN_W()/2, 176, makecol(0, 0, 0), makecol(255, 255, 255), "x=%d, y=%d, z=%d" % [x, y, z])
+end

data/ext/a4r_API_BITMAP.c

@@ -0,0 +1,27 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   bmp.h -> int
+ *
+ * Returns the height of the BITMAP in pixels.
+ */
+VALUE a4r_API_BITMAP_h_get(VALUE self)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(self, BITMAP, bitmap);
+  return INT2FIX(bitmap->h);
+}
+
+/*
+ * call-seq:
+ *   bmp.w -> int
+ *
+ * Returns the width of the BITMAP in pixels.
+ */
+VALUE a4r_API_BITMAP_w_get(VALUE self)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(self, BITMAP, bitmap);
+  return INT2FIX(bitmap->w);
+}

data/ext/a4r_API_DIGI_DRIVER.c

@@ -0,0 +1,14 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   driver.name -> str
+ *
+ * Driver name
+ */
+VALUE a4r_API_DIGI_DRIVER_name_get(VALUE self)
+{
+  DIGI_DRIVER *driver;
+  Data_Get_Struct(self, DIGI_DRIVER, driver);
+  return rb_str_new2(driver->name);
+}

data/ext/a4r_API_GFX_DRIVER.c

@@ -0,0 +1,14 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   driver.name -> str
+ *
+ * Returns the name of the graphics driver.
+ */
+VALUE a4r_API_GFX_DRIVER_name_get(VALUE self)
+{
+  GFX_DRIVER *driver;
+  Data_Get_Struct(self, GFX_DRIVER, driver);
+  return rb_str_new2(driver->name);
+}

data/ext/a4r_API_JOYSTICK_AXIS_INFO.c

@@ -0,0 +1,53 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   jai.pos -> int
+ *
+ * Analogue axis position
+ */
+VALUE a4r_API_JOYSTICK_AXIS_INFO_pos(VALUE self)
+{
+  JOYSTICK_AXIS_INFO *jai;
+  Data_Get_Struct(self, JOYSTICK_AXIS_INFO, jai);
+  return INT2FIX(jai->pos);
+}
+
+/*
+ * call-seq:
+ *   jai.d1 -> true or false
+ *
+ * Digital axis position
+ */
+VALUE a4r_API_JOYSTICK_AXIS_INFO_d1(VALUE self)
+{
+  JOYSTICK_AXIS_INFO *jai;
+  Data_Get_Struct(self, JOYSTICK_AXIS_INFO, jai);
+  return jai->d1 ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   jai.d2 -> true or false
+ *
+ * Digital axis position
+ */
+VALUE a4r_API_JOYSTICK_AXIS_INFO_d2(VALUE self)
+{
+  JOYSTICK_AXIS_INFO *jai;
+  Data_Get_Struct(self, JOYSTICK_AXIS_INFO, jai);
+  return jai->d2 ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   jai.name -> int
+ *
+ * Description of this axis
+ */
+VALUE a4r_API_JOYSTICK_AXIS_INFO_name(VALUE self)
+{
+  JOYSTICK_AXIS_INFO *jai;
+  Data_Get_Struct(self, JOYSTICK_AXIS_INFO, jai);
+  return rb_str_new2(jai->name);
+}

data/ext/a4r_API_JOYSTICK_BUTTON_INFO.c

@@ -0,0 +1,27 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   jbi.b -> true or false
+ *
+ * Boolean on/off flag
+ */
+VALUE a4r_API_JOYSTICK_BUTTON_INFO_b(VALUE self)
+{
+  JOYSTICK_BUTTON_INFO *jbi;
+  Data_Get_Struct(self, JOYSTICK_BUTTON_INFO, jbi);
+  return jbi->b ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   jbi.name -> str
+ *
+ * Description of this button
+ */
+VALUE a4r_API_JOYSTICK_BUTTON_INFO_name(VALUE self)
+{
+  JOYSTICK_BUTTON_INFO *jbi;
+  Data_Get_Struct(self, JOYSTICK_BUTTON_INFO, jbi);
+  return rb_str_new2(jbi->name);
+}

data/ext/a4r_API_JOYSTICK_DRIVER.c

@@ -0,0 +1,14 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   driver.name -> str
+ *
+ * Returns the name of the joystick driver.
+ */
+VALUE a4r_API_JOYSTICK_DRIVER_name_get(VALUE self)
+{
+  JOYSTICK_DRIVER *driver;
+  Data_Get_Struct(self, JOYSTICK_DRIVER, driver);
+  return rb_str_new2(driver->name);
+}

data/ext/a4r_API_JOYSTICK_INFO.c

@@ -0,0 +1,84 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   ji.flags -> int
+ *
+ * Status flags for this joystick
+ */
+VALUE a4r_API_JOYSTICK_INFO_flags(VALUE self)
+{
+  JOYSTICK_INFO *ji;
+  Data_Get_Struct(self, JOYSTICK_INFO, ji);
+  return INT2NUM(ji->flags);
+}
+
+/*
+ * call-seq:
+ *   ji.num_sticks -> int
+ *
+ * How many stick inputs?
+ */
+VALUE a4r_API_JOYSTICK_INFO_num_sticks(VALUE self)
+{
+  JOYSTICK_INFO *ji;
+  Data_Get_Struct(self, JOYSTICK_INFO, ji);
+  return INT2FIX(ji->num_sticks);
+}
+
+/*
+ * call-seq:
+ *   ji.num_buttons -> int
+ *
+ * How many buttons?
+ */
+VALUE a4r_API_JOYSTICK_INFO_num_buttons(VALUE self)
+{
+  JOYSTICK_INFO *ji;
+  Data_Get_Struct(self, JOYSTICK_INFO, ji);
+  return INT2FIX(ji->num_buttons);
+}
+
+/*
+ * call-seq:
+ *   ji.stick -> ary
+ *
+ * Stick state information
+ */
+VALUE a4r_API_JOYSTICK_INFO_stick(VALUE self)
+{
+  JOYSTICK_INFO *ji;
+  Data_Get_Struct(self, JOYSTICK_INFO, ji);
+
+  VALUE ret = rb_ary_new2(ji->num_sticks);
+  long x;
+  for (x = 0; x < ji->num_sticks; x++)
+  {
+    VALUE obj = Data_Wrap_Struct(cAPI_JOYSTICK_STICK_INFO, 0, 0, &(ji->stick[x]));
+    rb_ary_store(ret, x, obj);
+  }
+
+  return ret;
+}
+
+/*
+ * call-seq:
+ *   ji.button -> ary
+ *
+ * Button state information
+ */
+VALUE a4r_API_JOYSTICK_INFO_button(VALUE self)
+{
+  JOYSTICK_INFO *ji;
+  Data_Get_Struct(self, JOYSTICK_INFO, ji);
+
+  VALUE ret = rb_ary_new2(ji->num_buttons);
+  long x;
+  for (x = 0; x < ji->num_buttons; x++)
+  {
+    VALUE obj = Data_Wrap_Struct(cAPI_JOYSTICK_BUTTON_INFO, 0, 0, &(ji->button[x]));
+    rb_ary_store(ret, x, obj);
+  }
+
+  return ret;
+}

data/ext/a4r_API_JOYSTICK_STICK_INFO.c

@@ -0,0 +1,62 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   jsi.flags -> int
+ *
+ * Status flags for this input
+ */
+VALUE a4r_API_JOYSTICK_STICK_INFO_flags(VALUE self)
+{
+  JOYSTICK_STICK_INFO *jsi;
+  Data_Get_Struct(self, JOYSTICK_STICK_INFO, jsi);
+  return INT2NUM(jsi->flags);
+}
+
+/*
+ * call-seq:
+ *   jsi.num_axis -> int
+ *
+ * How many axes do we have? (note the misspelling)
+ */
+VALUE a4r_API_JOYSTICK_STICK_INFO_num_axis(VALUE self)
+{
+  JOYSTICK_STICK_INFO *jsi;
+  Data_Get_Struct(self, JOYSTICK_STICK_INFO, jsi);
+  return INT2FIX(jsi->num_axis);
+}
+
+/*
+ * call-seq:
+ *   jsi.axis -> ary
+ *
+ * Axis state information
+ */
+VALUE a4r_API_JOYSTICK_STICK_INFO_axis(VALUE self)
+{
+  JOYSTICK_STICK_INFO *jsi;
+  Data_Get_Struct(self, JOYSTICK_STICK_INFO, jsi);
+
+  VALUE ret = rb_ary_new2(jsi->num_axis);
+  long x;
+  for (x = 0; x < jsi->num_axis; x++)
+  {
+    VALUE obj = Data_Wrap_Struct(cAPI_JOYSTICK_AXIS_INFO, 0, 0, &(jsi->axis[x]));
+    rb_ary_store(ret, x, obj);
+  }
+
+  return ret;
+}
+
+/*
+ * call-seq:
+ *   jsi.name -> str
+ *
+ * Description of this input
+ */
+VALUE a4r_API_JOYSTICK_STICK_INFO_name(VALUE self)
+{
+  JOYSTICK_STICK_INFO *jsi;
+  Data_Get_Struct(self, JOYSTICK_STICK_INFO, jsi);
+  return rb_str_new2(jsi->name);
+}

data/ext/a4r_API_KEYBOARD_DRIVER.c

@@ -0,0 +1,14 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   driver.name -> str
+ *
+ * Returns the name of the keyboard driver.
+ */
+VALUE a4r_API_KEYBOARD_DRIVER_name_get(VALUE self)
+{
+  KEYBOARD_DRIVER *driver;
+  Data_Get_Struct(self, KEYBOARD_DRIVER, driver);
+  return rb_str_new2(driver->name);
+}

data/ext/a4r_API_MIDI_DRIVER.c

@@ -0,0 +1,14 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   driver.name -> str
+ *
+ * Driver name
+ */
+VALUE a4r_API_MIDI_DRIVER_name_get(VALUE self)
+{
+  MIDI_DRIVER *driver;
+  Data_Get_Struct(self, MIDI_DRIVER, driver);
+  return rb_str_new2(driver->name);
+}

data/ext/a4r_API_MOUSE_DRIVER.c

@@ -0,0 +1,14 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   driver.name -> str
+ *
+ * Returns the name of the mouse driver.
+ */
+VALUE a4r_API_MOUSE_DRIVER_name_get(VALUE self)
+{
+  MOUSE_DRIVER *driver;
+  Data_Get_Struct(self, MOUSE_DRIVER, driver);
+  return rb_str_new2(driver->name);
+}

data/ext/a4r_API_PALETTE.c

@@ -0,0 +1,63 @@
+#include "allegro4r.h"
+
+void a4r_API_PALETTE_free(void *palette)
+{
+  free((PALETTE*)palette);
+}
+
+/* :nodoc: */
+VALUE a4r_API_PALETTE_alloc(VALUE klass)
+{
+  PALETTE *palette;
+  VALUE obj = Data_Make_Struct(klass, PALETTE, 0, a4r_API_PALETTE_free, palette);
+  return obj;
+}
+
+/* :nodoc: */
+VALUE a4r_API_PALETTE_initialize_copy(VALUE copy, VALUE orig)
+{
+  if (copy == orig)
+    return copy;
+
+  if (TYPE(orig) != T_DATA || RDATA(orig)->dfree != (RUBY_DATA_FUNC)a4r_API_PALETTE_free)
+    rb_raise(rb_eTypeError, "wrong argument type");
+
+  PALETTE *orig_pal, *copy_pal;
+  Data_Get_Struct(orig, PALETTE, orig_pal);
+  Data_Get_Struct(copy, PALETTE, copy_pal);
+  MEMCPY(copy_pal, orig_pal, PALETTE, 1);
+  return copy;
+}
+
+/*
+ * call-seq:
+ *   palette[index] -> an_rgb
+ *
+ * Returns the RGB element at the specified index.
+ */
+VALUE a4r_API_PALETTE_getter(VALUE self, VALUE index)
+{
+  // TODO: Index validation && converting to "array" of RGBs
+  PALETTE *palette;
+  Data_Get_Struct(self, PALETTE, palette);
+  RGB *rgb = &((*palette)[FIX2INT(index)]);
+  VALUE obj = Data_Wrap_Struct(cAPI_RGB, 0, 0, rgb);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   palette[index] = an_rgb -> an_rgb
+ *
+ * Sets the element at index to the specified RGB element.
+ */
+VALUE a4r_API_PALETTE_setter(VALUE self, VALUE index, VALUE val)
+{
+  // TODO: Index validation, val validation && converting to "array" of RGBs
+  PALETTE *palette;
+  Data_Get_Struct(self, PALETTE, palette);
+  RGB *rgb;
+  Data_Get_Struct(val, RGB, rgb);
+  (*palette)[FIX2INT(index)] = *rgb;
+  return val;
+}