texplay 0.2.722 → 0.2.800

data/Rakefile

@@ -39,29 +39,29 @@ Rake::ExtensionTask.new('texplay', specification)  do |ext|
 end
 
 
-# comment this when want to build normal gems.
-# only have this code uncommented when building mswin32 and mingw32
-# binary gems
-#   specification = Gem::Specification.new do |s|
-#     s.name = "texplay"
-#     s.summary = "TexPlay is a light-weight image manipulation framework for Ruby and Gosu"
-#     s.version = TexPlay::VERSION
-#     s.date = Time.now.strftime '%Y-%m-%d'
-#     s.author = "John Mair (banisterfiend)"
-#     s.email = 'jrmair@gmail.com'
-#     s.description = s.summary
-#     s.require_path = 'lib'
-#     s.add_dependency("gosu",">=0.7.14")
-#     s.platform = 'i386-mingw32'
-#     s.homepage = "http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/"
-#     s.has_rdoc = false
+#comment this when want to build normal gems.
+#only have this code uncommented when building mswin32 and mingw32
+#binary gems
+# specification = Gem::Specification.new do |s|
+#   s.name = "texplay"
+#   s.summary = "TexPlay is a light-weight image manipulation framework for Ruby and Gosu"
+#   s.version = TexPlay::VERSION
+#   s.date = Time.now.strftime '%Y-%m-%d'
+#   s.author = "John Mair (banisterfiend)"
+#   s.email = 'jrmair@gmail.com'
+#   s.description = s.summary
+#   s.require_path = 'lib'
+#   s.add_dependency("gosu",">=0.7.14")
+#   s.platform = 'i386-mswin32'
+#   s.homepage = "http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/"
+#   s.has_rdoc = false
 
-#     s.files =  ["Rakefile", "README.markdown", "CHANGELOG", 
-#                 "lib/texplay.rb", "lib/texplay-contrib.rb", "lib/texplay/version.rb", "lib/1.8/texplay.so",
-#                 "lib/1.9/texplay.so"] +
+#   s.files =  ["Rakefile", "README.markdown", "CHANGELOG", 
+#               "lib/texplay.rb", "lib/texplay-contrib.rb", "lib/texplay/version.rb", "lib/1.8/texplay.so",
+#               "lib/1.9/texplay.so"] +
 #     FileList["examples/*.rb", "examples/media/*"].to_a
 # end
-  
+
 Rake::GemPackageTask.new(specification) do |package|
   package.need_zip = false
   package.need_tar = false

data/examples/example_color_transform.rb

@@ -30,13 +30,12 @@ class W < Gosu::Window
         @y2 += 1
 
 
-        @copy2.splice @img, 0, 0, :crop => [@x2 - @rad, @y2 - @rad, @x2 + @rad, @y2 + @rad]
-        @copy.splice @img, 0, 0, :crop => [@x - @rad, @y - @rad, @x + @rad, @y + @rad]
+        @copy2.splice @img, 0, 0, :crop => [@x2 - @rad, @y2 - @rad, @x2 + @rad, @y2 + @rad], :sync_mode => :no_sync
+        @copy.splice @img, 0, 0, :crop => [@x - @rad, @y - @rad, @x + @rad, @y + @rad], :sync_mode => :no_sync
         @img.
-            circle @x, @y, @rad, :fill => true,
-        :color_control => { :mult => [1.0, 0.5, 0.5, 1] }
+            circle @x, @y, @rad, :fill => true, :lerp => 0.3, :color => :red
 
-         #    circle @x2, @y2, @rad, :fill => true,
+         @img.circle @x2, @y2, @rad, :fill => true, :lerp => 0.3, :color => :blue
 #             :color_control => { :mult => [0.3, 0.9, 0.3, 1] }
         
 

data/examples/example_trace.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+  def initialize
+    super(1024, 768, false, 20)
+    @img = TexPlay.create_image(self, 500, 500).fill(3,3, :color => :alpha)
+    @img.rect 100, 100, 300 , 300, :color => :blue, :fill => true
+    puts (@img.line 0,0, 100, 100, :trace => { :until_color => :blue }).inspect
+  end
+
+  def draw
+    @img.draw 100, 50,1
+  end
+  
+end
+
+
+w = W.new
+w.show
+

data/examples/example_weird.rb

@@ -6,24 +6,15 @@ require 'texplay'
 class W < Gosu::Window
   def initialize
     super(1024, 768, false, 20)
