texplay 0.3.1-i386-mingw32 → 0.3.3-i386-mingw32

data/Rakefile

@@ -1,17 +1,14 @@
-$LOAD_PATH.unshift File.join(File.expand_path(__FILE__), '..')
-
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+project_name = "texplay"
 
 require 'rake/clean'
 require 'rake/gempackagetask'
+require "#{direc}/lib/#{project_name}/version"
 
-# get the texplay version
-require './lib/texplay/version'
-
-direc = File.dirname(__FILE__)
-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")
+CLEAN.include("ext/**/*.#{dlext}", "ext/**/*.log", "ext/**/*.o", "ext/**/*~",
+              "ext/**/*#*", "ext/**/*.obj", "ext/**/*.def", "ext/**/*.pdb")
 
 def apply_spec_defaults(s)
   s.name = "texplay"
@@ -23,13 +20,17 @@ def apply_spec_defaults(s)
   s.description = s.summary
   s.require_path = 'lib'
   s.add_dependency("gosu",">=0.7.25")
+  s.add_development_dependency("bacon",">=1.1.0")
   s.homepage = "http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/"
   s.has_rdoc = 'yard'
-  s.files =  FileList["Rakefile", "README.markdown", "CHANGELOG", 
+  s.files =  Dir["Rakefile", "README.markdown", "CHANGELOG", 
                       "lib/**/*.rb", "ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c",
-                      "examples/*.rb", "examples/media/*", "spec/*.rb"].to_a 
+                      "examples/*.rb", "examples/media/*", "test/*.rb", "live/*rb", ".gemtest"]
 end
 
+task :test do
+  sh "bacon -k #{direc}/test/texplay_spec.rb"
+end
 
 [:mingw32, :mswin32].each do |v|
   namespace v do
@@ -50,7 +51,7 @@ namespace :ruby do
   spec = Gem::Specification.new do |s|
     apply_spec_defaults(s)        
     s.platform = Gem::Platform::RUBY
-    s.extensions = ["ext/texplay/extconf.rb"]
+    s.extensions = ["ext/#{project_name}/extconf.rb"]
   end
 
   Rake::GemPackageTask.new(spec) do |pkg|
@@ -58,9 +59,31 @@ namespace :ruby do
     pkg.need_tar = false
   end
 end
+
+directories = ["#{direc}/lib/1.8", "#{direc}/lib/1.9"]
+directories.each { |d| directory d }
+
+desc "build the 1.8 and 1.9 binaries from source and copy to lib/"
+task :compile => directories do
+  build_for = proc do |pik_ver, ver|
+    sh %{ \
+          c:\\devkit\\devkitvars.bat && \
+          pik #{pik_ver} && \
+          ruby extconf.rb && \
+          make clean && \
+          make && \
+          cp *.so #{direc}/lib/#{ver} \
+        }
+  end
   
+  chdir("#{direc}/ext/#{project_name}") do
+    build_for.call("187", "1.8")
+    build_for.call("192", "1.9")
+  end
+end
+
 desc "build all platform gems at once"
-task :gems => ["mingw32:gem", "mswin32:gem", "ruby:gem"]
+task :gems => [:clean, :rmgems, "mingw32:gem", "mswin32:gem", "ruby:gem"]
 
 desc "remove all platform gems"
 task :rmgems => ["ruby:clobber_package"]
@@ -73,3 +96,4 @@ task :pushgems => :gems do
     end
   end
 end
+

data/ext/texplay/graphics_utils.c

@@ -14,6 +14,7 @@
 static void initialize_action_struct(action_struct * cur, VALUE hash_arg, sync sync_mode);
 static void process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode, bool primary);
 static void prepare_drawing_mode(action_struct * cur);
+static void prepare_alpha_blend(action_struct * cur);
 static void prepare_fill_texture(action_struct * cur);
 static void prepare_color_control(action_struct * cur);
 static void prepare_color_select(action_struct * cur);
@@ -343,6 +344,8 @@ initialize_action_struct(action_struct * cur, VALUE hash_arg, sync sync_mode)
     cur->pen.has_color_control_proc = false;
     cur->pen.has_color_control_transform = false;
     cur->pen.has_source_texture = false;
+
+    /* alpha blending */
     cur->pen.alpha_blend = false;
 
     /* set static color control transformations to defaults */
@@ -471,8 +474,48 @@ process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode,
     prepare_fill_texture(cur);
 
     /* does the user want to blend alpha values ? */
