devil 0.1.8-x86-mswin32-60 → 0.1.8.5-x86-mswin32-60

data/CHANGELOG

@@ -1,4 +1,19 @@
-2009-10-21
+2009-10-25 John Mair (Banisterfiend)
+version 0.1.8.5
+* added hooks: prepare_image_hook, create_image_hook, load_image_hook 
+* e.g Devil.set_options :load_image_hook => proc { IL::ConvertImage(IL::RGBA, IL::UNSIGNED_BYTE) }
+* added Devil.create_image() method for creating blank images (useful as a blitting canvas?)
+* added :color parameter to create_image (to set background color of new image)
+* added :in_profile and :out_profile to Devil.load_image and Devil.create_image
+* color profiles do not appear to work! so not officially supported or documented.
+* fixed gosu image flip bug
+* added more tests and rdoc
+
+2009-10-22 John Mair (Banisterfiend)
+* added ESC exit from Devil::Image#show
+* added optional :filter parameter to Devil::Image#thumbnail and Devil::Image#resize
+
+2009-10-21 John Mair (Banisterfiend)
 version 0.1.8
 * made LANCZOS3 scaling filter the default for highquality thumbnails
 * changed clear color to DevIL default (mother of pearl and full alpha)

data/README

@@ -1,4 +1,4 @@
-Ruby Devil version 0.1.8
+Ruby Devil version 0.1.8.5
 ========================
 
 * Original author: Jaroslaw Tworek <dev.jrx@gmail.com>

data/Rakefile

@@ -8,7 +8,7 @@ require 'rake/gempackagetask'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-DEVIL_VERSION = "0.1.8"
+DEVIL_VERSION = "0.1.8.5"
 
 dlext = Config::CONFIG['DLEXT']
 

data/ext/devil/ruby_il.c