-    @img = Gosu::Image.new(self, "#{Common::MEDIA}/bird.png")
-    @green = Gosu::Image.new(self, "#{Common::MEDIA}/gob.png")
-    ###    @img = Gosu::Image.new(self, "gob.png")
-    #@img = TexPlay.create_image(self, 500, 500).fill(0,0, :color => :red)
-
-    @img.splice @green, 0, 0, :alpha_blend => true
-    puts @img.get_pixel 15, 15
-    #        @img.rect 0, 0, @img.width, @img.height, :texture => @gob, :fill => true, :alpha_blend => true
-
+    @img = Gosu::Image.new(self, "#{Common::MEDIA}/gob.png")
+    @img.rect 0, 10, 300, 300, :color => :blue, :fill => true, :mode => :softlight
   end
 
   def draw
     @img.draw 100, 50,1
   end
-  
 end
 
-
 w = W.new
 w.show
 

data/ext/texplay/actions.c

@@ -12,7 +12,24 @@
 
 
 /** line_do_action, bresenham's algorithm **/
-void
+typedef enum { no_mode, until_color, while_color} trace_mode_type;
+
+static inline bool
+is_trace_match(rgba c, rgba trace_color, trace_mode_type trace_mode)
+{
+  if(trace_mode == while_color) {
+    if(!cmp_color(c, trace_color))
+      return true;
+  }
+  else if(trace_mode == until_color) {
+    if(cmp_color(c, trace_color))
+      return true;
+  }
+
+  return false;
+}
+
+trace_match
 line_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_arg,
                sync sync_mode, bool primary, action_struct * payload)
 {
@@ -21,11 +38,39 @@ line_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_ar
     action_struct cur;
     int thickness = 1;
 
-    draw_prologue(&cur, tex, x1, y1,
-                  x2, y2, &hash_arg, sync_mode, primary, &payload);
+    bool has_trace = false;
+    rgba trace_color;
+    trace_mode_type trace_mode = no_mode;
+    
+
 
     if(has_optional_hash_arg(hash_arg, "thickness")) 
         thickness = NUM2INT(get_from_hash(hash_arg, "thickness"));
+    
+    if(has_optional_hash_arg(hash_arg, "trace") && primary) {
+      VALUE trace_hash = get_from_hash(hash_arg, "trace");
+
+      /* we're tracing (not drawing) */
+      has_trace = true;
+
+      /* since we're not drawing, no need to sync */
+      sync_mode = no_sync;
+
+      if(has_optional_hash_arg(trace_hash, "until_color")) {
+        VALUE c = get_from_hash(trace_hash, "until_color");
+        trace_color = convert_rb_color_to_rgba(c);
+        trace_mode = until_color;
+      }
+      else if(has_optional_hash_arg(trace_hash, "while_color")) {
+        VALUE c = get_from_hash(trace_hash, "while_color");
+        trace_color = convert_rb_color_to_rgba(c);
+        trace_mode = while_color;
+      }
+    }
+
+    draw_prologue(&cur, tex, x1, y1,
+                  x2, y2, &hash_arg, sync_mode, primary, &payload);
+    
 
     /* clip the line */
     cohen_sutherland_clip(&x1, &y1, &x2, &y2, 0, 0, tex->width - 1, tex->height - 1);
@@ -50,7 +95,14 @@ line_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_ar
         F = 2 * H - W;
         while(x != x2) {
            if(thickness <= 1) {
+             if(!has_trace)
                 set_pixel_color_with_style(payload, tex, x, y);
+             else {
+               rgba c = get_pixel_color(tex, x, y);
+
+               if (is_trace_match(c, trace_color, trace_mode)) 
+                 return (trace_match) { x, y, c };
+             }
             }
             else {
                 set_hash_value(hash_arg, "fill", Qtrue);
@@ -71,7 +123,14 @@ line_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_ar
         while(y != y2 ) {
 
             if(thickness <= 1) {
+             if(!has_trace)
                 set_pixel_color_with_style(payload, tex, x, y);
+             else {
+               rgba c = get_pixel_color(tex, x, y);
+
+               if (is_trace_match(c, trace_color, trace_mode)) 
+                 return (trace_match) { x, y, c };
+             }                
             }
             else {
                 set_hash_value(hash_arg, "fill", Qtrue);
@@ -89,7 +148,14 @@ line_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_ar
     }
 
     if(thickness <= 1) {
-        set_pixel_color_with_style(payload, tex, x2, y2);
+        if(!has_trace)
+          set_pixel_color_with_style(payload, tex, x2, y2);
+        else {
+          rgba c = get_pixel_color(tex, x, y);
+          
+          if (is_trace_match(c, trace_color, trace_mode)) 
+            return (trace_match) { x, y, c };
+        }        
     }
     else {
         set_hash_value(hash_arg, "fill", Qtrue);
@@ -97,6 +163,8 @@ line_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_ar
                 
     }
     draw_epilogue(&cur, tex, primary);
+
+    return (trace_match) { .x = -1, .y = -1 };
 }
 /** end line **/
 

data/ext/texplay/actions.h

@@ -1,9 +1,17 @@
 #ifndef GUARD_ACTIONS_H
 #define GUARD_ACTIONS_H
 
+#include "texplay.h"
+
+/* used by line_do_action */
+typedef struct {
+  int x, y;
+  rgba color;
+} trace_match;
+
 
 /* lines */
-void line_do_action(int, int, int, int, texture_info *, VALUE, sync, bool primary, action_struct * payload);
+trace_match line_do_action(int, int, int, int, texture_info *, VALUE, sync, bool primary, action_struct * payload);
 
 /* circles */
 void circle_do_action(int, int, int, texture_info *, VALUE, sync, bool primary, action_struct * payload);

data/ext/texplay/bindings.c

@@ -505,7 +505,18 @@ m_flood_fill(int argc, VALUE * argv, VALUE self)
     
     return self;
 }
-    
+
+static inline VALUE
+convert_trace_match_to_ruby_array(trace_match match)
+{
+  VALUE ary = rb_ary_new();
+
+  rb_ary_store(ary, 0, INT2FIX(match.x));
+  rb_ary_store(ary, 1, INT2FIX(match.y));
+  rb_ary_store(ary, 2, convert_rgba_to_rb_color(&match.color));
+
+  return ary;
+}
 
 /* line action */
 VALUE
@@ -515,6 +526,7 @@ m_line(int argc, VALUE * argv, VALUE self)
     int last = argc - 1;
     VALUE options;
     texture_info tex;
+    trace_match match;
 
     ADJUST_SELF(self);
 
@@ -526,7 +538,14 @@ m_line(int argc, VALUE * argv, VALUE self)
 
     get_texture_info(self, &tex);
 
-    line_do_action(x1, y1, x2, y2, &tex, options, sync_mode, true, NULL);
+    match = line_do_action(x1, y1, x2, y2, &tex, options, sync_mode, true, NULL);
+
+    if (has_optional_hash_arg(options, "trace")) {
+      if (match.x == -1)
+        return Qnil;
+      else
+        return convert_trace_match_to_ruby_array(match);
+    }
 
     return self;
 }

data/ext/texplay/graphics_utils.c

@@ -13,9 +13,13 @@
 /* small helper functions */
 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_fill_texture(action_struct * cur);
 static void prepare_color_control(action_struct * cur);
+static rgba apply_lerp(action_struct * payload, texture_info * tex, int x, int y);
 static rgba apply_alpha_blend(action_struct * payload, texture_info * tex, int x, int y, rgba blended_pixel);
+static rgba apply_drawing_mode(action_struct * payload, texture_info * tex, int x, int y);
+
 static rgba apply_color_control_transform(action_struct * payload, texture_info * tex, int x, int y);
 static rgba exec_color_control_proc(action_struct * cur, texture_info * tex, int x, int y, rgba blended_pixel);
 /* end helpers */
@@ -149,11 +153,16 @@ set_pixel_color_with_style(action_struct * payload, texture_info * tex, int x, i
 
     blended_pixel = payload->color;
 
+    /* for linear interpolation */
+    if(payload->pen.has_lerp) {
+      blended_pixel = apply_lerp(payload, tex, x, y);
+    }
+
     /* for color_control transform */
     if(payload->pen.has_color_control_transform)
         blended_pixel = apply_color_control_transform(payload, tex, x, y);
     
-    /*    for texture fill  */
+    /* for texture fill  */
     if(payload->pen.has_source_texture)
         blended_pixel = get_pixel_color(&payload->pen.source_tex,
                                          x % payload->pen.source_tex.width,
@@ -165,7 +174,10 @@ set_pixel_color_with_style(action_struct * payload, texture_info * tex, int x, i
     
 
     /*  TO DO: do bitwise pixel combinations here */
-    
+    if(payload->pen.has_drawing_mode) {
+      blended_pixel = apply_drawing_mode(payload, tex, x, y);
+    }
+
     /*  TO DO: refactor into its own helper function
         & rewrite using sse2 */
     if(payload->pen.alpha_blend)
@@ -236,13 +248,13 @@ create_image(VALUE window, int width, int height)
     VALUE gosu = rb_const_get(rb_cObject, rb_intern("Gosu"));
     VALUE image = rb_const_get(gosu, rb_intern("Image"));
 
-    VALUE TP = rb_const_get(rb_cObject, rb_intern("TexPlay"));
-    VALUE EmptyImageStub = rb_const_get(TP, rb_intern("EmptyImageStub"));
+    VALUE tp = rb_const_get(rb_cObject, rb_intern("TexPlay"));
+    VALUE empty_image_stub = rb_const_get(tp, rb_intern("EmptyImageStub"));
     
     VALUE rmagick_img;
     VALUE new_image;
 
-    rmagick_img = rb_funcall(EmptyImageStub, rb_intern("new"), 2, INT2FIX(width), INT2FIX(height));
+    rmagick_img = rb_funcall(empty_image_stub, rb_intern("new"), 2, INT2FIX(width), INT2FIX(height));
 
     new_image = rb_funcall(image, rb_intern("new"), 2, window, rmagick_img);
 
@@ -275,6 +287,12 @@ initialize_action_struct(action_struct * cur, VALUE hash_arg, sync sync_mode)
     cur->pen.color_add.green = 0.0;
     cur->pen.color_add.blue = 0.0;
     cur->pen.color_add.alpha = 0.0;
+
+    /* lerp is off by default */
+    cur->pen.has_lerp = false;
+
+    /* drawing mode is off by deafult */
+    cur->pen.has_drawing_mode = false;
 }
     
 /* TODO: fix this function below, it's too ugly and bulky and weird **/
@@ -315,6 +333,16 @@ process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode,
 
         cur->pen.has_color_control_transform = true;
     }
+
+    /* lerp */
+    if(RTEST(get_from_hash(*hash_arg, "lerp"))) {
+      cur->pen.lerp = NUM2DBL(get_from_hash(*hash_arg, "lerp"));
+
+      /* bounds */
+      if(cur->pen.lerp > 1.0) cur->pen.lerp = 1.0;
+      if(cur->pen.lerp < 0.0) cur->pen.lerp = 0.0;
+      cur->pen.has_lerp = true;
+    }
     
     /* sync mode */
     if(has_optional_hash_arg(*hash_arg, "sync_mode")) {
@@ -337,6 +365,9 @@ process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode,
         
     }
 
+    /* process drawing mode */
+    prepare_drawing_mode(cur);
+
     /* process the color_control block or transform (if there is one) */
     prepare_color_control(cur);
 
@@ -349,8 +380,96 @@ process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode,
 
 }
 
+static void
+prepare_drawing_mode(action_struct * cur)
+{
+  if(is_a_hash(cur->hash_arg)) {
+    /* drawing mode */
+    if(has_optional_hash_arg(cur->hash_arg, "mode")) {
+      cur->pen.has_drawing_mode = true;
+
+      VALUE draw_mode = get_from_hash(cur->hash_arg, "mode");
 
 
+      Check_Type(draw_mode, T_SYMBOL);
+        
+      if(draw_mode == string2sym("clear"))
+        cur->pen.drawing_mode = clear;
+
+      else if(draw_mode == string2sym("copy"))
+        cur->pen.drawing_mode = copy;
+
+      else if(draw_mode == string2sym("noop"))
+        cur->pen.drawing_mode = noop;
+
+      else if(draw_mode == string2sym("set"))
+        cur->pen.drawing_mode = set;
+
+      else if(draw_mode == string2sym("copy_inverted"))
+        cur->pen.drawing_mode = copy_inverted;
+
+      else if(draw_mode == string2sym("invert"))
+        cur->pen.drawing_mode = invert;
+
+      else if(draw_mode == string2sym("and_reverse"))
+        cur->pen.drawing_mode = and_reverse;
+
+      else if(draw_mode == string2sym("and"))
+        cur->pen.drawing_mode = and;
+
+      else if(draw_mode == string2sym("or"))
+        cur->pen.drawing_mode = or;
+
+      else if(draw_mode == string2sym("nand"))
+        cur->pen.drawing_mode = nand;
+
+      else if(draw_mode == string2sym("nor"))
+        cur->pen.drawing_mode = nor;
+
+      else if(draw_mode == string2sym("xor"))
+        cur->pen.drawing_mode = xor;
+
+      else if(draw_mode == string2sym("equiv"))
+        cur->pen.drawing_mode = equiv;
+
+      else if(draw_mode == string2sym("and_inverted"))
+        cur->pen.drawing_mode = and_inverted;
+
+      else if(draw_mode == string2sym("or_inverted"))
+        cur->pen.drawing_mode = or_inverted;
+
+      else if(draw_mode == string2sym("additive"))
+        cur->pen.drawing_mode = additive;
+      else if(draw_mode == string2sym("multiply"))
+        cur->pen.drawing_mode = multiply;
+      else if(draw_mode == string2sym("screen"))
+        cur->pen.drawing_mode = screen;
+      else if(draw_mode == string2sym("overlay"))
+        cur->pen.drawing_mode = overlay;
+      else if(draw_mode == string2sym("darken"))
+        cur->pen.drawing_mode = darken;
+      else if(draw_mode == string2sym("lighten"))
+        cur->pen.drawing_mode = lighten;
+      else if(draw_mode == string2sym("colordodge"))
+        cur->pen.drawing_mode = colordodge;
+      else if(draw_mode == string2sym("colorburn"))
+        cur->pen.drawing_mode = colorburn;
+      else if(draw_mode == string2sym("hardlight"))
+        cur->pen.drawing_mode = hardlight;
+      else if(draw_mode == string2sym("softlight"))
+        cur->pen.drawing_mode = softlight;
+      else if(draw_mode == string2sym("difference"))
+        cur->pen.drawing_mode = difference;
+      else if(draw_mode == string2sym("exclusion"))
+        cur->pen.drawing_mode = exclusion;      
+      else
+        rb_raise(rb_eArgError, "unrecognized drawing mode: %s\n.",
+                 sym2string(draw_mode));
+    }
+  }
+}
+  
+
 /* set action color to return value of color_control proc */
 static void
 prepare_color_control(action_struct * cur)
@@ -457,7 +576,316 @@ prepare_fill_texture(action_struct * payload)
     }
 }
 