-    if(get_from_hash(*hash_arg, "alpha_blend") == Qtrue)
-        cur->pen.alpha_blend = true;
+    prepare_alpha_blend(cur);
+}
+
+static void
+prepare_alpha_blend(action_struct * cur)
+{
+  if(has_optional_hash_arg(cur->hash_arg, "alpha_blend")) {
+
+    VALUE blend_mode = get_from_hash(cur->hash_arg, "alpha_blend");
+
+    /* true is equivalent to default blend mode, 'source' */
+    if(blend_mode == Qtrue)
+      blend_mode = string2sym("source");
+
+    /* where false or nil is passed */
+    if(!RTEST(blend_mode)) {
+      cur->pen.alpha_blend = false;
+      return;
+    }
+
+    cur->pen.alpha_blend = true;
+
+    Check_Type(blend_mode, T_SYMBOL);
+    
+    if(blend_mode == string2sym("source")) {
+      cur->pen.alpha_blend_mode = source;
+    }      
+    else if(blend_mode == string2sym("dest")) {
+      cur->pen.alpha_blend_mode = dest;
+    }
+    else if(blend_mode == string2sym("source_with_fixed_alpha")) {
+      cur->pen.alpha_blend_mode = source_with_fixed_alpha;
+    }
+    else if(blend_mode == string2sym("dest_with_fixed_alpha")) {
+      cur->pen.alpha_blend_mode = dest_with_fixed_alpha;
+    }
+    else
+      rb_raise(rb_eArgError, "unrecognized blend mode: %s\n.",
+               sym2string(blend_mode));
+
+  }
+
 
 }
 
@@ -591,10 +634,6 @@ prepare_color_control(action_struct * cur)
             if(is_an_array(try_add)) {
                 
                 cur->pen.color_add = convert_rb_color_to_rgba(try_add);
-                /* cur->pen.color_add.red = NUM2DBL(get_from_array(try_add, 0)); */
-                /* cur->pen.color_add.green = NUM2DBL(get_from_array(try_add, 1)); */
-                /* cur->pen.color_add.blue = NUM2DBL(get_from_array(try_add, 2)); */
-                /* cur->pen.color_add.alpha = NUM2DBL(get_from_array(try_add, 3)); */
 
                 cur->pen.has_color_control_transform = true;
             }
@@ -602,11 +641,6 @@ prepare_color_control(action_struct * cur)
 
                 cur->pen.color_mult = convert_rb_color_to_rgba(try_mult);
 
-                /* cur->pen.color_mult.red = NUM2DBL(get_from_array(try_mult, 0)); */
-                /* cur->pen.color_mult.green = NUM2DBL(get_from_array(try_mult, 1)); */
-                /* cur->pen.color_mult.blue = NUM2DBL(get_from_array(try_mult, 2)); */
-                /* cur->pen.color_mult.alpha = NUM2DBL(get_from_array(try_mult, 3)); */
-
                 cur->pen.has_color_control_transform = true;
             }
                 