@@ -116,12 +116,18 @@ static VALUE il_TexImage(VALUE obj, VALUE rb_width, VALUE rb_height,
     ILuint depth = NUM2INT(rb_depth);
     ILubyte bpp = NUM2INT(rb_bpp);
     ILenum format = NUM2INT(rb_format);
-    ILenum type = NUM2INT(rb_type);
+    ILenum type = NUM2INT(rb_type);
+	ILboolean flag;
 
     /* from ILvoid */
-    void* data = ImageData2Arr(rb_data);
+    void * data = NULL;
+    
+    if(NIL_P(rb_data))
+        data = NULL;
+    else
+        data = ImageData2Arr(rb_data);
 
-    ILboolean flag = ilTexImage(width, height, depth,
+    flag = ilTexImage(width, height, depth,
                                 bpp, format, type, data);
     return flag ? Qtrue : Qfalse;
 }
@@ -249,6 +255,22 @@ static VALUE il_Disable(VALUE obj, VALUE rb_mode) {
     return flag ? Qtrue : Qfalse;
 }
 
+static VALUE il_ApplyProfile(VALUE obj, VALUE rb_inprofile, VALUE rb_outprofile)
+{
+    char * inprofile = NULL;
+    char * outprofile = StringValuePtr(rb_outprofile);
+    ILboolean flag;
+
+    if(NIL_P(rb_inprofile))
+        inprofile = NULL;
+    else
+        inprofile = StringValuePtr(rb_inprofile);
+
+    flag = ilApplyProfile(inprofile, outprofile);
+
+    return flag ? Qtrue : Qfalse;
+}
+
 static VALUE il_GetInteger(VALUE obj, VALUE rb_mode) {
     ILenum mode = NUM2INT(rb_mode);
 
@@ -266,7 +288,7 @@ static VALUE il_ConvertImage(VALUE obj, VALUE rb_destformat, VALUE rb_desttype)
 }
 
 /* TODO: MAKE SURE NO MEMORY LEAKS! */
-/* this function is not actualy in the DevIL API, but im adding it here for convenience */
+/* this function is not actually in the DevIL API, but im adding it here for convenience */
 static VALUE bf_ToBlob(VALUE obj)
 {
     ILuint width, height, saved_image, copy_image;
@@ -399,6 +421,7 @@ InitializeIL() {
     rb_define_module_function(mIL, "OriginFunc", il_OriginFunc, 1);
     rb_define_module_function(mIL, "ClearColour", il_ClearColour, 4);
     rb_define_module_function(mIL, "ClearImage", il_ClearImage, 0);
+    rb_define_module_function(mIL, "ApplyProfile", il_ApplyProfile, 2);
     /* end of methods added by banisterfiend */
     
     //////////////////////////////////

data/lib/devil.rb

@@ -19,17 +19,26 @@ module Devil
     include IL
     include ILU
 
-    VERSION = '0.1.8'
+    VERSION = '0.1.8.5'
     
     class << self
 
         # loads +file+ and returns a new image
         # Optionally accepts a block and yields the newly created image to the block.
-        def load_image(file, &block)
-            name = IL.GenImages(1).first
-            IL.BindImage(name)
+        def load_image(file, options={}, &block)
+            name = prepare_image
+            out_profile = options[:out_profile]
+            in_profile = options[:in_profile]
+            
             IL.LoadImage(file)
 
+            # apply a color profile if one is provided
+            IL.ApplyProfile(in_profile, out_profile) if out_profile
+
+            # run the proc (if it exists)
+            load_image_proc = Devil.get_options[:load_image_hook]
+            load_image_proc.call if load_image_proc            
+
             if (error_code = IL.GetError) != IL::NO_ERROR
                 raise RuntimeError, "an error occured while trying to "+
                     "load the image #{file}. #{ILU.ErrorString(error_code)}"
@@ -45,6 +54,47 @@ module Devil
 
         alias_method :with_image, :load_image
         alias_method :load, :load_image
+
+        # returns a blank image of +width+ and +height+.
+        # Optionally accepts the :color hash param that fills the new image with a color
+        # (see: Devil.set_options :clear_color)
+        # Optionally accepts a block and yields the newly created image to the block.
+        def create_image(width, height, options={}, &block)
+            name = prepare_image
+            out_profile = options[:out_profile]
+            in_profile = options[:in_profile]
+
+            clear_color = options[:color]
+
+            IL.TexImage(width, height, 1, 4, IL::RGBA, IL::UNSIGNED_BYTE, nil)
+
+            # apply a color profile if one is provided
+            IL.ApplyProfile(in_profile, out_profile) if out_profile            
+
+            IL.ClearColour(*clear_color) if clear_color
+            IL.ClearImage
+            IL.ClearColour(*Devil.get_options[:clear_color]) if clear_color
+
+            # run the proc (if it exists)
+            create_image_proc = Devil.get_options[:create_image_hook]
+            create_image_proc.call if create_image_proc
+
+            if (error_code = IL.GetError) != IL::NO_ERROR
+                raise RuntimeError, "an error occured while trying to "+
+                    "create an image. #{ILU.ErrorString(error_code)}"
+            end
+
+            img = Image.new(name, nil)
+            if block
+                block.call(img)
+            end
+            
+            img
+        end
+
+        alias_method :create_blank_image, :create_image
+        alias_method :create_blank, :create_image
+        alias_method :blank_image, :create_image
         
         # convert an image +blob+ with +width+ and +height+
         # to a bona fide image
@@ -83,7 +133,7 @@ module Devil
         def set_options(options={})
             @options.merge!(options)
 
-            # update the scale_filter 
+            # update the config. options 
             ILU.ImageParameter(ILU::FILTER, @options[:scale_filter])
             ILU.ImageParameter(ILU::PLACEMENT, @options[:placement])
             IL.ClearColour(*@options[:clear_color])
@@ -101,18 +151,20 @@ module Devil
             IL.Init
             ILU.Init
 
-            set_option_defaults
+            set_defaults
         end
 
-        private
-        
-        def set_option_defaults
+        # restore Devil's default configuration.
+        def set_defaults
             @options = {
                 :scale_filter => ILU::SCALE_LANCZOS3,
                 :edge_filter => :prewitt,
                 :window_size => [1024, 768],
                 :clear_color => [255, 248, 230, 0],
                 :placement => ILU::CENTER,
+                :prepare_image_hook => nil,
+                :load_image_hook => nil,
+                :create_image_hook => nil,
             }
             
             # configurable options
@@ -122,250 +174,286 @@ module Devil
 
             # fixed options
             IL.Enable(IL::FILE_OVERWRITE)
+            IL.Enable(IL::ORIGIN_SET)
+            IL.OriginFunc(IL::ORIGIN_LOWER_LEFT)
         end
-    end
- 
-    class Image
-        attr_reader :name, :file
 
-        def initialize(name, file)
-            @name = name
-            @file = file
+        alias_method :restore_defaults, :set_defaults
 
-            ObjectSpace.define_finalizer( self, proc { IL.DeleteImages(1, [name]) } )
-        end
-        
-        # returns the width of the image.
-        def width
-            action { IL.GetInteger(IL::IMAGE_WIDTH) }
-        end
+        private
 
-        alias_method :columns, :width
+        def prepare_image
+            name = IL.GenImages(1).first
+            IL.BindImage(name)
+
+            # run the proc (if it exists)
+            prepare_image_proc = Devil.get_options[:prepare_image_hook]
+            prepare_image_proc.call if prepare_image_proc
 
-        # returns the height of the image.
-        def height
-            action { IL.GetInteger(IL::IMAGE_HEIGHT) }
+            name
         end
+    end
+end
+# end of Devil module 
 
-        alias_method :rows, :height
+# wraps a DevIL image
+class Devil::Image
+    attr_reader :name, :file
 
-        # saves the image to +file+. If no +file+ is provided default to the opened file.
-        def save(file = @file)
-            raise "This image does not have an associated file. Please provide an explicit file name when saving." if !file
-            
-            action { IL.SaveImage(file) }
-            self
-        end
-        
-        # resize the image to +width+ and +height+. Aspect ratios of the image do not have to be the same.
-        def resize(width, height)
-            action { ILU.Scale(width, height, 1) }
-            self
-        end
+    def initialize(name, file)
+        @name = name
+        @file = file
 
-        # Creates a proportional thumbnail of the image scaled so its longest.
-        # edge is resized to +size+.
-        def thumbnail(size)
+        ObjectSpace.define_finalizer( self, proc { IL.DeleteImages(1, [name]) } )
+    end
+    
+    # returns the width of the image.
+    def width
+        action { IL.GetInteger(IL::IMAGE_WIDTH) }
+    end
 
-            # this thumbnail code from image_science.rb
-            w, h = width, height
-            scale = size.to_f / (w > h ? w : h)
-            resize((w * scale).to_i, (h * scale).to_i)
-            self
-        end
+    alias_method :columns, :width
 
-        # return a deep copy of the current image.
-        def dup
-            new_image_name = action { IL.CloneCurImage }
-            Image.new(new_image_name, nil)
-        end
+    # returns the height of the image.
+    def height
+        action { IL.GetInteger(IL::IMAGE_HEIGHT) }
+    end
 
-        alias_method :clone, :dup
+    alias_method :rows, :height
 
-        # crop the current image.
-        # +xoff+ number of pixels to skip in x direction.
-        # +yoff+ number of pixels to skip in y direction.
-        # +width+ number of pixels to preserve in x direction.
-        # +height+ number of pixels to preserve in y direction.
-        def crop(xoff, yoff, width, height)
-            action { ILU.Crop(xoff, yoff, 1, width, height, 1) }
-            self
-        end
+    # saves the image to +file+. If no +file+ is provided default to the opened file.
+    def save(file = @file)
+        raise "This image does not have an associated file. Please provide an explicit file name when saving." if !file
+        
+        action { IL.SaveImage(file) }
+        self
+    end
+    
+    # resize the image to +width+ and +height+. Aspect ratios of the image do not have to be the same.
+    # Optional :filter hash parameter that maps to a valid scale filter
+    # (see: Devil.set_options :scale_filter)
+    def resize(width, height, options = {})
+        filter = options[:filter]
 
-        # enlarge the canvas of current image to +width+ and +height+.
-        def enlarge_canvas(width, height)
-            if width < self.width || height < self.height
-                raise "width and height parameters must be larger than current image width and height"
-            end
-            
-            action { ILU.EnlargeCanvas(width, height, 1) }
-            self
+        action do
+            ILU.ImageParameter(ILU::FILTER, filter) if filter
+            ILU.Scale(width, height, 1)
+            ILU.ImageParameter(ILU::FILTER, Devil.get_options[:scale_filter]) if filter
         end
+        
+        self
+    end
 
-        # splice the +source+ image into current image at position +x+ and +y+.
-        # Takes an optional +:crop+ hash parameter that has the following format: +:crop => [sx, sy, width, height]+
-        # +sx+, +sy+, +width, +height+ crop the source image to be spliced.
-        # +sx+ is how many pixels to skip in x direction of source image.
-        # +sy+ is how many pixels to skip in y direction of source image.
-        # +width+ number of pixels to preserve in x direction of source image.
-        # +height+ number of pixels to preserve in y direction of source image.
-        # if no +:crop+ parameter is provided then the whole image is spliced in.
-        def blit(source, x, y, options = {})
-            options = {
-                :crop => [0, 0, source.width, source.height]
-            }.merge!(options)
-            
-            action do
-                IL.Blit(source.name, x, y, 0, options[:crop][0], options[:crop][1], 0,
-                        options[:crop][2], options[:crop][3], 1)
-            end
-            
-            self
-        end
+    # Creates a proportional thumbnail of the image scaled so its longest
+    # edge is resized to +size+.
+    # Optional :filter hash parameter that maps to a valid scale filter
+    # (see: Devil.set_options :scale_filter)
+    def thumbnail(size, options = {})
+
+        # this thumbnail code from image_science.rb
+        w, h = width, height
+        scale = size.to_f / (w > h ? w : h)
+        resize((w * scale).to_i, (h * scale).to_i, options)
+        self
+    end
 
-        alias_method :composite, :blit
+    # return a deep copy of the current image.
+    def dup
+        new_image_name = action { IL.CloneCurImage }
+        Devil::Image.new(new_image_name, nil)
+    end
 
-        # reflect image about its y axis.
-        def mirror
-            action { ILU.Mirror }
-            self
-        end
+    alias_method :clone, :dup
 
-        # use prewitt or sobel filters to detect the edges in the current image.
-        def edge_detect
-            case Devil.get_options[:edge_filter]
-            when :prewitt
-                action { ILU.EdgeDetectP }
-            when :sobel
-                action { ILU.EdgeDetectS }
-            else
-                raise "No such edge filter #{Devil.get_options[:edge_filter]}. Use :prewitt or :sobel"
-            end
-            self
-        end
+    # crop the current image.
+    # +xoff+ number of pixels to skip in x direction.
+    # +yoff+ number of pixels to skip in y direction.
+    # +width+ number of pixels to preserve in x direction.
+    # +height+ number of pixels to preserve in y direction.
+    def crop(xoff, yoff, width, height)
+        action { ILU.Crop(xoff, yoff, 1, width, height, 1) }
+        self
+    end
 
-        # embosses an image, causing it to have a "relief" feel to it using a convolution filter.
-        def emboss
-            action { ILU.Emboss }
-            self
+    # enlarge the canvas of current image to +width+ and +height+.
+    def enlarge_canvas(width, height)
+        if width < self.width || height < self.height
+            raise "width and height parameters must be larger than current image width and height"
         end
+        
+        action { ILU.EnlargeCanvas(width, height, 1) }
+        self
+    end
 
-        # applies a strange color distortion effect to the image giving  a preternatural feel
-        def alienify
-            action { ILU.Alienify }
-            self
+    # splice the +source+ image into current image at position +x+ and +y+.
+    # Takes an optional +:crop+ hash parameter that has the following format: +:crop => [sx, sy, width, height]+
+    # +sx+, +sy+, +width, +height+ crop the source image to be spliced.
+    # +sx+ is how many pixels to skip in x direction of source image.
+    # +sy+ is how many pixels to skip in y direction of source image.
+    # +width+ number of pixels to preserve in x direction of source image.
+    # +height+ number of pixels to preserve in y direction of source image.
+    # if no +:crop+ parameter is provided then the whole image is spliced in.
+    def blit(source, x, y, options = {})
+        options = {
+            :crop => [0, 0, source.width, source.height]
+        }.merge!(options)
+        
+        action do
+            IL.Blit(source.name, x, y, 0, options[:crop][0], options[:crop][1], 0,
+                    options[:crop][2], options[:crop][3], 1)
         end
+        
+        self
+    end
 
-        # performs a gaussian blur on the image. The blur is performed +iter+ times.
-        def blur(iter)
-            action { ILU.BlurGaussian(iter) }
-            self
-        end
+    alias_method :composite, :blit
 
-        # 'pixelize' the image using a pixel size of +pixel_size+.
-        def pixelize(pixel_size)
-            action { ILU.Pixelize(pixel_size) }
-            self
-        end
+    # reflect image about its y axis.
+    def mirror
+        action { ILU.Mirror }
+        self
+    end
 
-        # add random noise to the image. +factor+ is the tolerance to use.
-        # accepeted values range from 0.0 - 1.0.
-        def noisify(factor)
-            action { ILU.Noisify(factor) }
-            self
-        end
+    # use prewitt or sobel filters to detect the edges in the current image.
+    # Optional :filter hash parameter selects filter to use (:prewitt or :sobel).
+    # (see: Devil.set_options :edge_filter)    
+    def edge_detect(options={})
+        options = {
+            :filter => Devil.get_options[:edge_filter]
+        }.merge!(options)
+        
+        case options[:filter]
+        when :prewitt
+            action { ILU.EdgeDetectP }
+        when :sobel
+            action { ILU.EdgeDetectS }
+        else
+            raise "No such edge filter #{options[:filter]}. Use :prewitt or :sobel"
+        end
+        self
+    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)
-            action { ILU.Sharpen(factor, iter) }
-            self
-        end
+    # embosses an image, causing it to have a "relief" feel to it using a convolution filter.
+    def emboss
+        action { ILU.Emboss }
+        self
+    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)
-            action { ILU.GammaCorrect(factor) }
-            self
-        end
+    # applies a strange color distortion effect to the image giving  a preternatural feel
+    def alienify
+        action { ILU.Alienify }
+        self
+    end
 
-        # invert the color of every pixel in the image.
-        def negate
-            action { ILU.Negative }
-            self
-        end
+    # performs a gaussian blur on the image. The blur is performed +iter+ times.
+    def blur(iter)
+        action { ILU.BlurGaussian(iter) }
+        self
+    end
 
-        alias_method :negative, :negate
+    # 'pixelize' the image using a pixel size of +pixel_size+.
+    def pixelize(pixel_size)
+        action { ILU.Pixelize(pixel_size) }
+        self
+    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)
-            action { ILU.Contrast(factor) }
-            self
-        end
+    # add random noise to the image. +factor+ is the tolerance to use.
+    # accepeted values range from 0.0 - 1.0.
+    def noisify(factor)
+        action { ILU.Noisify(factor) }
+        self
+    end
 