+/***********************************/
+/**** drawing mode related code ****/
+/***********************************/
+
+typedef struct {
+    unsigned char red, green, blue, alpha;
+} rgba_char;
+
+static inline rgba_char 
+color_float_to_int_format(rgba c)
+{
+  return (rgba_char) { c.red * 255,
+                       c.green * 255,
+                       c.blue * 255,
+                       c.alpha * 255
+                      };
+}
+
+static inline rgba 
+color_int_vals_to_float_format(unsigned char r, unsigned char g, unsigned char b,
+                   unsigned char a)
+{
+  return (rgba) { r / 255.0,
+                  g / 255.0,
+                  b / 255.0,
+                  a / 255.0
+                };
+}
+
+/* using terminology from photoshop PDF. b=background, s=source */
+static inline rgba
+mode_multiply(rgba b, rgba s)
+{
+  return (rgba) { b.red * s.red,
+                  b.green * s.green,
+                  b.blue * s.blue,
+                  b.alpha * s.alpha };
+}
+
+static inline rgba
+mode_screen(rgba b, rgba s)
+{
+  return (rgba) { b.red + s.red - (b.red * s.red),
+                  b.green + s.green - (b.green * s.green),
+                  b.blue + s.blue - (b.blue * s.blue),
+                  b.alpha + s.alpha - (b.alpha * s.alpha) };
+}
+
+static inline float
+mode_hardlight_channel(float b, float s)
+{
+  if (s <= 0.5)
+    return 2 * b *  s; 
+          
+  else
+    return b + s - (b * s); 
+}
+
+static inline rgba
+mode_hardlight(rgba b, rgba s)
+{
+  return (rgba) { mode_hardlight_channel(b.red, s.red),
+                  mode_hardlight_channel(b.green, s.green),
+                  mode_hardlight_channel(b.blue, s.blue),
+                  mode_hardlight_channel(b.alpha, s.alpha) };
+}
+
+/* function from the photoshop PDF to implement soft lighting */
+static inline float
+D(float x)
+{
+  if (x <= 0.25)
+    return ((16 * x - 12) * x + 4) * x;
+  else
+    return sqrt(x);
+}
+
+static inline float
+mode_softlight_channel(float b, float s)
+{
+  if (s <= 0.5)
+    return b - (1 - 2 * s) * b * (1 - b);
+  else
+    return b + (2 * s - 1) * (D(b) - b);
+}
+
+static inline rgba
+mode_softlight(rgba b, rgba s)
+{
+  return (rgba) { mode_softlight_channel(b.red, s.red),
+                  mode_softlight_channel(b.green, s.green),
+                  mode_softlight_channel(b.blue, s.blue),
+                  mode_softlight_channel(b.alpha, s.alpha) };
+}
+
+static inline float
+mode_colordodge_channel(float b, float s)
+{
+  if (s < 1)
+    return MIN(1, b / (1 - s));
+  else
+    return 1;
+}
+
+static inline float
+mode_colorburn_channel(float b, float s)
+{
+  if (s > 0)
+    return 1 - MIN(1, (1 - b) / s);
+  else
+    return 0;
+}
+  
+static rgba
+apply_drawing_mode(action_struct * payload, texture_info * tex, int x, int y)
+{
+  rgba finished_pixel;
+  
+  rgba source_pixel = payload->color;  
+  rgba dest_pixel = get_pixel_color(tex, x, y);
+
+  rgba_char dest_pixel_char = color_float_to_int_format(dest_pixel);
+  rgba_char source_pixel_char = color_float_to_int_format(source_pixel);
+  
+  switch(payload->pen.drawing_mode)
+    {
+      
+    /* bitwise blending functions */
+    case clear:
+      finished_pixel = (rgba) { 0, 0, 0, 0 };
+      break;
+    case copy:
+      finished_pixel = source_pixel;
+      break;
+    case noop:
+      finished_pixel = dest_pixel;
+      break;
+    case set:
+      finished_pixel = (rgba) { 1, 1, 1, 1 };
+      break;
+    case copy_inverted:
+      finished_pixel = color_int_vals_to_float_format(~source_pixel_char.red,
+                                               ~source_pixel_char.green,
+                                               ~source_pixel_char.blue,
+                                               ~source_pixel_char.alpha);
+      break;
+    case invert:
+      finished_pixel = color_int_vals_to_float_format(~dest_pixel_char.red,
+                                               ~dest_pixel_char.green,
+                                               ~dest_pixel_char.blue,
+                                               ~dest_pixel_char.alpha);
+                                               
+      break;
+    case and_reverse:
+      finished_pixel = color_int_vals_to_float_format(source_pixel_char.red | ~dest_pixel_char.red,
+                                               source_pixel_char.green | ~dest_pixel_char.green,
+                                               source_pixel_char.blue | ~dest_pixel_char.blue,
+                                               source_pixel_char.alpha | ~dest_pixel_char.alpha);
+      break;
+    case and:
+      finished_pixel = color_int_vals_to_float_format(source_pixel_char.red & dest_pixel_char.red,
+                                               source_pixel_char.green & dest_pixel_char.green,
+                                               source_pixel_char.blue & dest_pixel_char.blue,
+                                               source_pixel_char.alpha & dest_pixel_char.alpha);
+      break;
+    case or:
+      finished_pixel = color_int_vals_to_float_format(source_pixel_char.red | dest_pixel_char.red,
+                                               source_pixel_char.green | dest_pixel_char.green,
+                                               source_pixel_char.blue | dest_pixel_char.blue,
+                                               source_pixel_char.alpha | dest_pixel_char.alpha);
+      
+      break;
+    case nand:
+      finished_pixel = color_int_vals_to_float_format(~(source_pixel_char.red & dest_pixel_char.red),
+                                               ~(source_pixel_char.green & dest_pixel_char.green),
+                                               ~(source_pixel_char.blue & dest_pixel_char.blue),
+                                               ~(source_pixel_char.alpha & dest_pixel_char.alpha));
+      
+      break;
+    case nor:
+      finished_pixel = color_int_vals_to_float_format(~(source_pixel_char.red | dest_pixel_char.red),
+                                               ~(source_pixel_char.green | dest_pixel_char.green),
+                                               ~(source_pixel_char.blue | dest_pixel_char.blue),
+                                               ~(source_pixel_char.alpha | dest_pixel_char.alpha));
+      
+      break;
+    case xor:
+      finished_pixel = color_int_vals_to_float_format(source_pixel_char.red ^ dest_pixel_char.red,
+                                               source_pixel_char.green ^ dest_pixel_char.green,
+                                               source_pixel_char.blue ^ dest_pixel_char.blue,
+                                               source_pixel_char.alpha ^ dest_pixel_char.alpha);
+      
+      break;
+    case equiv:
+      finished_pixel = color_int_vals_to_float_format(~(source_pixel_char.red ^ dest_pixel_char.red),
+                                               ~(source_pixel_char.green ^ dest_pixel_char.green),
+                                               ~(source_pixel_char.blue ^ dest_pixel_char.blue),
+                                               ~(source_pixel_char.alpha ^ dest_pixel_char.alpha));
+      
+      break;
+    case and_inverted:
+      finished_pixel = color_int_vals_to_float_format(~source_pixel_char.red & dest_pixel_char.red,
+                                               ~source_pixel_char.green & dest_pixel_char.green,
+                                               ~source_pixel_char.blue & dest_pixel_char.blue,
+                                               ~source_pixel_char.alpha & dest_pixel_char.alpha);      
+      break;
+    case or_inverted:
+      finished_pixel = color_int_vals_to_float_format(~source_pixel_char.red | dest_pixel_char.red,
+                                               ~source_pixel_char.green | dest_pixel_char.green,
+                                               ~source_pixel_char.blue | dest_pixel_char.blue,
+                                               ~source_pixel_char.alpha | dest_pixel_char.alpha);
+      
+      break;
+
+    /* photoshop style blending functions */
+    case additive:
+      finished_pixel = (rgba) { MIN(source_pixel.red + dest_pixel.red, 1),
+                                MIN(source_pixel.green + dest_pixel.green, 1),
+                                MIN(source_pixel.blue + dest_pixel.blue, 1),
+                                MIN(source_pixel.alpha + dest_pixel.alpha, 1) };
+      break;
+    case multiply:
+      finished_pixel = mode_multiply(dest_pixel, source_pixel);
+                       
+      break;
+    case screen:
+      finished_pixel = mode_screen(dest_pixel, source_pixel);
+      
+      break;
+    case overlay:
+      finished_pixel = mode_hardlight(source_pixel, dest_pixel);
+
+      break;
+
+    case darken:
+      finished_pixel = (rgba) { MIN(source_pixel.red, dest_pixel.red),
+                                MIN(source_pixel.green, dest_pixel.green),
+                                MIN(source_pixel.blue, dest_pixel.blue),
+                                MIN(source_pixel.alpha, dest_pixel.alpha) };
+      break;
+    case lighten:
+      finished_pixel = (rgba) { MAX(source_pixel.red, dest_pixel.red),
+                                MAX(source_pixel.green, dest_pixel.green),
+                                MAX(source_pixel.blue, dest_pixel.blue),
+                                MAX(source_pixel.alpha, dest_pixel.alpha) };
+      break;
+    case colordodge:
+      finished_pixel = (rgba) { mode_colordodge_channel(dest_pixel.red, source_pixel.red),
+                                mode_colordodge_channel(dest_pixel.green, source_pixel.green),
+                                mode_colordodge_channel(dest_pixel.blue, source_pixel.blue),
+                                mode_colordodge_channel(dest_pixel.alpha, source_pixel.alpha) };
+                                
+      break;
+    case colorburn:
+      finished_pixel = (rgba) { mode_colorburn_channel(dest_pixel.red, source_pixel.red),
+                                mode_colorburn_channel(dest_pixel.green, source_pixel.green),
+                                mode_colorburn_channel(dest_pixel.blue, source_pixel.blue),
+                                mode_colorburn_channel(dest_pixel.alpha, source_pixel.alpha) };
+      break;
+    case hardlight:
+      finished_pixel = mode_hardlight(dest_pixel, source_pixel);
+
+      break;
+    case softlight:
+      finished_pixel = mode_softlight(dest_pixel, source_pixel);
+
+      break;
+    case difference:
+      finished_pixel = (rgba) { ABS(dest_pixel.red - source_pixel.red),
+                                ABS(dest_pixel.green - source_pixel.green),
+                                ABS(dest_pixel.blue - source_pixel.blue),
+                                ABS(dest_pixel.alpha - source_pixel.alpha) };
+      break;
+    case exclusion:
+      finished_pixel = (rgba) { dest_pixel.red + source_pixel.red - (2 * dest_pixel.red * source_pixel.red),
+                                dest_pixel.green + source_pixel.green - (2 * dest_pixel.green * source_pixel.green),
+                                dest_pixel.blue + source_pixel.blue - (2 * dest_pixel.blue * source_pixel.blue),
+                                dest_pixel.alpha + source_pixel.alpha - (2 * dest_pixel.alpha * source_pixel.alpha) };
+      break;
+    }
+
+  return finished_pixel;
+}
+/***************************************/
+/**** end drawing mode related code ****/
+/***************************************/
+
+
+static rgba
+apply_lerp(action_struct * payload, texture_info * tex, int x, int y)
+{
+  rgba finished_pixel;
+  rgba dest_pixel = get_pixel_color(tex, x, y);
+
+  finished_pixel.red = payload->pen.lerp * payload->color.red +
+    (1 - payload->pen.lerp) * dest_pixel.red;
+
+  finished_pixel.green = payload->pen.lerp * payload->color.green +
+    (1 - payload->pen.lerp) * dest_pixel.green;
+
+  finished_pixel.blue = payload->pen.lerp * payload->color.blue +
+    (1 - payload->pen.lerp) * dest_pixel.blue;
+
+  finished_pixel.alpha = payload->pen.lerp * payload->color.alpha +
+    (1 - payload->pen.lerp) * dest_pixel.alpha;
+
+  return finished_pixel;
+}
 