@@ -1068,33 +1102,68 @@ apply_color_control_transform(action_struct * payload, texture_info * tex, int x
 static rgba
 apply_alpha_blend(action_struct * payload, texture_info * tex, int x, int y, rgba blended_pixel)
 {
-    rgba dest_pixel = get_pixel_color(tex, x, y);
-    rgba finished_pixel;
-
+  rgba dest_pixel = get_pixel_color(tex, x, y);
+  rgba finished_pixel;
 
-    if (not_a_color(blended_pixel))
-        return blended_pixel;
+  if (not_a_color(blended_pixel))
+    return blended_pixel;
+    
+  alpha_blend_mode_t blend_mode = payload->pen.alpha_blend_mode;
     
-    /* alpha blending is nothing more than a weighted average of src and dest pixels
-       based on source alpha value */
-    /* NB: destination alpha value is ignored */
+  switch(blend_mode)
+    {
+    case source:
+    case source_with_fixed_alpha:
+      /** TO DO: rewrite this using sse2 instructions **/
+      finished_pixel.red = blended_pixel.alpha * blended_pixel.red + (1 - blended_pixel.alpha)
+        * dest_pixel.red;
+
+      finished_pixel.green = blended_pixel.alpha * blended_pixel.green + (1 - blended_pixel.alpha)
+        * dest_pixel.green;
+
+      finished_pixel.blue = blended_pixel.alpha * blended_pixel.blue + (1 - blended_pixel.alpha)
+        * dest_pixel.blue;
+
+      if(blend_mode == source) {
+        finished_pixel.alpha = blended_pixel.alpha * blended_pixel.alpha + (1 - blended_pixel.alpha)
+          * dest_pixel.alpha;
+      }
+      else {
 
-    /** TO DO: rewrite this using sse2 instructions **/
-    finished_pixel.red = blended_pixel.alpha * blended_pixel.red + (1 - blended_pixel.alpha)
+        // fixed alpha
+        finished_pixel.alpha = dest_pixel.alpha;
+      }
+        
+      break;
+    case dest:
+    case dest_with_fixed_alpha:
+      finished_pixel.red = dest_pixel.alpha * blended_pixel.red + (1 - dest_pixel.alpha)
         * dest_pixel.red;
 
-    finished_pixel.green = blended_pixel.alpha * blended_pixel.green + (1 - blended_pixel.alpha)
+      finished_pixel.green = dest_pixel.alpha * blended_pixel.green + (1 - dest_pixel.alpha)
         * dest_pixel.green;
 
-    finished_pixel.blue = blended_pixel.alpha * blended_pixel.blue + (1 - blended_pixel.alpha)
+      finished_pixel.blue = dest_pixel.alpha * blended_pixel.blue + (1 - dest_pixel.alpha)
         * dest_pixel.blue;
 
+      if(blend_mode == dest) {
+        finished_pixel.alpha = dest_pixel.alpha * blended_pixel.alpha + (1 - dest_pixel.alpha)
+          * dest_pixel.alpha;
+      }
+      else {
 
-    finished_pixel.alpha = blended_pixel.alpha * blended_pixel.alpha + (1 - blended_pixel.alpha)
-      * dest_pixel.alpha;
+        // fixed alpha
+        finished_pixel.alpha = dest_pixel.alpha;
+      }
+            
+      break;
+    default:
+      rb_raise(rb_eRuntimeError,
+               "apply_alpha_blend() impossible error. got %d\n", blend_mode);
 
+    }
 
-    return finished_pixel;
+  return finished_pixel;
 }
 
 /* NEW from utils.c */

data/ext/texplay/texplay.h

@@ -29,15 +29,15 @@
 
 /* enums */
 typedef enum e_bool {
-    false, true
+  false, true
 } bool;
 
 typedef enum e_color {
-    red, green, blue, alpha
+  red, green, blue, alpha
 } color_t;
 
 typedef enum e_sync_mode {
-    lazy_sync, eager_sync, no_sync
+  lazy_sync, eager_sync, no_sync
 } sync;
 
 
@@ -54,6 +54,10 @@ typedef enum {
   difference, exclusion
 } draw_mode;
 
+typedef enum {
+  source, dest, source_with_fixed_alpha, dest_with_fixed_alpha
+} alpha_blend_mode_t;
+
 /* structs */
 typedef struct s_rgba {
   float red, green, blue, alpha;
@@ -67,80 +71,81 @@ typedef struct {
 
 /* stores image data */
 typedef struct {
-    int width, height;    
-    float top, left;    
-    int tname;
-    float * td_array;
-    int yincr, firstpixel;
-    int x_offset, y_offset;
-    VALUE image;
+  int width, height;    
+  float top, left;    
+  int tname;
+  float * td_array;
+  int yincr, firstpixel;
+  int x_offset, y_offset;
+  VALUE image;
 } texture_info;
 
 
 /* convenience macro */
 #define IMAGE_BOUNDS(X) ((image_bounds *) (X))
 typedef struct {
-    int xmin;
-    int ymin;
-    int xmax;
-    int ymax;
+  int xmin;
+  int ymin;
+  int xmax;
+  int ymax;
 } image_bounds;
 
 
 typedef struct action_struct {
-    int xmin, ymin, xmax, ymax;
-    sync sync_mode;
+  int xmin, ymin, xmax, ymax;
+  sync sync_mode;
 
-    /* pointer to associated texture */
-    /* a bit of a kludge having this here
-       since it's only being used by convert_image_local_color_to_rgba */
-    texture_info * tex;
+  /* pointer to associated texture */
+  /* a bit of a kludge having this here
+     since it's only being used by convert_image_local_color_to_rgba */
+  texture_info * tex;
     
-    VALUE hash_arg;
-
-    /* action color */
-    rgba color;
+  VALUE hash_arg;
 
-    /* pen data */
-    struct {
+  /* action color */
+  rgba color;
 
-        /* color control, dynamic */
-        bool has_color_control_proc;
-        VALUE color_control_proc;
-        int color_control_arity;
+  /* pen data */
+  struct {
 
-        /* color control, static */
-        bool has_color_control_transform;
-        rgba color_mult;
-        rgba color_add;
+    /* color control, dynamic */
+    bool has_color_control_proc;
+    VALUE color_control_proc;
+    int color_control_arity;
 
-        /* texture fill */
-        bool has_source_texture;
-        texture_info source_tex;
+    /* color control, static */
+    bool has_color_control_transform;
+    rgba color_mult;
+    rgba color_add;
 
-        /* lerp */
-        bool has_lerp;
-        float lerp;
+    /* texture fill */
+    bool has_source_texture;
+    texture_info source_tex;
 
-        /* alpha blend */
-        bool alpha_blend;
+    /* lerp */
+    bool has_lerp;
+    float lerp;
 
-        /* drawing mode */
-        bool has_drawing_mode;
-        draw_mode drawing_mode;
-
-        /* tolerance */
-        bool has_tolerance;
-        float tolerance;
-
-        /* color selection */
-        bool has_color_select;
-        rgba_list source_select;
-        rgba_list source_ignore;
-        rgba_list dest_select;
-        rgba_list dest_ignore;
+    /* alpha blend */
+    bool alpha_blend;
+    alpha_blend_mode_t alpha_blend_mode;
+      
+    /* drawing mode */
+    bool has_drawing_mode;
+    draw_mode drawing_mode;
+
+    /* tolerance */
+    bool has_tolerance;
+    float tolerance;
+
+    /* color selection */
+    bool has_color_select;
+    rgba_list source_select;
+    rgba_list source_ignore;
+    rgba_list dest_select;
+    rgba_list dest_ignore;
       
-    } pen;
+  } pen;
 
 } action_struct;
 

data/lib/texplay/alone.rb

@@ -0,0 +1,20 @@
+direc = File.dirname(__FILE__)
+
+require "#{direc}/../texplay"
+
+module TexPlay
+  Win = Gosu::Window.new(0, 0, false)
+
+  set_options :sync_mode => :no_sync
+
+  class << self
+    def load(name)
+      Gosu::Image.new(Win, name)
+    end
+  
+    alias_method :original_create_image, :create_image
+    def create_image(width, height, options={})
+      original_create_image(Win, width, height, options)
+    end      
+  end
+end

data/lib/texplay/c_function_docs.rb

@@ -1,3 +1,4 @@
+# -*- coding: iso-8859-1 -*-
 # This code is never run; it is just here so we can document the C functions.
 
 
@@ -44,7 +45,7 @@ module TexPlay
   def each(&block)
   end
 
-  # Fill at a given position.
+  # Perform a Flood Fill at a given position.
   #
   # @param [Number] x
   # @param [Number] y
@@ -186,4 +187,4 @@ module TexPlay
   # @return [String] Raw binary data (blob) in RGBA byte order.
   def to_blob
   end
-end
+end

data/lib/texplay/version.rb

@@ -1,3 +1,3 @@
 module TexPlay
-  VERSION = "0.3.1"
+  VERSION = "0.3.3"
 end

data/lib/texplay-contrib.rb

@@ -1,171 +1,164 @@
-begin
-    require 'rubygems'
-rescue LoadError
-end
-
-require 'texplay'
-
 # to bring in String#each_char for 1.8
 if RUBY_VERSION =~ /1.8/
-    require 'jcode'
+  require 'jcode'
 end
 
 # setup will be executed straight after Gosu::Image instantiation
 TexPlay::on_setup do
-    @turtle_pos = TexPlay::TPPoint.new(width / 2, height / 2 )
-    @turtle_angle = 0
+  @turtle_pos = TexPlay::TPPoint.new(width / 2, height / 2 )
+  @turtle_angle = 0
 end
 
 
 TexPlay::create_macro(:move_to) do |x, y|
-    capture { 
-        @turtle_pos.x = x
-        @turtle_pos.y = y
-    }
+  capture { 
+    @turtle_pos.x = x
+    @turtle_pos.y = y
+  }
 end
 
 TexPlay::create_macro(:move_rel) do |dx, dy|
-    capture { 
-        @turtle_pos.x += dx
-        @turtle_pos.y += dy
-    }
+  capture { 
+    @turtle_pos.x += dx
+    @turtle_pos.y += dy
+  }
 end
 
 TexPlay::create_macro(:line_to) do |x, y, *other|
-    capture { 
-        line(@turtle_pos.x, @turtle_pos.y, x, y, *other)
+  capture { 
+    line(@turtle_pos.x, @turtle_pos.y, x, y, *other)
 
-        @turtle_pos.x, @turtle_pos.y = x, y
-    }
+    @turtle_pos.x, @turtle_pos.y = x, y
+  }
 end
 
 TexPlay::create_macro(:line_rel) do |dx, dy, *other|
-    capture { 
-        x = @turtle_pos.x + dx
-        y = @turtle_pos.y + dy
+  capture { 
+    x = @turtle_pos.x + dx
+    y = @turtle_pos.y + dy
 
-        line(@turtle_pos.x, @turtle_pos.y, x, y, *other)
+    line(@turtle_pos.x, @turtle_pos.y, x, y, *other)
 
-        @turtle_pos.x, @turtle_pos.y = x, y
-    }
+    @turtle_pos.x, @turtle_pos.y = x, y
+  }
 end
 
 TexPlay::create_macro(:turn_to) do |a|
-    capture {
-        @turtle_angle = a
-    }
+  capture {
+    @turtle_angle = a
+  }
 end
 
 TexPlay::create_macro(:turn) do |da|
-    capture { 
-        @turtle_angle += da
-    }
+  capture { 
+    @turtle_angle += da
+  }
 end
 
 TexPlay::create_macro(:forward) do |dist, *other|
-    capture {
-        visible = other.shift
+  capture {
+    visible = other.shift
 
-        radians_per_degree = 0.0174532925199433
+    radians_per_degree = 0.0174532925199433
 
-        x = @turtle_pos.x + dist * Math::cos(radians_per_degree * @turtle_angle)
-        y = @turtle_pos.y + dist * Math::sin(radians_per_degree * @turtle_angle)
+    x = @turtle_pos.x + dist * Math::cos(radians_per_degree * @turtle_angle)
+    y = @turtle_pos.y + dist * Math::sin(radians_per_degree * @turtle_angle)
 
-        if(visible) then
-            line_to(x, y, *other)
-        else
-            move_to(x, y)
-        end
-    }
+    if(visible) then
+      line_to(x, y, *other)
+    else
+      move_to(x, y)
+    end
+  }
 end
 
 # L-System code
 # adding LSystem class to TexPlay module
 class TexPlay::LSystem
-    def initialize(&block)
-        @rules = {}
-        
-        instance_eval(&block) if block
-    end
+  def initialize(&block)
+    @rules = {}
     
-    def rule(new_rule)
-        @rules.merge!(new_rule)
-    end
-
-    def atom(new_atom)
-        @atom = new_atom
-    end
-
-    def angle(new_angle=nil)
-        return @angle if !new_angle
-        @angle = new_angle
-    end
-
-    def produce_string(order)
-        order = order[:order]
-        string = @atom.dup
+    instance_eval(&block) if block
+  end
+  
+  def rule(new_rule)
+    @rules.merge!(new_rule)
+  end
+
+  def atom(new_atom)
+    @atom = new_atom
+  end
+
+  def angle(new_angle=nil)
+    return @angle if !new_angle
+    @angle = new_angle
+  end
+
+  def produce_string(order)
+    order = order[:order]
+    string = @atom.dup
+    
+    order.times do
+      i = 0
+      while(i < string.length)
+        sub = @rules[string[i, 1]]
         
-        order.times do
-            i = 0
-            while(i < string.length)
-                sub = @rules[string[i, 1]]
-                
-                string[i] = sub if sub
-                
-                i += sub ? sub.length : 1
-            end
-        end
+        string[i] = sub if sub
         
-        string
+        i += sub ? sub.length : 1
+      end
     end
+    
+    string
+  end
 end
 
 # L-System macro
 TexPlay::create_macro(:lsystem) do |x, y, system, options|
-    capture {
-        theta = system.angle
-        turtle_stack = []
-        move_to(x, y)
-        line_length = options[:line_length] || 1
-        
-        system.produce_string(options).each_char do |v|
-                      
-            case v
-            when "F"
-                forward(line_length, true)
-            when "+"
-                turn(theta)
-            when "-"
-                turn(-theta)
-            when "["
-                turtle_stack.push([@turtle_pos.dup, @turtle_angle])
-            when "]"
-                @turtle_pos, @turtle_angle = turtle_stack.pop
-            end
-        end
-    }
+  capture {
+    theta = system.angle
+    turtle_stack = []
+    move_to(x, y)
+    line_length = options[:line_length] || 1
+    
+    system.produce_string(options).each_char do |v|
+      
+      case v
+      when "F"
+        forward(line_length, true)
+      when "+"
+        turn(theta)
+      when "-"
+        turn(-theta)
+      when "["
+        turtle_stack.push([@turtle_pos.dup, @turtle_angle])
+      when "]"
+        @turtle_pos, @turtle_angle = turtle_stack.pop
+      end
+    end
+  }
 end
 
 # Scaling
 # uses nearest-neighbour
 TexPlay::create_macro(:splice_and_scale) do |img, cx, cy, *options|
-    options = options.first ? options.first : {}
-
-    options = {
-        :color_control => proc do |c1, c2, x, y|
-            factor = options[:factor] || 1
-            factor_x = options[:factor_x] || factor
-            factor_y = options[:factor_y] || factor
-
-            x = factor_x * (x - cx) + cx
-            y = factor_y * (y - cy) + cy
-           
-            rect x, y, x + factor_x, y + factor_y, :color => c2, :fill => true
-            :none
-        end
-    }.merge!(options)
-   
-    splice img, cx, cy, options
-
-    self
+  options = options.first ? options.first : {}
+
+  options = {
+    :color_control => proc do |c1, c2, x, y|
+      factor = options[:factor] || 1
+      factor_x = options[:factor_x] || factor
+      factor_y = options[:factor_y] || factor
+
+      x = factor_x * (x - cx) + cx
+      y = factor_y * (y - cy) + cy
+      
+      rect x, y, x + factor_x, y + factor_y, :color => c2, :fill => true
+      :none
+    end
+  }.merge!(options)
+  
+  splice img, cx, cy, options
+
+  self
 end

data/lib/texplay.rb

@@ -4,7 +4,6 @@
 direc = File.expand_path(File.dirname(__FILE__))
 
 # include gosu first
-require 'rbconfig'
 require 'gosu'
 require "#{direc}/texplay/version"
 
@@ -14,13 +13,12 @@ module TexPlay
   class << self
     def on_setup(&block)
       raise "need a block" if !block
-      
       @__init_procs__ ||= []
       @__init_procs__.push(block)
     end
 
     def setup(receiver)
-      if @__init_procs__ then
+      if @__init_procs__ 
         @__init_procs__.each do |init_proc|
           receiver.instance_eval(&init_proc)
         end
@@ -36,7 +34,12 @@ module TexPlay
       raise ArgumentError, "Height and width must be positive" if height <= 0 or width <= 0
       
       img = Gosu::Image.new(window, EmptyImageStub.new(width, height), :caching => options[:caching])
-      img.rect 0, 0, img.width - 1, img.height - 1, :color => options[:color], :fill => true 
+
+      # this should be a major speedup (avoids both a cache and a sync
+      # if color is alpha (default)
+      if options[:color] != :alpha
+        img.rect 0, 0, img.width - 1, img.height - 1, :color => options[:color], :fill => true
+      end
 
       img
     end
@@ -46,7 +49,7 @@ module TexPlay
     # Image can be :tileable, but it will break if it is tileable AND gets modified after creation.
     def from_blob(window, blob_data, width, height, options={})
       options = {
-        :caching => @options[:caching],
+        :caching => false,
         :tileable => false,
       }.merge!(options)
 
@@ -71,7 +74,7 @@ module TexPlay
     # default values defined here
     def set_defaults
       @options = {
-        :caching => true
+        :caching => :lazy
       }
     end
 
@@ -121,6 +124,7 @@ module TexPlay
   #
   # This object duck-types an RMagick image (#rows, #columns, #to_blob), so that Gosu will import it.
   class ImageStub
+
     # @return [Integer]
     attr_reader :rows, :columns
 
@@ -153,14 +157,15 @@ module TexPlay
 end
 
 # bring in user-defined extensions to TexPlay
-dlext = Config::CONFIG['DLEXT']
 begin
   if RUBY_VERSION && RUBY_VERSION =~ /1.9/
-    require "#{direc}/1.9/texplay.#{dlext}"
+    require "#{direc}/1.9/texplay"
   else
-    require "#{direc}/1.8/texplay.#{dlext}"
+    require "#{direc}/1.8/texplay"
   end
 rescue LoadError => e
+  require 'rbconfig'
+  dlext = Config::CONFIG['DLEXT']
   require "#{direc}/texplay.#{dlext}"
 end
 
@@ -203,16 +208,33 @@ module Gosu
         options = {
           :caching => TexPlay.get_options[:caching]
         }.merge!(options)
-        
-        # refresh the TexPlay image cache
+
+        caching_mode = options[:caching]
+
+        # we can't manipulate large images, so skip them.
         if obj.width <= (TexPlay::TP_MAX_QUAD_SIZE) &&
-            obj.height <= (TexPlay::TP_MAX_QUAD_SIZE) && obj.quad_cached? then
-          obj.refresh_cache if options[:caching]
+            obj.height <= (TexPlay::TP_MAX_QUAD_SIZE)
+          
+          if caching_mode
+            if caching_mode == :lazy
+
+              # only cache if quad already cached (to refresh old data)
+              # otherwise cache lazily at point of first TexPlay call
+              obj.refresh_cache if obj.quad_cached?
+
+            else
+              
+              # force a cache - this obviates the need for a
+              # potentialy expensive runtime cache of the image by
+              # moving the cache to load-time
+              obj.refresh_cache
+            end
+          end
         end
         
         # run custom setup
         TexPlay.setup(obj)
-        
+
         obj.instance_variable_set(:@__window__, window)
 
         obj

data/live/live.rb

@@ -0,0 +1,85 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/texplay"
+require 'pry'
+
+WIDTH = 640
+HEIGHT = 480
+
+class Gosu::Image
+  attr_accessor :x, :y
+
+  alias_method :orig_init, :initialize
+  def initialize(*args)
+    @x = WIDTH / 2
+    @y = HEIGHT / 2
+    orig_init(*args)
+  end
+end
+
+class WinClass < Gosu::Window
+
+  class View
+    attr_accessor :zoom, :rotate
+
+    def initialize
+      @zoom = 1
+      @rotate = 0
+    end
+
+    def reset
+      @zoom = 1
+      @rotate = 0
+    end
+  end
+  
+  attr_reader :images, :view
+  
+  def initialize
+    super(WIDTH, HEIGHT, false)
+    Gosu.enable_undocumented_retrofication
+
+    @images = []
+    @view = View.new
+    @pry_instance = Pry.new :prompt => [Proc.new { "(live)> " }, Proc.new { "(live)* " }]
+    
+    @img = TexPlay.create_image(self, 200, 200)
+    @img.rect 0, 0, @img.width - 1, @img.height - 1
+    
+    images << @img
+    @binding = binding
+  end
+
+  def create_image(width, height, options={})
+    TexPlay.create_image(self, width, height, options)
+  end
+
+  def load_image(file)
+    Gosu::Image.new(self, file)
+  end
+
+  def show_image(image)
+    images << image
+  end
+
+  def hide_image(image)
+    images.delete(image)
+  end
+  
+  def draw
+    images.uniq!
+    images.each do |v|
+      v.draw_rot(v.x, v.y, 1, view.rotate, 0.5, 0.5, view.zoom, view.zoom)
+    end
+  end
+
+  def update
+    @pry_instance.rep(@binding)
+  end
+end
+
+w = WinClass.new
+
+w.show
+

data/test/image_spec.rb

@@ -0,0 +1,45 @@
+direc = File.dirname(__FILE__)
+
+require "#{direc}/../lib/texplay"
+
+class Module
+  public :remove_const
+end
+
+describe Gosu::Image do
+  before do
+    @window = Gosu::Window.new(640, 480, false)
+    NormalImageSize = [Gosu::MAX_TEXTURE_SIZE - 2, Gosu::MAX_TEXTURE_SIZE - 2]
+    TooLargeImageSize = [2000, 2000]
+  end
+
+  after do
+    Object.remove_const(:NormalImageSize)
+    Object.remove_const(:TooLargeImageSize)
+  end
+  
+  describe "Gosu::Image#new (patched by TexPlay)" do
+    describe "caching option" do
+      it "should not cache image if :caching => false" do
+        source_image = TexPlay.create_image(@window, *NormalImageSize)
+        source_image.quad_cached?.should == false
+
+        image = Gosu::Image.new(@window, source_image, :caching => false)
+        image.width.should == NormalImageSize[0]
+        image.height.should == NormalImageSize[1]
+
+        image.quad_cached?.should == false
+      end
+
+      it "should cache the image if :caching => true" do
+        source_image = TexPlay.create_image(@window, *NormalImageSize)
+
+        image = Gosu::Image.new(@window, source_image, :caching => true)
+        image.width.should == NormalImageSize[0]
+        image.height.should == NormalImageSize[1]
+
+        image.quad_cached?.should == true
+      end
+    end
+  end
+end

data/test/texplay_spec.rb

@@ -0,0 +1,141 @@
+$LOAD_PATH.unshift File.join(File.expand_path(__FILE__), '..', 'lib','texplay')
+direc = File.dirname(__FILE__)
+
+require "#{direc}/../lib/texplay"
+
+describe TexPlay do
+  described_class = TexPlay
+  
+  before do
+    @window = Gosu::Window.new(640, 480, false)
+  end
+
+  describe "#create_image" do
+    it "should create a blank image of the correct size" do
+      width, height = 30, 10
+      image = described_class.create_image(@window, width, height)
+
+      image.width.should == width
+      image.height.should == height
+
+      width.times do |x|
+        height.times do |y|
+          image.get_pixel(x, y).should == [0.0, 0.0, 0.0, 0.0]
+        end
+      end
+    end
+
+    it "should create a coloured image of the correct size" do
+      width, height = 10, 30
+      color = [1.0, 1.0, 0.0, 1.0]
+      image = described_class.create_image(@window, width, height, :color => color)
+
+      image.width.should == width
+      image.height.should == height
+
+      width.times do |x|
+        height.times do |y|
+          image.get_pixel(x, y).should == color
+        end
+      end
+    end
+
+    it "should raise an error if an image dimension is 0 or less" do
+      lambda { described_class.create_image(@window, 0, 0)}.should.raise ArgumentError
+    end
+
+    # TODO: Should probably be an ArgumentError.
+    it "should NOT raise an error if the image would be too large (as uses raw blobs, doesnt use TexPlay at all)" do
+      too_big = TexPlay::TP_MAX_QUAD_SIZE + 1
+      [[too_big, 5], [10, too_big], [too_big, too_big]].each do |width, height|
+        lambda { described_class.create_image(@window, width, height)}.should.not.raise Exception
+      end
+    end
+  end
+
+  describe "#clear" do
+    it "should clear an image to the correct color" do
+      img = described_class.create_image(@window, 10, 10)
+      img.clear :color => :red
+      (0...img.width).each do |x|
+        (0...img.height).each do |y|
+          img.get_pixel(x,y).should == [1,0,0,1]
+        end
+      end
+    end
+  end
+
+  describe "#from_blob" do
+    # it "should create an image with the requested pixel data and size" do
+    #   # 4 x 3, with columns of red, blue, green, transparent.
+    #   gosu_colors = [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255], [0, 0, 0, 0]]
+    #   texplay_colors = gosu_colors.map {|a| a.map {|c| c / 255.0 } }
+    #   width, height = gosu_colors.size, 3
+      
+    #   image = described_class.from_blob(@window, (gosu_colors * height).flatten.pack('C*'), width, height)
+
+    #   image.width.should == width
+    #   image.height.should == height
+
+    #   texplay_colors.each_with_index do |color, x|
+    #     3.times do |y|
+    #       image.get_pixel(x, y).should == color
+    #     end
+    #   end
+    # end
+
+    it "should raise an error if the image size is not correct for the blob data" do
+      lambda { described_class.from_blob(@window, [1, 1, 1, 1].pack("C*"), 2, 1) }.should.raise ArgumentError
+    end
+
+    it "should raise an error if an image dimension is 0 or less" do
+      lambda { described_class.from_blob(@window, '', 0, 0) }.should.raise ArgumentError
+    end
+  end
+
+  describe "alpha_blend" do
+    it "should alpha blend using source alpha and not fixing alpha" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 1]
+      img1.clear :color => [0, 0, 1, 0.5], :alpha_blend => :source
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.75]
+    end
+
+    it "hash params true and :source should be equivalent" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 1]
+      img2 = img1.dup
+      img1.clear :color => [0, 0, 1, 0.5], :alpha_blend => :source
+      img2.clear :color => [0, 0, 1, 0.5], :alpha_blend => true
+      
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.75]
+      img2.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.75]
+    end
+
+    it "false or nil should prevent alpha blending" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 1]
+      img2 = img1.dup
+      img1.clear :color => [0, 0, 1, 0.5], :alpha_blend => false
+      img2.clear :color => [0, 0, 1, 0.5], :alpha_blend => nil
+      
+      img1.get_pixel(5, 5).should == [0, 0, 1, 0.5]
+      img2.get_pixel(5, 5).should == [0, 0, 1, 0.5]
+    end
+
+    it "should alpha blend using dest alpha and not fixing alpha" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 0.5]
+      img1.clear :color => [0, 0, 1, 1], :alpha_blend => :dest
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.75]
+    end
+
+    it "should alpha blend using source alpha and fixing alpha" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 1]
+      img1.clear :color => [0, 0, 1, 0.5], :alpha_blend => :source_with_fixed_alpha
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 1]
+    end
+
+    it "should alpha blend using dest alpha and fixing alpha" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 0.5]
+      img1.clear :color => [0, 0, 1, 1], :alpha_blend => :dest_with_fixed_alpha
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.5]
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: texplay
 version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: false
