devil 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (C) 2006 Jaroslaw Tworek
+Copyright (C) 2009 John Mair
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jaroslaw Tworek < dev.jrx@gmail.com >
+  John Mair, http://banisterfiend.wordpress.com

data/README

@@ -0,0 +1,25 @@
+Devil version 0.1.0
+
+* Original author: Jaroslaw Tworek <dev.jrx@gmail.com>
+* Current maintainer: John Mair (banisterfiend) http://banisterfiend.wordpress.com
+
+Ruby bindings for the Developer's Image Library
+You need DevIL installed to build this extension
+
+For debian:
+* install the libdevil and libdevil-dev packages
+
+Or go here to download the libraries:
+http://openil.sourceforge.net
+
+It's also worth having Ruby OpenGL bindings to use the extensions.
+
+http://www2.geganet.net/~yoshi/
+
+See INSTALL for installation instructions.
+
+For now, there is support for just a subset of DevIL functions, but it is enough
+for 95% things you may want to do.
+
+For example uses, see test/ directory
+

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rake/clean'
+require 'rake/extensiontask'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+DEVIL_VERSION = "0.1.0"
+
+dlext = Config::CONFIG['DLEXT']
+
+CLEAN.include("ext/**/*.#{dlext}", "ext/**/.log", "ext/**/.o", "ext/**/*~", "ext/**/*#*", "ext/**/.obj", "ext/**/.def", "ext/**/.pdb")
+CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o", "doc/**")
+
+spec = Gem::Specification.new do |s|
+    s.name = "devil"
+    s.summary = "ruby bindings for devil cross platform image loading library"
+    s.description = s.summary
+    s.version = DEVIL_VERSION
+    s.author = "Jaroslaw Tworek, John Mair (banisterfiend)"
+    s.email = 'jrmair@gmail.com'
+    s.date = Time.now.strftime '%Y-%m-%d'
+    s.require_path = 'lib'
+    s.homepage = "http://banisterfiend.wordpress.com"
+    s.platform = Gem::Platform::RUBY
+    s.extensions = FileList["ext/**/extconf.rb"]
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README"]
+    s.rdoc_options << '--main' << 'README'
+    s.files = ["Rakefile", "README", "LICENSE", "lib/devil.rb"] +
+        FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c"].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = false
+end
+
+Rake::ExtensionTask.new('devil', spec)  do |ext|
+    ext.config_script = 'extconf.rb' 
+    ext.cross_compile = true                
+    ext.cross_platform = 'i386-mswin32'
+end
+
+Rake::TestTask.new do |t|
+    t.libs << "lib"
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.rdoc_files.include("README", "lib/devil.rb")
+end
+

data/ext/devil/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+have_library("IL", "ilInit");
+have_library("ILU", "iluInit");
+have_library("ILUT", "ilutInit");
+
+create_makefile('devil')

data/ext/devil/ruby_devil_ext.c

@@ -0,0 +1,9 @@
+#include "ruby_devil_ext.h"
+
+
+void
+Init_devil() {
+    InitializeIL();
+    InitializeILU();
+    InitializeILUT();
+}

data/ext/devil/ruby_devil_ext.h

@@ -0,0 +1,9 @@
+#include <ruby.h>
+
+#include <stdio.h>
+
+typedef struct RArray RArray;
+
+extern void InitializeIL();
+extern void InitializeILU();
+extern void InitializeILUT();

data/ext/devil/ruby_il.c