+  
 /* TODO: reimplement using SSE2 */
 static rgba
 apply_color_control_transform(action_struct * payload, texture_info * tex, int x, int y)

data/ext/texplay/texplay.h

@@ -40,6 +40,19 @@ typedef enum e_sync_mode {
     lazy_sync, eager_sync, no_sync
 } sync;
 
+typedef enum {
+  clear, copy, noop,
+  set, copy_inverted,
+  invert, and_reverse, and,
+  or, nand, nor, xor,
+  equiv, and_inverted,
+  or_inverted, additive,
+  multiply, screen, overlay,
+  darken, lighten, colordodge,
+  colorburn, hardlight, softlight,
+  difference, exclusion
+} draw_mode;
+
 /* structs */
 typedef struct s_rgba {
     float red, green, blue, alpha;
@@ -66,6 +79,7 @@ typedef struct {
     int ymax;
 } image_bounds;
 
+
 typedef struct action_struct {
     int xmin, ymin, xmax, ymax;
     sync sync_mode;
@@ -84,8 +98,8 @@ typedef struct action_struct {
     struct {
 
         /* color control, dynamic */
-        VALUE color_control_proc;
         bool has_color_control_proc;
+        VALUE color_control_proc;
         int color_control_arity;
 
         /* color control, static */
@@ -94,11 +108,20 @@ typedef struct action_struct {
         rgba color_add;
 
         /* texture fill */
-        texture_info source_tex;
         bool has_source_texture;
+        texture_info source_tex;
+
+        /* lerp */
+        bool has_lerp;
+        float lerp;
 
         /* alpha blend */
         bool alpha_blend;
+
+        /* drawing mode */
+        bool has_drawing_mode;
+        draw_mode drawing_mode;
+      
     } pen;
 
 } action_struct;

data/ext/texplay/utils.c

@@ -727,9 +727,6 @@ fact(int n)
 unsigned
 comb(int n, int r)
 {
-    /* double temp = fact(n) / (fact(r) * fact(n - r)); */
-    /* return temp; */
-
     /* nCr is symmetrical about n / 2 */
     if(r > (n / 2))
         r = n - r;

data/lib/texplay/version.rb

@@ -1,3 +1,3 @@
-module TexPlay
-    VERSION = "0.2.722"
-end
+module TexPlay
+    VERSION = "0.2.800"
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 722
-  version: 0.2.722
+  - 800
+  version: 0.2.800
 platform: ruby
 authors: 
 - John Mair (banisterfiend)
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-14 00:00:00 +13:00
+date: 2010-03-22 00:00:00 +13:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -84,6 +84,7 @@ files:
 - examples/example_simple.rb
 - examples/example_splice.rb
 - examples/example_sync.rb
+- examples/example_trace.rb
 - examples/example_turtle.rb
 - examples/example_weird.rb
 - examples/media/bird.png