-        # darkens the bright colours and lightens the dark
-        # colours, reducing the contrast in an image or 'equalizing' it.
-        def equalize
-            action { ILU.Equalize }
-            self
-        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)
+        action { ILU.Sharpen(factor, iter) }
+        self
+    end
 
-        # returns the image data in the form of a ruby string.
-        # The image data is formatted to RGBA / UNSIGNED BYTE.
-        def to_blob
-            action { IL.ToBlob }
-        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)
+        action { ILU.GammaCorrect(factor) }
+        self
+    end
 
-        # flip the image about its x axis.
-        def flip
-            action { ILU.FlipImage }
-            self
-        end
+    # invert the color of every pixel in the image.
+    def negate
+        action { ILU.Negative }
+        self
+    end
 
-        # rotate an image about its central point by +angle+ degrees (counter clockwise).
-        def rotate(angle)
-            action { ILU.Rotate(angle) }
-            self
-        end
+    alias_method :negative, :negate
 
-        #  simply clears the image to the 'clear color' (specified using Devil.set_options(:clear_color => [r, g, b, a])
-        def clear
-            action { IL.ClearImage }
-            self
-        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)
+        action { ILU.Contrast(factor) }
+        self
+    end
 
-        private
+    # darkens the bright colours and lightens the dark
+    # colours, reducing the contrast in an image or 'equalizing' it.
+    def equalize
+        action { ILU.Equalize }
+        self
+    end
 