@@ -0,0 +1,375 @@
+#include "ruby_devil_ext.h"
+#include <IL/il.h>
+
+struct ImageData {
+    ILubyte* data;
+};
+
+static VALUE mIL;
+static VALUE cImageData;
+static VALUE cNullImageData;
+
+
+inline ILubyte* ImageData2Arr(VALUE obj) {
+    struct ImageData* arr;
+    Data_Get_Struct(obj, struct ImageData, arr);
+    return arr->data;
+}
+
+inline VALUE MakeImageData(ILubyte* image_data) {
+    struct ImageData* c_data;
+    VALUE ret = Data_Make_Struct(cImageData, struct ImageData, 0, NULL, c_data);
+    c_data->data = image_data;
+    return ret;    
+}
+
+
+static VALUE il_Init(VALUE obj) {
+    ilInit();
+    return Qnil;
+}
+
+static VALUE il_GenImages(VALUE obj, VALUE num_names) {
+    ILsizei num = NUM2INT(num_names);
+    ILuint* names = ALLOC_N(ILuint, num);
+    RArray* ret;
+    int i;
+
+    if (!names)
+	rb_raise(rb_eRuntimeError, "IL.GenImages memory allocation");
+
+    ilGenImages(num, names);
+
+    ret = RARRAY( rb_ary_new2(num));
+    for(i = 0; i < num; ++i)
+	rb_ary_push( (VALUE)ret, INT2NUM(names[i]));
+    free(names);
+
+    return (VALUE)ret;
+}
+
+static VALUE il_BindImage(VALUE obj, VALUE image) {
+    ILuint u_image = NUM2INT(image);
+    ilBindImage(u_image);
+    return Qnil;
+}
+
+static VALUE il_DeleteImages(VALUE obj, VALUE images) {
+    ILsizei num;
+    ILuint* u_images;
+    RArray* ary;
+    VALUE entry;
+    int i = 0;
+
+    if(TYPE(images) != T_ARRAY)
+	rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(images));
+
+    ary = RARRAY(images);
+    num = RARRAY_LEN(images);
+    u_images = ALLOC_N(ILuint, num);
+
+    for(i = 0; i < num; ++i) {
+	entry = rb_ary_entry((VALUE)ary, i);
+	u_images[i] = NUM2INT(entry);
+    }
+
+    ilDeleteImages(num, u_images);
+
+    free(u_images);
+    return Qnil;
+}
+
+static VALUE il_LoadImage(VALUE obj, VALUE rb_filename) {
+    char* filename = STR2CSTR(rb_filename);
+    ILboolean load = ilLoadImage(filename);
+    return load ? Qtrue : Qfalse;
+}
+
+static VALUE il_Load(VALUE obj, VALUE rb_type, VALUE rb_filename) {
+    ILenum type = NUM2INT(rb_type);
+    char* filename = STR2CSTR(rb_filename);
+
+    ILboolean load = ilLoad(type, filename);
+    return load ? Qtrue : Qfalse;
+}
+
+static VALUE il_SaveImage(VALUE obj, VALUE rb_filename) {
+    char* filename = STR2CSTR(rb_filename);
+    ILboolean load = ilSaveImage(filename);
+
+    return load ? Qtrue : Qfalse;
+}
+
+static VALUE il_Save(VALUE obj, VALUE rb_type, VALUE rb_filename) {
+    ILenum type = NUM2INT(rb_type);
+    char* filename = STR2CSTR(rb_filename);
+    ILboolean load = ilSave(type, filename);
+
+    return load ? Qtrue : Qfalse;
+}
+
+static VALUE il_TexImage(VALUE obj, VALUE rb_width, VALUE rb_height,
+                         VALUE rb_depth, VALUE rb_bpp, VALUE rb_format, VALUE rb_type,
+                         VALUE rb_data) {
+    ILuint width = NUM2INT(rb_width);
+    ILuint height = NUM2INT(rb_height);
+    ILuint depth = NUM2INT(rb_depth);
+    ILubyte bpp = NUM2INT(rb_bpp);
+    ILenum format = NUM2INT(rb_format);
+    ILenum type = NUM2INT(rb_type);
+    ILvoid* data = ImageData2Arr(rb_data);
+
+    ILboolean flag = ilTexImage(width, height, depth,
+                                bpp, format, type, data);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE il_GetData(VALUE obj) {
+    ILubyte* data = ilGetData();
+    return MakeImageData(data);
+}
+
+ILuint ilCopyPixels(ILuint XOff, ILuint YOff, ILuint ZOff, ILuint Width,
+                    ILuint Height, ILuint Depth, ILenum Format, ILenum Type, ILvoid
+                    *Data);
+
+static VALUE il_CopyPixels(VALUE obj, VALUE rb_XOff, VALUE rb_YOff, VALUE rb_ZOff,
+                           VALUE rb_Width, VALUE rb_Height, VALUE rb_Depth, VALUE rb_Format,
+                           VALUE rb_Type, VALUE rb_data) {
+    ILuint XOff = NUM2INT(rb_XOff);
+    ILuint YOff = NUM2INT(rb_YOff);
+    ILuint ZOff = NUM2INT(rb_ZOff);
+    ILuint Width = NUM2INT(rb_Width);
+    ILuint Height = NUM2INT(rb_Height);
+    ILuint Depth = NUM2INT(rb_Depth);
+    ILenum Format = NUM2INT(rb_Format);
+    ILenum Type = NUM2INT(rb_Type);
+    ILvoid* data = ImageData2Arr(rb_data);
+
+    ILuint uint = ilCopyPixels(XOff, YOff, ZOff, Width, Height, Depth, Format, Type, data);
+    return INT2FIX(uint);    
+}
+
+static VALUE il_SetData(VALUE obj, VALUE rb_Data) {
+    ILvoid* data = ImageData2Arr(rb_Data);
+    ILboolean flag = ilSetData(data);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE il_SetPixels(VALUE obj, VALUE rb_XOff, VALUE rb_YOff, VALUE rb_ZOff,
+                          VALUE rb_Width, VALUE rb_Height, VALUE rb_Depth, VALUE rb_Format,
+                          VALUE rb_Type, VALUE rb_data) {
+    ILuint XOff = NUM2INT(rb_XOff);
+    ILuint YOff = NUM2INT(rb_YOff);
+    ILuint ZOff = NUM2INT(rb_ZOff);
+    ILuint Width = NUM2INT(rb_Width);
+    ILuint Height = NUM2INT(rb_Height);
+    ILuint Depth = NUM2INT(rb_Depth);
+    ILenum Format = NUM2INT(rb_Format);
+    ILenum Type = NUM2INT(rb_Type);
+    ILvoid* data = ImageData2Arr(rb_data);
+
+    ilSetPixels(XOff, YOff, ZOff, Width, Height, Depth, Format, Type, data);
+    return Qnil;
+}
+
+
+static VALUE il_CopyImage(VALUE obj, VALUE rb_Src){
+    ILuint Src = NUM2INT(rb_Src);
+    ILboolean flag = ilCopyImage(Src);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE il_OverlayImage(VALUE obj, VALUE rb_Source, VALUE rb_XCoord,
+                             VALUE rb_YCoord, VALUE rb_ZCoord) {
+    ILuint Source = NUM2INT(rb_Source);
+    ILint XCoord = NUM2INT(rb_XCoord);
+    ILint YCoord = NUM2INT(rb_YCoord);
+    ILint ZCoord = NUM2INT(rb_ZCoord);
+    ILboolean flag = ilOverlayImage(Source, XCoord, YCoord,ZCoord);
+    
+    return flag ? Qtrue : Qfalse;
+}
+
+
+static VALUE il_Blit(VALUE obj, VALUE rb_Source, VALUE rb_DestX, VALUE
+                     rb_DestY, VALUE rb_DestZ, VALUE rb_SrcX, VALUE rb_SrcY, VALUE
+                     rb_SrcZ, VALUE rb_Width, VALUE rb_Height, VALUE rb_Depth) {
+    ILuint Source = NUM2INT(rb_Source);
+    ILint DestX = NUM2INT(rb_DestX);
+    ILint DestY = NUM2INT(rb_DestY);
+    ILint DestZ = NUM2INT(rb_DestZ);
+    ILint SrcX = NUM2INT(rb_SrcX);
+    ILint SrcY = NUM2INT(rb_SrcY);
+    ILint SrcZ = NUM2INT(rb_SrcZ);
+    ILuint Width = NUM2INT(rb_Width);
+    ILuint Height = NUM2INT(rb_Height);
+    ILuint Depth = NUM2INT(rb_Depth);
+
+    ILboolean flag = ilBlit(Source, DestX,DestY, DestZ,SrcX, SrcY, SrcZ,
+                            Width,Height,Depth);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE il_GetError(VALUE obj) {
+    ILenum num = ilGetError();
+    return INT2FIX(num);
+}
+
+static VALUE il_ActiveMipmap(VALUE obj, VALUE rb_Number) {
+    ILuint Number = NUM2INT(rb_Number);
+    ILboolean flag = ilActiveMipmap(Number);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE il_ActiveImage(VALUE obj, VALUE rb_Number){
+    ILuint Number = NUM2INT(rb_Number);
+    ILboolean flag = ilActiveImage(Number);
+    return flag ? Qtrue : Qfalse;
+}
+
+/* added by banisterfiend */
+static VALUE il_Enable(VALUE obj, VALUE rb_mode) {
+    ILenum mode = NUM2INT(rb_mode);
+
+    ILboolean flag = ilEnable(mode);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE il_GetInteger(VALUE obj, VALUE rb_mode) {
+    ILenum mode = NUM2INT(rb_mode);
+
+    ILint result = ilGetInteger(mode);
+    return INT2NUM(result);
+}
+/* end of banisterfiend additions */
+
+void
+InitializeIL() {
+    mIL = rb_define_module("IL");
+    //////////////////////////////////
+    //CLASSES
+    //////////////////////////////////
+    cImageData = rb_define_class_under(mIL, "ImageData", rb_cObject);
+    cNullImageData = MakeImageData(NULL);
+    rb_define_const(cImageData, "NullData", cNullImageData);
+    //////////////////////////////////
+    //METHODS
+    //////////////////////////////////
+    rb_define_module_function(mIL, "Init", il_Init, 0);
+    rb_define_module_function(mIL, "GenImages", il_GenImages, 1);
+    rb_define_module_function(mIL, "BindImage", il_BindImage, 1);
+    rb_define_module_function(mIL, "DeleteImages", il_DeleteImages, 1);
+    rb_define_module_function(mIL, "LoadImage", il_LoadImage, 1);
+    rb_define_module_function(mIL, "Load", il_Load, 2);
+    rb_define_module_function(mIL, "SaveImage", il_SaveImage, 1);
+    rb_define_module_function(mIL, "Save", il_Save, 2);
+    rb_define_module_function(mIL, "TexImage", il_TexImage, 7);
+    rb_define_module_function(mIL, "GetData", il_GetData, 0);
+    rb_define_module_function(mIL, "CopyPixels", il_CopyPixels, 9);
+    rb_define_module_function(mIL, "SetData", il_SetData, 1);
+    rb_define_module_function(mIL, "SetPixels", il_SetPixels, 9);
+    rb_define_module_function(mIL, "CopyImage", il_CopyImage, 1);
+    rb_define_module_function(mIL, "OverlayImage", il_OverlayImage, 4);
+    rb_define_module_function(mIL, "Blit", il_Blit, 10);
+    rb_define_module_function(mIL, "GetError", il_GetError, 0);
+    rb_define_module_function(mIL, "ActiveMipmap", il_ActiveMipmap, 1);
+    rb_define_module_function(mIL, "ActiveImage", il_ActiveImage, 1);
+
+    // METHODS ADDED BY BANISTERFIEND
+    rb_define_module_function(mIL, "Enable", il_Enable, 1);
+    rb_define_module_function(mIL, "GetInteger", il_GetInteger, 1);
+
+    
+    //////////////////////////////////
+    //CONSTANTS
+    //////////////////////////////////
+    rb_define_const(mIL, "TYPE_UNKNOWN", INT2NUM(IL_TYPE_UNKNOWN));
+    rb_define_const(mIL, "BMP", INT2NUM(IL_BMP));
+    rb_define_const(mIL, "CUT", INT2NUM(IL_CUT));
+    rb_define_const(mIL, "DOOM", INT2NUM(IL_DOOM));
+    rb_define_const(mIL, "DOOM_FLAT", INT2NUM(IL_DOOM_FLAT));
+    rb_define_const(mIL, "ICO", INT2NUM(IL_ICO));
+    rb_define_const(mIL, "JPG", INT2NUM(IL_JPG));
+    rb_define_const(mIL, "JFIF", INT2NUM(IL_JFIF));
+    rb_define_const(mIL, "LBM", INT2NUM(IL_LBM));
+    rb_define_const(mIL, "PCD", INT2NUM(IL_PCD));
+    rb_define_const(mIL, "PCX", INT2NUM(IL_PCX));
+    rb_define_const(mIL, "PIC", INT2NUM(IL_PIC));
+    rb_define_const(mIL, "PNG", INT2NUM(IL_PNG));
+    rb_define_const(mIL, "PNM", INT2NUM(IL_PNM));
+    rb_define_const(mIL, "SGI", INT2NUM(IL_SGI));
+    rb_define_const(mIL, "TGA", INT2NUM(IL_TGA));
+    rb_define_const(mIL, "TIF", INT2NUM(IL_TIF));
+    rb_define_const(mIL, "CHEAD", INT2NUM(IL_CHEAD));
+    rb_define_const(mIL, "RAW", INT2NUM(IL_RAW));
+    rb_define_const(mIL, "MDL", INT2NUM(IL_MDL));
+    rb_define_const(mIL, "WAL", INT2NUM(IL_WAL));
+    rb_define_const(mIL, "LIF", INT2NUM(IL_LIF));
+    rb_define_const(mIL, "MNG", INT2NUM(IL_MNG));
+    rb_define_const(mIL, "JNG", INT2NUM(IL_JNG));
+    rb_define_const(mIL, "GIF", INT2NUM(IL_GIF));
+    rb_define_const(mIL, "DDS", INT2NUM(IL_DDS));
+    rb_define_const(mIL, "DCX", INT2NUM(IL_DCX));
+    rb_define_const(mIL, "PSD", INT2NUM(IL_PSD));
+    rb_define_const(mIL, "EXIF", INT2NUM(IL_EXIF));
+    rb_define_const(mIL, "PSP", INT2NUM(IL_PSP));
+    rb_define_const(mIL, "PIX", INT2NUM(IL_PIX));
+    rb_define_const(mIL, "PXR", INT2NUM(IL_PXR));
+    rb_define_const(mIL, "XPM", INT2NUM(IL_XPM));
+    rb_define_const(mIL, "HDR", INT2NUM(IL_HDR));
+    rb_define_const(mIL, "JASC_PAL", INT2NUM(IL_JASC_PAL));
+
+    rb_define_const(mIL, "COLOUR_INDEX", INT2NUM(IL_COLOUR_INDEX));
+    rb_define_const(mIL, "COLOR_INDEX", INT2NUM(IL_COLOR_INDEX));
+    rb_define_const(mIL, "RGB", INT2NUM(IL_RGB));
+    rb_define_const(mIL, "RGBA", INT2NUM(IL_RGBA));
+    rb_define_const(mIL, "BGR", INT2NUM(IL_BGR));
+    rb_define_const(mIL, "BGRA", INT2NUM(IL_BGRA));
+    rb_define_const(mIL, "LUMINANCE", INT2NUM(IL_LUMINANCE));
+    rb_define_const(mIL, "LUMINANCE_ALPHA", INT2NUM(IL_LUMINANCE_ALPHA));
+
+    rb_define_const(mIL, "UNSIGNED_BYTE", INT2NUM(IL_UNSIGNED_BYTE));
+    rb_define_const(mIL, "SHORT", INT2NUM(IL_SHORT));
+    rb_define_const(mIL, "UNSIGNED_SHORT", INT2NUM(IL_UNSIGNED_SHORT));
+    rb_define_const(mIL, "INT", INT2NUM(IL_INT));
+    rb_define_const(mIL, "UNSIGNED_INT", INT2NUM(IL_UNSIGNED_INT));
+    rb_define_const(mIL, "FLOAT", INT2NUM(IL_FLOAT));
+    rb_define_const(mIL, "DOUBLE", INT2NUM(IL_DOUBLE));
+
+    rb_define_const(mIL, "NO_ERROR", INT2NUM(IL_NO_ERROR));
+    rb_define_const(mIL, "INVALID_ENUM", INT2NUM(IL_INVALID_ENUM));
+    rb_define_const(mIL, "OUT_OF_MEMORY", INT2NUM(IL_OUT_OF_MEMORY));
+    rb_define_const(mIL, "FORMAT_NOT_SUPPORTED", INT2NUM(IL_FORMAT_NOT_SUPPORTED));
+    rb_define_const(mIL, "INTERNAL_ERROR", INT2NUM(IL_INTERNAL_ERROR));
+    rb_define_const(mIL, "INVALID_VALUE", INT2NUM(IL_INVALID_VALUE));
+    rb_define_const(mIL, "ILLEGAL_OPERATION", INT2NUM(IL_ILLEGAL_OPERATION));
+    rb_define_const(mIL, "ILLEGAL_FILE_VALUE", INT2NUM(IL_ILLEGAL_FILE_VALUE));
+    rb_define_const(mIL, "INVALID_FILE_HEADER", INT2NUM(IL_INVALID_FILE_HEADER));
+    rb_define_const(mIL, "INVALID_PARAM", INT2NUM(IL_INVALID_PARAM));
+    rb_define_const(mIL, "COULD_NOT_OPEN_FILE", INT2NUM(IL_COULD_NOT_OPEN_FILE));
+    rb_define_const(mIL, "INVALID_EXTENSION", INT2NUM(IL_INVALID_EXTENSION));
+    rb_define_const(mIL, "FILE_ALREADY_EXISTS", INT2NUM(IL_FILE_ALREADY_EXISTS));
+    rb_define_const(mIL, "OUT_FORMAT_SAME", INT2NUM(IL_OUT_FORMAT_SAME));
+    rb_define_const(mIL, "STACK_OVERFLOW", INT2NUM(IL_STACK_OVERFLOW));
+    rb_define_const(mIL, "STACK_UNDERFLOW", INT2NUM(IL_STACK_UNDERFLOW));
+    rb_define_const(mIL, "INVALID_CONVERSION", INT2NUM(IL_INVALID_CONVERSION));
+    rb_define_const(mIL, "BAD_DIMENSIONS", INT2NUM(IL_BAD_DIMENSIONS));
+    rb_define_const(mIL, "FILE_READ_ERROR", INT2NUM(IL_FILE_READ_ERROR)); 
+    rb_define_const(mIL, "FILE_WRITE_ERROR", INT2NUM(IL_FILE_WRITE_ERROR));
+    rb_define_const(mIL, "LIB_GIF_ERROR", INT2NUM(IL_LIB_GIF_ERROR));
+    rb_define_const(mIL, "LIB_JPEG_ERROR", INT2NUM(IL_LIB_JPEG_ERROR));
+    rb_define_const(mIL, "LIB_PNG_ERROR", INT2NUM(IL_LIB_PNG_ERROR));
+    rb_define_const(mIL, "LIB_TIFF_ERROR", INT2NUM(IL_LIB_TIFF_ERROR));
+    rb_define_const(mIL, "LIB_MNG_ERROR", INT2NUM(IL_LIB_MNG_ERROR));
+    rb_define_const(mIL, "UNKNOWN_ERROR", INT2NUM(IL_UNKNOWN_ERROR));
+
+    // CONSTANTS BELOW ADDED BY BANISTERFIEND
+    rb_define_const(mIL, "IMAGE_WIDTH", INT2NUM(IL_IMAGE_WIDTH));
+    rb_define_const(mIL, "IMAGE_HEIGHT", INT2NUM(IL_IMAGE_HEIGHT));
+    rb_define_const(mIL, "FILE_OVERWRITE", INT2NUM(IL_FILE_OVERWRITE));
+}
+//////////////////////////////////////////
+
+//////////////////////////////////////////
+

data/ext/devil/ruby_ilu.c

@@ -0,0 +1,121 @@
+#include <ruby.h>
+#include <IL/ilu.h>
+#include "ruby_devil_ext.h"
+
+static VALUE mILU;
+
+static VALUE ilu_Init(VALUE obj) {
+    iluInit();
+    return Qnil;
+}
+
+static VALUE ilu_ErrorString(VALUE obj, VALUE rb_error) {
+    ILenum num = NUM2INT(rb_error);
+    const char* error = iluErrorString(num);
+    return rb_str_new2(error);
+}
+
+static VALUE ilu_Alienify(VALUE obj) {
+    ILboolean flag = iluAlienify();
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_BlurAvg(VALUE obj, VALUE rb_iter) {
+    ILuint iter = NUM2INT(rb_iter);
+    ILboolean flag = iluBlurAvg(iter);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_BlurGaussian(VALUE obj, VALUE rb_iter) {
+    ILuint iter = NUM2INT(rb_iter);
+    ILboolean flag = iluBlurGaussian(iter);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_Contrast(VALUE obj, VALUE rb_cont) {
+    ILfloat cont = NUM2DBL(rb_cont);
+    ILboolean flag = iluContrast(cont);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_Equalize(VALUE obj) {
+    ILboolean flag = iluEqualize();
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_GammaCorrect (VALUE obj, VALUE rb_gamma) {
+    ILfloat gamma = NUM2DBL(rb_gamma);
+    ILboolean flag = iluGammaCorrect(gamma);
+    return flag ? Qtrue : Qfalse;
+}
+static VALUE ilu_Negative (VALUE obj) {
+    ILboolean flag = iluNegative();
+    return flag ? Qtrue : Qfalse;
+}
+static VALUE ilu_Noisify (VALUE obj, VALUE rb_tolerance) {
+    ILclampf tolerance = NUM2DBL(rb_tolerance);
+    ILboolean flag = iluNoisify(tolerance);
+    return flag ? Qtrue : Qfalse;
+}
+static VALUE ilu_Pixelize (VALUE obj, VALUE rb_pix_size) {
+    ILuint pix = NUM2INT(rb_pix_size);
+    ILboolean flag = iluPixelize(pix);
+    return flag ? Qtrue : Qfalse;
+}
+static VALUE ilu_Sharpen (VALUE obj, VALUE rb_factor, VALUE rb_iter) {
+    ILfloat factor = NUM2DBL(rb_factor);
+    ILuint iter = NUM2INT(rb_iter);
+    ILboolean flag = iluSharpen(factor, iter);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_Scale(VALUE obj, VALUE rb_Width, VALUE rb_Height, VALUE rb_Depth) {
+    ILuint Width = NUM2INT(rb_Width);
+    ILuint Height = NUM2INT(rb_Height);
+    ILuint Depth = NUM2INT(rb_Depth);
+    ILboolean flag = iluScale(Width, Height, Depth);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_ImageParameter(VALUE obj, VALUE rb_PName, VALUE rb_Param) {
+    ILenum PName = NUM2INT(rb_PName);
+    ILenum Param = NUM2INT(rb_Param);
+    iluImageParameter(PName, Param);
+    return Qnil;
+}
+
+static VALUE ilu_BuildMipmaps(VALUE obj) {
+    ILboolean flag = iluBuildMipmaps();
+    return flag ? Qtrue : Qfalse;
+}
+
+void
+InitializeILU() {
+    mILU = rb_define_module("ILU");
+    rb_define_module_function(mILU, "Init", ilu_Init, 0);
+    rb_define_module_function(mILU, "ErrorString", ilu_ErrorString, 1);
+    rb_define_module_function(mILU, "Alienify", ilu_Alienify, 0);
+    rb_define_module_function(mILU, "BlurAvg", ilu_BlurAvg, 1);
+    rb_define_module_function(mILU, "BlurGaussian", ilu_BlurGaussian, 1);
+    rb_define_module_function(mILU, "Contrast",ilu_Contrast , 1);
+    rb_define_module_function(mILU, "Equalize",ilu_Equalize , 0);
+    rb_define_module_function(mILU, "GammaCorrect",ilu_GammaCorrect , 1);
+    rb_define_module_function(mILU, "Negative", ilu_Negative , 0);
+    rb_define_module_function(mILU, "Noisify", ilu_Noisify , 1);
+    rb_define_module_function(mILU, "Pixelize", ilu_Pixelize , 1);
+    rb_define_module_function(mILU, "Sharpen", ilu_Sharpen, 2);
+    rb_define_module_function(mILU, "Scale", ilu_Scale , 3);
+    rb_define_module_function(mILU, "ImageParameter", ilu_ImageParameter , 2);
+    rb_define_module_function(mILU, "BuildMipmaps",  ilu_BuildMipmaps, 0);
+
+    rb_define_const(mILU, "FILTER", INT2NUM(ILU_FILTER));
+    rb_define_const(mILU, "NEAREST", INT2NUM(ILU_NEAREST));
+    rb_define_const(mILU, "LINEAR", INT2NUM(ILU_LINEAR));
+    rb_define_const(mILU, "BILINEAR", INT2NUM(ILU_BILINEAR));
+    rb_define_const(mILU, "SCALE_BOX", INT2NUM(ILU_SCALE_BOX));
+    rb_define_const(mILU, "SCALE_TRIANGLE", INT2NUM(ILU_SCALE_TRIANGLE));
+    rb_define_const(mILU, "SCALE_BELL", INT2NUM(ILU_SCALE_BELL));
+    rb_define_const(mILU, "SCALE_BSPLINE", INT2NUM(ILU_SCALE_BSPLINE));
+    rb_define_const(mILU, "SCALE_LANCZOS3", INT2NUM(ILU_SCALE_LANCZOS3));
+    rb_define_const(mILU, "SCALE_MITCHELL", INT2NUM(ILU_SCALE_MITCHELL));
+}

data/ext/devil/ruby_ilut.c

@@ -0,0 +1,98 @@
+#include <ruby.h>
+#include <IL/ilut.h>
+#include "ruby_devil_ext.h"
+
+static VALUE mILUT;
+
+static VALUE ilut_Renderer(VALUE obj, VALUE ilut_enum) {
+    ILenum renderer = NUM2INT(ilut_enum);
+    ilutRenderer(renderer);
+    return Qnil;
+}
+
+static VALUE ilut_Enable(VALUE obj, VALUE rb_Mode) {
+    ILenum Mode = NUM2INT(rb_Mode);
+    ILboolean flag = ilutEnable(Mode);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilut_GLTexImage(VALUE obj, VALUE rb_Level) {
+    ILuint Level = NUM2INT(rb_Level);
+    ILboolean flag = ilutGLTexImage(Level);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilut_GLBindTexImage(VALUE obj) {
+    GLuint ret = ilutGLBindTexImage();
+    return INT2FIX(ret);
+}
+
+static VALUE ilut_GLBuildMipmaps(VALUE obj) {
+    ILboolean flag = ilutGLBuildMipmaps();
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilut_GLBindMipmaps(VALUE obj) {
+    ILuint ret = ilutGLBindMipmaps();
+    return INT2FIX(ret);
+}
+
+static VALUE ilut_GLLoadImage(VALUE obj, VALUE rb_FileName) {
+    const ILstring FileName = STR2CSTR(rb_FileName);
+    GLuint ret = ilutGLLoadImage(FileName);
+    return INT2FIX(ret);
+}
+
+static VALUE ilut_GLScreen(VALUE obj) {
+    ILboolean flag = ilutGLScreen();
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilut_GLScreenie(VALUE obj) {
+    ILboolean flag = ilutGLScreenie();
+    return flag ? Qtrue : Qfalse;
+}
+
+
+
+void 
+InitializeILUT() {
+    mILUT = rb_define_module("ILUT");
+    //////////////////////////////////
+    //METHODS
+    //////////////////////////////////
+    rb_define_module_function(mILUT, "Renderer", ilut_Renderer, 1);
+    rb_define_module_function(mILUT, "Enable", ilut_Enable , 1);
+    rb_define_module_function(mILUT, "GLTexImage", ilut_GLTexImage, 1);
+    rb_define_module_function(mILUT, "GLBindTexImage", ilut_GLBindTexImage, 0);
+    rb_define_module_function(mILUT, "GLBuildMipmaps", ilut_GLBuildMipmaps , 0);
+    rb_define_module_function(mILUT, "GLBindMipmaps", ilut_GLBindMipmaps , 0);
+    rb_define_module_function(mILUT, "GLLoadImage", ilut_GLLoadImage, 1);
+    rb_define_module_function(mILUT, "GLScreen", ilut_GLScreen , 1);
+    rb_define_module_function(mILUT, "GLScreenie", ilut_GLScreenie , 1);
+
+    //////////////////////////////////
+    //CONSTANTS
+    //////////////////////////////////
+    rb_define_const(mILUT, "OPENGL", INT2NUM(ILUT_OPENGL));
+    rb_define_const(mILUT, "ALLEGRO", INT2NUM(ILUT_ALLEGRO));
+    rb_define_const(mILUT, "WIN32", INT2NUM(ILUT_WIN32));
+    rb_define_const(mILUT, "DIRECT3D8", INT2NUM(ILUT_DIRECT3D8));
+    rb_define_const(mILUT, "DIRECT3D9", INT2NUM(ILUT_DIRECT3D9));
+
+    rb_define_const(mILUT, "PALETTE_MODE", INT2NUM(ILUT_PALETTE_MODE));
+    rb_define_const(mILUT, "OPENGL_CONV", INT2NUM(ILUT_OPENGL_CONV));
+    rb_define_const(mILUT, "D3D_MIPLEVELS", INT2NUM(ILUT_D3D_MIPLEVELS));
+    rb_define_const(mILUT, "MAXTEX_WIDTH", INT2NUM(ILUT_MAXTEX_WIDTH));
+    rb_define_const(mILUT, "MAXTEX_HEIGHT", INT2NUM(ILUT_MAXTEX_HEIGHT));
+    rb_define_const(mILUT, "MAXTEX_DEPTH", INT2NUM(ILUT_MAXTEX_DEPTH));
+    rb_define_const(mILUT, "GL_USE_S3TC", INT2NUM(ILUT_GL_USE_S3TC));
+    rb_define_const(mILUT, "D3D_USE_DXTC", INT2NUM(ILUT_D3D_USE_DXTC));
+    rb_define_const(mILUT, "GL_GEN_S3TC", INT2NUM(ILUT_GL_GEN_S3TC));
+    rb_define_const(mILUT, "D3D_GEN_DXTC", INT2NUM(ILUT_D3D_GEN_DXTC));
+    rb_define_const(mILUT, "S3TC_FORMAT", INT2NUM(ILUT_S3TC_FORMAT));
+    rb_define_const(mILUT, "DXTC_FORMAT", INT2NUM(ILUT_DXTC_FORMAT));
+    rb_define_const(mILUT, "D3D_POOL", INT2NUM(ILUT_D3D_POOL));
+    rb_define_const(mILUT, "D3D_ALPHA_KEY_COLOR", INT2NUM(ILUT_D3D_ALPHA_KEY_COLOR));
+    rb_define_const(mILUT, "D3D_ALPHA_KEY_COLOUR", INT2NUM(ILUT_D3D_ALPHA_KEY_COLOUR));
+}

data/lib/devil.rb

@@ -0,0 +1,154 @@
+require 'rbconfig'
+
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+begin
+    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+        require "#{direc}/1.9/devil.#{dlext}"
+    else
+        require "#{direc}/1.8/devil.#{dlext}"
+    end
+rescue LoadError => e
+    require "#{direc}/devil.#{dlext}"
+end
+
+# Provides a high level wrapper for the low-level DevIL Ruby bindings
+module Devil
+    VERSION = '0.1.0'
+    
+    # loads +file+ and returns a new image
+    # Optionally accepts a block and yields the newly created image to the block.
+    def self.load_image(file, &block)
+        name = IL.GenImages(1).first
+        IL.BindImage(name)
+        IL.LoadImage(file)
+
+        img = Image.new(name, file)
+        if block
+            block.call(img)
+        end
+        
+        img
+    end
+
+    # initializes Devil and sets defaults
+    # This method should never need to be called directly.
+    def self.init
+        # initialize DevIL
+        IL.Init
+
+        # default options
+        IL.Enable(IL::FILE_OVERWRITE)
+        ILU.ImageParameter(ILU::FILTER, ILU::BILINEAR) 
+    end
+
+    class << self
+        alias_method :with_image, :load_image
+    end
+
+    class Image
+        def initialize(name, file)
+            @name = name
+            @file = file
+
+            ObjectSpace.define_finalizer( self, proc { IL.DeleteImages(1, [name]) } )
+        end
+        
+        # returns the width of the image
+        def width
+            set_binding
+            IL.GetInteger(IL::IMAGE_WIDTH)
+        end
+
+        # returns the height of the image
+        def height
+            set_binding
+            IL.GetInteger(IL::IMAGE_HEIGHT)
+        end
+
+        # saves the image to +file+. If no +file+ is provided default to the opened file.
+        def save(file = @file)
+            set_binding
+            IL.SaveImage(file)
+        end
+
+        
+        # resize the image to +width+ and +height+. Aspect ratios of the image do not have to be the same.
+        def resize(width, height)
+            set_binding
+            ILU.Scale(width, height, 1)
+        end
+
+        # performs a gaussian blur on the image. The blur is performed +iter+ times.
+        def blur(iter)
+            set_binding
+            ILU.BlurGaussian(iter)
+        end
+
+        # 'pixelize' the image using a pixel size of +pixel_size+
+        def pixelize(pixel_size)
+            set_binding
+            ILU.Pixelize(pixel_size)
+        end
+
+        # add random noise to the image. +factor+ is the tolerance to use.
+        # accepeted values range from 0.0 - 1.0
+        def noisify(factor)
+            set_binding
+            ILU.Noisify(factor)
+        end
+
+        # The sharpening +factor+ must be in the range of 0.0 - 2.5. A value of 1.0 for the sharpening
+        # factor will have no effect on the image. Values in the range 1.0 - 2.5 will sharpen the
+        # image, with 2.5 having the most pronounced sharpening effect. Values from 0.0 to 1.0 do
+        # a type of reverse sharpening, blurring the image. Values outside of the 0.0 - 2.5 range
+        # produce undefined results.
+        #        
+        # The number of +iter+ (iterations) to perform will usually be 1, but to achieve more sharpening,
+        # increase the number of iterations. 
+        def sharpen(factor, iter)
+            set_binding
+            ILU.Sharpen(factor, iter)
+        end
+
+        # applies gamma correction to an image using an exponential curve.
+        # +factor+ is gamma correction factor to use.
+        # A value of 1.0 leaves the image unmodified.
+        # Values in the range 0.0 - 1.0 darken the image
+        # Values above 1.0 brighten the image.
+        def gamma_correct(factor)
+            set_binding
+            ILU.GammaCorrect(factor)
+        end
+
+        # invert the color of every pixel in the image.
+        def negative
+            set_binding
+            ILU.Negative
+        end
+
+        # +factor+ describes desired contrast to use
+        # A value of 1.0 has no effect on the image.
+        # Values between 1.0 and 1.7 increase the amount of contrast (values above 1.7 have no effect)
+        # Valid range of +factor+ is 0.0 - 1.7
+        def contrast(factor)
+            set_binding
+            ILU.Contrast(factor)
+        end
+
+        # darkens the bright colours and lightens the dark
+        # colours, reducing the contrast in an image or 'equalizing' it.
+        def equalize
+            set_binding
+            ILU.Equalize
+        end
+        
+        private
+        
+        def set_binding
+            IL.BindImage(@name)
+        end
+    end
+end
+
+Devil.init

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: devil
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jaroslaw Tworek, John Mair (banisterfiend)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-07 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: ruby bindings for devil cross platform image loading library
+email: jrmair@gmail.com
+executables: []
+
+extensions: 
+- ext/devil/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- Rakefile
+- README
+- LICENSE
+- lib/devil.rb
+- ext/devil/extconf.rb
+- ext/devil/ruby_devil_ext.h
+- ext/devil/ruby_ilut.c
+- ext/devil/ruby_devil_ext.c
+- ext/devil/ruby_il.c
+- ext/devil/ruby_ilu.c
+has_rdoc: true
+homepage: http://banisterfiend.wordpress.com
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ruby bindings for devil cross platform image loading library
+test_files: []
+