allegro4r 0.0.1

data/ext/a4r_API_digital_sample_routines.c

@@ -0,0 +1,83 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   load_sample(filename) -> a_sample
+ *
+ * Loads a sample from a file, supporting both mono and stereo WAV and mono VOC
+ * files, in 8 or 16-bit formats, as well as formats handled by functions
+ * registered using register_sample_file_type. Example:
+ *   sample = load_sample(user_input)
+ *   abort_on_error("Couldn't load sample!") if sample.nil?
+ *
+ * Return value: Returns a reference to the SAMPLE or nil on error. Remember to
+ * free this sample later to avoid memory leaks.
+ */
+VALUE a4r_API_load_sample(VALUE self, VALUE filename)
+{
+  SAMPLE *s = load_sample(StringValuePtr(filename));
+  if (s == NULL)
+    return Qnil;
+
+  VALUE obj = Data_Wrap_Struct(cAPI_SAMPLE, 0, 0, s);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   destroy_sample(spl) -> nil
+ *
+ * Destroys a sample structure when you are done with it. It is safe to call
+ * this even when the sample might be playing, because it checks and will kill
+ * it off if it is active. Use this to avoid memory leaks in your program.
+ */
+VALUE a4r_API_destroy_sample(VALUE self, VALUE spl)
+{
+  SAMPLE *s;
+  Data_Get_Struct(spl, SAMPLE, s);
+  destroy_sample(s);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   play_sample(spl, vol, pan, freq, loop) -> int
+ *
+ * Triggers a sample at the specified volume, pan position, and frequency. The
+ * parameters 'vol' and 'pan' range from 0 (min/left) to 255 (max/right).
+ * Frequency is relative rather than absolute: 1000 represents the frequency
+ * that the sample was recorded at, 2000 is twice this, etc. If 'loop' is true,
+ * the sample will repeat until you call stop_sample, and can be manipulated
+ * while it is playing by calling adjust_sample. Example:
+ *   # Scream from the left speaker, twice the freq.
+ *   sound = play_sample(scream, 255, 0, 2000, false)
+ *
+ * Return value: Returns the voice number that was allocated for the sample or
+ * negative if no voices were available.
+ */
+VALUE a4r_API_play_sample(VALUE self, VALUE spl, VALUE vol, VALUE pan, VALUE freq, VALUE loop)
+{
+  SAMPLE *s;
+  Data_Get_Struct(spl, SAMPLE, s);
+  return INT2FIX(play_sample(s, FIX2INT(vol), FIX2INT(pan), FIX2INT(freq), RTEST(loop)));
+}
+
+/*
+ * call-seq:
+ *   adjust_sample(spl, vol, pan, freq, loop) -> nil
+ *
+ * Alters the parameters of a sample while it is playing (useful for
+ * manipulating looped sounds). You can alter the volume, pan, and frequency,
+ * and can also clear the loop flag, which will stop the sample when it next
+ * reaches the end of its loop. The values of the parameters are just like those
+ * of play_sample. If there are several copies of the same sample playing, this
+ * will adjust the first one it comes across. If the sample is not playing it
+ * has no effect.
+ */
+VALUE a4r_API_adjust_sample(VALUE self, VALUE spl, VALUE vol, VALUE pan, VALUE freq, VALUE loop)
+{
+  SAMPLE *s;
+  Data_Get_Struct(spl, SAMPLE, s);
+  adjust_sample(s, FIX2INT(vol), FIX2INT(pan), FIX2INT(freq), RTEST(loop));
+  return Qnil;
+}

data/ext/a4r_API_direct_access_to_video_memory.c

@@ -0,0 +1,102 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   bmp_select(bmp) -> nil
+ *
+ */
+VALUE a4r_API_bmp_select(VALUE self, VALUE bmp)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  bmp_select(bmp);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   bmp_read8(addr) -> str
+ *
+ */
+VALUE a4r_API_bmp_read8(VALUE self, VALUE addr)
+{
+  return rb_str_new((char*)&(bmp_read8(NUM2ULONG(addr))), sizeof(uint8_t));
+}
+
+/*
+ * call-seq:
+ *   bmp_read32(addr) -> str
+ *
+ */
+VALUE a4r_API_bmp_read32(VALUE self, VALUE addr)
+{
+  return rb_str_new((char*)&(bmp_read32(NUM2ULONG(addr))), sizeof(uint32_t));
+}
+
+/*
+ * call-seq:
+ *   bmp_write8(addr, c) -> nil
+ *
+ */
+VALUE a4r_API_bmp_write8(VALUE self, VALUE addr, VALUE c)
+{
+  bmp_write8(NUM2ULONG(addr), *((uint8_t*)StringValuePtr(c)));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   bmp_write32(addr, c) -> nil
+ *
+ */
+VALUE a4r_API_bmp_write32(VALUE self, VALUE addr, VALUE c)
+{
+  bmp_write32(NUM2ULONG(addr), *((uint32_t*)StringValuePtr(c)));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   bmp_write_line(bmp, line) -> num
+ *
+ * Selects the line of a bitmap that you are going to draw onto.
+ *
+ * Return value: Returns the address of the selected line for writing.
+ */
+VALUE a4r_API_bmp_write_line(VALUE self, VALUE bmp, VALUE line)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  return ULONG2NUM(bmp_write_line(bitmap, FIX2INT(line)));
+}
+
+/*
+ * call-seq:
+ *   bmp_read_line(bmp, line) -> num
+ *
+ * Selects the line of a bitmap that you are going to read from.
+ *
+ * Return value: Returns the address of the selected line for reading.
+ */
+VALUE a4r_API_bmp_read_line(VALUE self, VALUE bmp, VALUE line)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  return ULONG2NUM(bmp_read_line(bitmap, FIX2INT(line)));
+}
+
+/*
+ * call-seq:
+ *   bmp_unwrite_line(bmp, line) -> nil
+ *
+ * Releases the bitmap memory after you are finished with it. You only need to
+ * call this once at the end of a drawing operation, even if you have called
+ * bmp_write_line or bmp_read_line several times before it.
+ */
+VALUE a4r_API_bmp_unwrite_line(VALUE self, VALUE bmp)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  bmp_unwrite_line(bitmap);
+  return Qnil;
+}

data/ext/a4r_API_drawing_primitives.c

@@ -0,0 +1,114 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   clear_bitmap(bitmap) -> nil
+ *
+ * Clears the bitmap to color 0.
+ */
+VALUE a4r_API_clear_bitmap(VALUE self, VALUE bitmap)
+{
+  BITMAP *bmp;
+  Data_Get_Struct(bitmap, BITMAP, bmp);
+  clear_bitmap(bmp);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   clear_to_color(bitmap, color) -> nil
+ *
+ * Clears the bitmap to the specified color. Example:
+ *   # Clear the screen to red.
+ *   clear_to_color(bmp, makecol(255, 0, 0))
+ */
+VALUE a4r_API_clear_to_color(VALUE self, VALUE bitmap, VALUE color)
+{
+  BITMAP *bmp;
+  Data_Get_Struct(bitmap, BITMAP, bmp);
+  clear_to_color(bmp, FIX2INT(color));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   putpixel(bmp, x, y, color) -> nil
+ *
+ * Writes a pixel to the specified position in the bitmap, using the current
+ * drawing mode and the bitmap's clipping rectangle. Example:
+ *   putpixel(screen, 10, 30, some_color)
+ */
+VALUE a4r_API_putpixel(VALUE self, VALUE bmp, VALUE x, VALUE y, VALUE color)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  putpixel(bitmap, FIX2INT(x), FIX2INT(y), FIX2INT(color));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   getpixel(bmp, x, y) -> int
+ *
+ * Reads a pixel from point (x, y) in the bitmap.
+ *
+ * Return value: Returns -1 if the point lies outside the bitmap (ignoring the
+ * clipping rectangle), otherwise the value of the pixel in the color format of
+ * the bitmap.
+ *
+ * Warning: -1 is also a valid value for pixels contained in 32-bit bitmaps with
+ * alpha channel (when R,G,B,A are all equal to 255) so you can't use the test
+ * against -1 as a predicate for such bitmaps. In this cases, the only reliable
+ * predicate is is_inside_bitmap.
+ *
+ * To extract the individual color components, use the getr / getg / getb /
+ * geta family of functions.
+ */
+VALUE a4r_API_getpixel(VALUE self, VALUE bmp, VALUE x, VALUE y)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  return INT2FIX(getpixel(bitmap, FIX2INT(x), FIX2INT(y)));
+}
+
+/*
+ * call-seq:
+ *   rectfill(bmp, x1, y1, x2, y2, color) -> nil
+ *
+ * Draws a solid, filled rectangle with the two points as its opposite corners.
+ */
+VALUE a4r_API_rectfill(VALUE self, VALUE bmp, VALUE x1, VALUE y1, VALUE x2, VALUE y2, VALUE color)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  rectfill(bitmap, FIX2INT(x1), FIX2INT(y1), FIX2INT(x2), FIX2INT(y2), FIX2INT(color));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   circle(bmp, x, y, radius, color) -> nil
+ *
+ * Draws a circle with the specified centre and radius.
+ */
+VALUE a4r_API_circle(VALUE self, VALUE bmp, VALUE x, VALUE y, VALUE radius, VALUE color)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  circle(bitmap, FIX2INT(x), FIX2INT(y), FIX2INT(radius), FIX2INT(color));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   circlefill(bmp, x, y, radius, color) -> nil
+ *
+ * Draws a filled circle with the specified centre and radius. 
+ */
+VALUE a4r_API_circlefill(VALUE self, VALUE bmp, VALUE x, VALUE y, VALUE radius, VALUE color)
+{
+  BITMAP *bitmap;
+  Data_Get_Struct(bmp, BITMAP, bitmap);
+  circlefill(bitmap, FIX2INT(x), FIX2INT(y), FIX2INT(radius), FIX2INT(color));
+  return Qnil;
+}

data/ext/a4r_API_file_and_compression_routines.c

@@ -0,0 +1,27 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   get_filename(path) -> str
+ *
+ * Finds out the filename portion of a completely specified file path. Both '\'
+ * and '/' are recognized as directory separators under DOS and Windows.
+ * However, only '/' is recognized as directory separator under other platforms.
+ * Example:
+ *   name = get_executable_name
+ *   allegro_message("Running '%s'\n" % get_filename(name))
+ *
+ * Note that Allegro won't perform any IO operations during the verification.
+ * This means that if you have '/a/path/like/this/', which doesn't have a
+ * filename, the function will return an empty string. However, if you have
+ * '/a/path/like/this', Allegro will return 'this', even if it is a valid
+ * directory.
+ *
+ * Return value: Returns a string with the filename, or the beginning of 'path'
+ * if no valid filename is found (eg. you are processing a path with backslashes
+ * under Unix).
+ */
+VALUE a4r_API_get_filename(VALUE self, VALUE path)
+{
+  return rb_str_new2(get_filename(StringValuePtr(path)));
+}

data/ext/a4r_API_fixed_point_math_routines.c

@@ -0,0 +1,98 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   itofix(x) -> num
+ *
+ * Converts an integer to fixed point. This is the same thing as x<<16. Remember
+ * that overflows (trying to convert an integer greater than 32767) and
+ * underflows (trying to convert an integer lesser than -32768) are not detected
+ * even in debug builds! The values simply "wrap around". Example:
+ *   # This conversion is OK.
+ *   number = itofix(100)
+ *   ASSERT(fixtoi(number) == 100)
+ *   number = itofix(64000)
+ *   # This check will fail in debug builds.
+ *   ASSERT(fixtoi(number) == 64000)
+ *
+ * Return value: Returns the value of the integer converted to fixed point
+ * ignoring overflows.
+ */
+VALUE a4r_API_itofix(VALUE self, VALUE x)
+{
+  return LONG2NUM(itofix(FIX2INT(x)));
+}
+
+/*
+ * call-seq:
+ *   ftofix(x) -> num
+ *
+ * Converts a floating point value to fixed point. Unlike itofix, this function
+ * clamps values which could overflow the type conversion, setting 'errno' to
+ * ERANGE in the process if this happens. Example:
+ *   number = itofix(-40000)
+ *   ASSERT(fixfloor(number) == -32768)
+ *   number = itofix(64000)
+ *   ASSERT(fixfloor(number) == 32767)
+ *   ASSERT(errno == 0) # This will fail.
+ *
+ * Return value: Returns the value of the floating point value converted to
+ * fixed point clamping overflows (and setting 'errno').
+ */
+VALUE a4r_API_ftofix(VALUE self, VALUE x)
+{
+  return LONG2NUM(ftofix(NUM2DBL(x)));
+}
+
+/*
+ * call-seq:
+ *   fixtof(x) -> float
+ *
+ * Converts fixed point to floating point. Example:
+ *   # This will put 33.33333 into 'result'.
+ *   result = fixtof(itofix(100) / 3)
+ *   # This will put 16.66666 into 'result'.
+ *   result = fixtof(itofix(100) / 6)
+ */
+VALUE a4r_API_fixtof(VALUE self, VALUE x)
+{
+  return rb_float_new(fixtof(NUM2LONG(x)));
+}
+
+/*
+ * call-seq:
+ *   fixmul(x, y) -> float
+ *
+ * A fixed point value can be multiplied or divided by an integer with the
+ * normal '*' and '/' operators. To multiply two fixed point values, though, you
+ * must use this function.
+ *
+ * If an overflow occurs, 'errno' will be set and the maximum possible value
+ * will be returned, but 'errno' is not cleared if the operation is successful.
+ * This means that if you are going to test for overflow you should set
+ * 'errno=0' before calling fixmul. Example
+ *   # This will put 30000 into 'result'.
+ *   result = fixmul(itofix(10), itofix(3000))
+ *   # But this overflows, and sets 'errno'.
+ *   result = fixmul(itofix(100), itofix(3000))
+ *   ASSERT(errno == 0)
+ *
+ * Return value: Returns the clamped result of multiplying 'x' by 'y', setting
+ * 'errno' to ERANGE if there was an overflow.
+ */
+VALUE a4r_API_fixmul(VALUE self, VALUE x, VALUE y)
+{
+  return rb_float_new(fixmul(NUM2LONG(x), NUM2LONG(y)));
+}
+
+/*
+ * call-seq:
+ *   fixsqrt(x) -> float
+ *
+ * This finds out the non negative square root of 'x'. If 'x' is negative,
+ * 'errno' is set to EDOM and the function returns zero.
+ */
+VALUE a4r_API_fixsqrt(VALUE self, VALUE x)
+{
+  return rb_float_new(fixsqrt(NUM2LONG(x)));
+}

data/ext/a4r_API_fonts.c

@@ -0,0 +1,147 @@
+#include "allegro4r.h"
+
+/*
+ * call-seq:
+ *   load_font(filename, pal, param) -> a_fnt or nil
+ *
+ * Loads a font from a file. At present, this supports loading fonts from a GRX
+ * format .fnt file, a 8x8 or 8x16 BIOS format .fnt file, a datafile or any
+ * bitmap format that can be loaded by load_bitmap.
+ *
+ * If the font contains palette information, then the palette is returned in the
+ * second parameter, which should be an array of 256 RGB structures (a PALETTE).
+ * The pal argument may be nil. In this case, the palette data, if present, is
+ * simply not returned.
+ *
+ * The third parameter can be used to pass specific information to a custom
+ * loader routine. Normally, you can just leave this as nil. Note that another
+ * way of loading fonts is embedding them into a datafile and using the datafile
+ * related functions.
+ *
+ * Example:
+ *   myfont = load_font("my_font.pcx", palette, nil)
+ *   abort_on_error("Couldn't load font!") if myfont.nil?
+ *   ...
+ *   textout_centre_ex(screen, myfont, "This is my own pretty font!",
+ *     SCREEN_W / 2, SCREEN_H / 2, white, black)
+ *   ...
+ *   destroy_font(myfont)
+ *
+ * Returns a reference to the font or nil on error. Remember that you are
+ * responsible for destroying the font when you are finished with it to avoid
+ * memory leaks.
+ */
+VALUE a4r_API_load_font(VALUE self, VALUE filename, VALUE pal, VALUE param)
+{
+  PALETTE *palette;
+  RGB *rgb;
+  if (pal == Qnil)
+    rgb = NULL;
+  else
+  {
+    Data_Get_Struct(pal, PALETTE, palette);
+    rgb = *palette;
+  }
+
+  void *p;
+  if (param == Qnil)
+    p = NULL;
+  else
+    p = StringValuePtr(param);
+
+  FONT *font = load_font(StringValuePtr(filename), rgb, p);
+  if (font == NULL)
+    return Qnil;
+
+  VALUE obj = Data_Wrap_Struct(cAPI_FONT, 0, 0, font);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   destroy_font(f) -> nil
+ *
+ * Frees the memory being used by a font structure. Don't use this on the
+ * default global Allegro font or any text routines using it could crash. You
+ * should use this only on fonts you have loaded manually after you are done
+ * with them, to prevent memory leaks in your program.
+ */
+VALUE a4r_API_destroy_font(VALUE self, VALUE f)
+{
+  FONT *font;
+  Data_Get_Struct(f, FONT, font);
+  destroy_font(font);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   extract_font_range(f, begin, end) -> a_fnt or nil
+ *
+ * This function extracts a character range from a font and returns a new font
+ * that contains only the range of characters selected by this function. You can
+ * pass -1 for either the lower or upper bound if you want to select all
+ * characters from the start or to the end of the font. Example:
+ *   # Create a font of only capital letters
+ *   capitals = extract_font_range(myfont, ?A, ?Z)
+ *
+ *   # Create a copy of the font
+ *   fontcopy = extract_font_range(myfont, -1, -1)
+ *   ...
+ *   destroy_font(capitals)
+ *   destroy_font(fontcopy)
+ *
+ * Returns a reference to the new font or nil on error. Remember that you are
+ * responsible for destroying the font when you are finished with it to avoid
+ * memory leaks.
+ */
+VALUE a4r_API_extract_font_range(VALUE self, VALUE f, VALUE begin, VALUE end)
+{
+  FONT *from, *to;
+  Data_Get_Struct(f, FONT, from);
+  to = extract_font_range(from, FIX2INT(begin), FIX2INT(end));
+  if (to == NULL)
+    return Qnil;
+  VALUE obj = Data_Wrap_Struct(cAPI_FONT, 0, 0, to);
+  return obj;
+}
+
+/*
+ * call-seq:
+ *   merge_fonts(f1, f2) -> a_fnt or nil
+ *
+ * This function merges the character ranges from two fonts and returns a new
+ * font containing all characters in the old fonts. In general, you cannot merge
+ * fonts of different types (eg, TrueType fonts and bitmapped fonts), but as a
+ * special case, this function can promote a monochrome bitmapped font to a
+ * color font and merge those. Example:
+ *   # Create a font that contains the capatials from
+ *   # the fancy font but other characters from myfont
+ *   lower_range = extract_font_range(myfont, -1, ?A - 1)
+ *   upper_range = extract_font_range(myfont, ?Z + 1, -1)
+ *   capitals = extract_font_range(myfancy_font, ?A, ?Z)
+ *
+ *   tempfont = merge_fonts(lower_range, capitals)
+ *   combined_font = merge_fonts(tempfont, upper_range);
+ *
+ *   # Clean up temporary fonts
+ *   destroy_font(lower_range)
+ *   destroy_font(upper_range)
+ *   destroy_font(capitals)
+ *   destroy_font(tempfont)
+ *
+ * Returns a reference to the new font or nil on error. Remember that you are
+ * responsible for destroying the font when you are finished with it to avoid
+ * memory leaks.
+ */
+VALUE a4r_API_merge_fonts(VALUE self, VALUE f1, VALUE f2)
+{
+  FONT *font1, *font2, *ret;
+  Data_Get_Struct(f1, FONT, font1);
+  Data_Get_Struct(f2, FONT, font2);
+  ret = merge_fonts(font1, font2);
+  if (ret == NULL)
+    return Qnil;
+  VALUE obj = Data_Wrap_Struct(cAPI_FONT, 0, 0, ret);
+  return obj;
+}