-        def set_binding
-            IL.BindImage(@name)
-        end
+    # returns the image data in the form of a ruby string.
+    # The image data is formatted to RGBA / UNSIGNED BYTE.
+    def to_blob
+        action { IL.ToBlob }
+    end
 
-        def error_check
-            if (error_code = IL.GetError) != IL::NO_ERROR
-                raise RuntimeError, "An error occured. #{ILU.ErrorString(error_code)}"
-            end
-        end
+    # flip the image about its x axis.
+    def flip
+        action { ILU.FlipImage }
+        self
+    end
 
-        def action
-            set_binding
-            result = yield
-            error_check
-            
-            result
+    # rotate an image about its central point by +angle+ degrees (counter clockwise).
+    def rotate(angle)
+        action { ILU.Rotate(angle) }
+        self
+    end
+
+    #  simply clears the image to the 'clear color' (specified using Devil.set_options(:clear_color => [r, g, b, a])
+    def clear
+        action { IL.ClearImage }
+        self
+    end
+
+    private
+
+    def set_binding
+        IL.BindImage(@name)
+    end
+
+    def error_check
+        if (error_code = IL.GetError) != IL::NO_ERROR
+            raise RuntimeError, "An error occured. #{ILU.ErrorString(error_code)}"
         end
     end
