texplay 0.3.1 → 0.3.3pre2

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-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