+  hash: 21
+  prerelease: 
   segments: 
   - 0
   - 3
-  - 1
-  version: 0.3.1
+  - 3
+  version: 0.3.3
 platform: i386-mingw32
 authors: 
 - John Mair (banisterfiend)
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-13 00:00:00 +13:00
+date: 2011-02-22 00:00:00 +13:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,6 +34,22 @@ dependencies:
         version: 0.7.25
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :development
+  version_requirements: *id002
 description: TexPlay is a light-weight image manipulation framework for Ruby and Gosu
 email: jrmair@gmail.com
 executables: []
@@ -46,6 +62,7 @@ files:
 - Rakefile
 - README.markdown
 - CHANGELOG
+- lib/texplay/alone.rb
 - lib/texplay/c_function_docs.rb
 - lib/texplay/version.rb
 - lib/texplay-contrib.rb
@@ -122,11 +139,13 @@ files:
 - examples/media/sand1.png
 - examples/media/sunset.png
 - examples/media/texplay.png
-- spec/image_spec.rb
-- spec/texplay_spec.rb
+- test/image_spec.rb
+- test/texplay_spec.rb
+- live/live.rb
+- .gemtest
 - lib/1.8/texplay.so
 - lib/1.9/texplay.so
-has_rdoc: yard
+has_rdoc: true
 homepage: http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/
 licenses: []
 