+
+    def action
+        set_binding
+        result = yield
+        error_check
+        
+        result
+    end
 end
 
 Devil.init

data/lib/devil/gosu.rb

@@ -1,3 +1,5 @@
+# (C) John Mair 2009, under the MIT licence
+
 require 'texplay'
 require 'devil'
 
@@ -19,7 +21,7 @@ module TexPlay
         devil_img = nil
         capture {
             devil_img = Devil.from_blob(self.to_blob, self.width, self.height)
-            devil_img.flip
+            devil_img
         }
         devil_img
     end
@@ -40,10 +42,8 @@ class Gosu::Window
             glEnable(GL_TEXTURE_2D)
             glBindTexture(GL_TEXTURE_2D, canvas_texture_id)
             
-            glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, 1)
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, self.width, self.height, 0, GL_RGB, GL_UNSIGNED_BYTE, "\0" * self.width * self.height * 3)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, self.width, self.height, 0,
+                         GL_RGB, GL_UNSIGNED_BYTE, "\0" * self.width * self.height * 3)
             
             glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, self.width, self.height, 0)
 
@@ -65,7 +65,7 @@ class Gosu::Image
             if file.respond_to?(:to_blob) || file =~ /\.(bmp|png)$/
                 original_new_redux(window, file, *args, &block)
             else 
-                original_new_redux(window, Devil.load(file), *args, &block)
+                original_new_redux(window, Devil.load(file).flip, *args, &block)
             end
         end
     end
@@ -98,6 +98,8 @@ class Devil::Image
 
                 def draw    # :nodoc:
                     @show_list.each { |v| v[:image].draw_rot(v[:x], v[:y], 1, 0) }
+
+                    exit if button_down?(Gosu::KbEscape)
                 end
             end
 
@@ -111,7 +113,7 @@ class Devil::Image
         end
 
         # note we dup the image so the displayed image is a snapshot taken at the time #show is invoked
-        @@window.show_list.push :image => Gosu::Image.new(@@window, self.dup), :x => x, :y => y
+        @@window.show_list.push :image => Gosu::Image.new(@@window, self.dup.flip), :x => x, :y => y
 
         self
     end

data/test/test_blank.rb

@@ -0,0 +1,17 @@
+$direc = File.dirname(__FILE__)
+
+$LOAD_PATH.push("#{$direc}/../lib/")
+
+require 'rubygems'
+require 'devil/gosu'
+
+Devil.set_options :load_image_hook => proc { IL.ConvertImage(IL::RGBA, IL::UNSIGNED_BYTE) }
+
+Devil.create_image(500, 500, :color => [255, 255, 0, 255]) do |img|
+    source1 = Devil.load("texture.png").thumbnail(100)
+    img.blit source1, 100, 100
+    img.blit source1, 400, 100
+    img.blit source1.dup.rotate(45), 100, 300
+    img.show
+end
+