@@ -156,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: TexPlay is a light-weight image manipulation framework for Ruby and Gosu

data/spec/image_spec.rb

@@ -1,7 +0,0 @@
-$LOAD_PATH.unshift File.join(File.expand_path(__FILE__), '..', 'lib','texplay')
-
-require 'texplay'
-
-describe Gosu::Image do
-  it "should do all sorts of things"
-end

data/spec/texplay_spec.rb

@@ -1,80 +0,0 @@
-$LOAD_PATH.unshift File.join(File.expand_path(__FILE__), '..', 'lib','texplay')
-
-require 'texplay'
-
-describe TexPlay do
-  before :each do
-    @window = Gosu::Window.new(640, 480, false)
-  end
-
-  describe "#create_image" do
-    it "should create a blank image of the correct size" do
-      width, height = 30, 10
-      image = described_class.create_image(@window, width, height)
-
-      image.width.should == width
-      image.height.should == height
-
-      width.times do |x|
-        height.times do |y|
-          image.get_pixel(x, y).should == [0.0, 0.0, 0.0, 0.0]
-        end
-      end
-    end
-
-    it "should create a coloured image of the correct size" do
-      width, height = 10, 30
-      color = [1.0, 1.0, 0.0, 1.0]
-      image = described_class.create_image(@window, width, height, :color => color)
-
-      image.width.should == width
-      image.height.should == height
-
-      width.times do |x|
-        height.times do |y|
-          image.get_pixel(x, y).should == color
-        end
-      end
-    end
-
-    it "should raise an error if an image dimension is 0 or less" do
-      lambda { described_class.create_image(@window, 0, 0)}.should raise_error ArgumentError
-    end
-
-    # TODO: Should probably be an ArgumentError.
-    it "should raise an error if the image would be too large" do
-      too_big = TexPlay::TP_MAX_QUAD_SIZE + 1
-      [[too_big, 5], [10, too_big], [too_big, too_big]].each do |width, height|
-        lambda { described_class.create_image(@window, width, height)}.should raise_error Exception
-      end
-    end
-  end
-
-  describe "#from_blob" do
-    it "should create an image with the requested pixel data and size" do
-      # 4 x 3, with columns of red, blue, green, transparent.
-      gosu_colors = [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255], [0, 0, 0, 0]]
-      texplay_colors = gosu_colors.map {|a| a.map {|c| c / 255.0 } }
-      width, height = gosu_colors.size, 3
-      
-      image = described_class.from_blob(@window, (gosu_colors * height).flatten.pack('C*'), width, height)
-
-      image.width.should == width
-      image.height.should == height
-
-      texplay_colors.each_with_index do |color, x|
-        3.times do |y|
-          image.get_pixel(x, y).should == color
-        end
-      end
-    end
-
-    it "should raise an error if the image size is not correct for the blob data" do
-      lambda { described_class.from_blob(@window, [1, 1, 1, 1].pack("C*"), 2, 1) }.should raise_error ArgumentError
-    end
-
-    it "should raise an error if an image dimension is 0 or less" do
-      lambda { described_class.from_blob(@window, '', 0, 0) }.should raise_error ArgumentError
-    end
-  end
-end