data/test/test_clone_and_crop.rb

@@ -5,12 +5,12 @@ $LOAD_PATH.push("#{direc}/../lib/")
 require 'rubygems'
 require "devil/gosu"
 
-img = Devil.load_image("#{direc}/texture.jpg") 
+img = Devil.load_image("#{direc}/texture.png") 
 
 img.crop(100,100, 200, 200)
 img_dup = img.dup
 
-img.negative
+img.rotate(rand(360))
 
 img.show(200,200)
 img_dup.show(450, 200)

data/test/test_gosu_load.rb

@@ -10,6 +10,7 @@ class W < Gosu::Window
         super(1024, 768, false, 20)
 
         @img = Gosu::Image.new(self, "#{$direc}/texture.jpg")
+        @img = @img.to_devil.save("cunt.png").to_gosu(self).to_devil.blur(5).to_gosu(self)
     end
     
     def draw

data/test/test_gosu_roundtrip.rb

@@ -0,0 +1,27 @@
+$direc = File.dirname(__FILE__)
+
+$LOAD_PATH.push("#{$direc}/../lib/")
+
+require 'rubygems'
+require 'devil/gosu'
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+
+        @img = Gosu::Image.new(self, "#{$direc}/texture.jpg")
+        @img = @img.to_devil.
+            emboss.
+            rotate(45).
+            to_gosu(self)
+    end
+    
+    def draw
+        @img.draw 100, 50,1
+    end
+    
+end
+
+w = W.new
+w.show
+        

data/test/test_profile.rb

@@ -0,0 +1,8 @@
+$direc = File.dirname(__FILE__)
+
+$LOAD_PATH.push("#{$direc}/../lib/")
+
+require 'rubygems'
+require 'devil/gosu'
+
+Devil.load("texture.png", :in_profile => "sRGB.icm", :out_profile => "AdobeRGB1998.icc").save("texture_out.png")

data/test/test_thumbnail.rb

@@ -6,6 +6,7 @@ require 'rubygems'
 require 'devil/gosu'
 
 Devil.load("texture.png") do |img|
-    img.thumbnail(150).show
+    img.dup.thumbnail(150, :filter => Devil::NEAREST).show(100, 300)
+    img.dup.thumbnail(150).show(100, 100)
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: devil
 version: !ruby/object:Gem::Version 
-  version: 0.1.8
+  version: 0.1.8.5
 platform: x86-mswin32-60
 authors: 
 - Jaroslaw Tworek, John Mair (banisterfiend)
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-21 00:00:00 +13:00
+date: 2009-10-26 00:00:00 +13:00
 default_executable: 
 dependencies: []
 
@@ -33,12 +33,15 @@ files:
 - ext/devil/ruby_devil_ext.c
 - ext/devil/ruby_il.c
 - ext/devil/ruby_ilu.c
+- test/test_blank.rb
 - test/test_blit.rb
 - test/test_clone_and_crop.rb
 - test/test_gosu_load.rb
+- test/test_gosu_roundtrip.rb
 - test/test_gosu_save.rb
 - test/test_gosu_show.rb
 - test/test_new_api.rb
+- test/test_profile.rb
 - test/test_scale_algos.rb
 - test/test_screenshot.rb
 - test/test_thumbnail.rb