texplay 0.2.1-x86-mswin32-60

data/src/TAGS

@@ -0,0 +1,286 @@
+
+actions.c,3564
+do_sync(action_struct * cur, texture_info * tex) do_sync
34,1286
+line_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_arg,line_do_action
44,1509
+#define SIMPLE_FORMAT SIMPLE_FORMAT
126,3531
+#define POINT_FORMAT POINT_FORMAT
127,3555
+polyline_point(VALUE points, int k, int * x, int * y, int format, int draw_offset_x,polyline_point
131,3622
+polyline_do_action(VALUE points, texture_info * tex, VALUE hash_arg,polyline_do_action
154,4324
+ngon_do_action(int x, int y, int r, int num_sides, texture_info * tex, VALUE hash_arg,ngon_do_action
231,6780
+rect_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_arg,rect_do_action
275,8056
+circle_do_action(int x1, int y1, int r, texture_info * tex, VALUE hash_arg,circle_do_action
329,9856
+pixel_do_action(int x1, int y1, texture_info * tex, VALUE hash_arg,pixel_do_action
403,12271
+typedef struct { int x1, x2, y, dy; } LINESEGMENT;x1
417,12704
+typedef struct { int x1, x2, y, dy; } LINESEGMENT;x2
417,12704
+typedef struct { int x1, x2, y, dy; } LINESEGMENT;y
417,12704
+typedef struct { int x1, x2, y, dy; } LINESEGMENT;dy
417,12704
+typedef struct { int x1, x2, y, dy; } LINESEGMENT;LINESEGMENT
417,12704
+#define MAXDEPTH MAXDEPTH
419,12756
+#define PUSH(PUSH
421,12780
+#define POP(POP
425,12997
+flood_fill_do_action(int x, int y, texture_info * tex, VALUE hash_arg,flood_fill_do_action
429,13142
+glow_floodFill( int x, int y, rgba * seed_color, action_struct * cur, texture_info * tex, texture_info * tex2 )glow_floodFill
498,15194
+glow_fill_do_action(int x, int y, texture_info * tex, VALUE hash_arg,glow_fill_do_action
552,17088
+#define stackSize stackSize
586,18167
+int stack[stackSize];stack
587,18194
+int stackPointer;stackPointer
588,18216
+pop(int * x, int * y, int h) pop
591,18247
+push(int x, int y, int h) push
608,18559
+emptyStack() emptyStack
623,18834
+scan_fill_do_action(int x, int y, texture_info * tex, VALUE hash_arg,scan_fill_do_action
630,18902
+bezier_point(VALUE points, float u, float * x, float * y, int n, int format,bezier_point
700,21601
+bezier_do_action(VALUE points, texture_info * tex, VALUE hash_arg, sync sync_mode,bezier_do_action
731,22561
+set_color_array(VALUE ary, rgba * color)set_color_array
831,25683
+each_pixel_do_action(int x1, int y1, int x2, int y2, VALUE proc, texture_info * tex, VALUE hash_arg,each_pixel_do_action
840,25963
+splice_do_action(int x0, int y0, int cx1, int cy1, int cx2, int cy2, texture_info * splice_tex,splice_do_action
869,26797
+process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode, bool primary)process_common_hash_args
940,29218
+update_lazy_bounds(action_struct * cur, texture_info * tex)update_lazy_bounds
1021,32185
+update_bounds(action_struct * cur, int xmin, int ymin, int xmax, int ymax)update_bounds
1044,33016
+set_local_bounds(action_struct * cur, int xmin, int ymin, int xmax, int ymax, texture_info * tex)set_local_bounds
1056,33341
+draw_prologue(action_struct * cur, texture_info * tex, int xmin, int ymin, int xmax, int ymax,draw_prologue
1072,33773
+draw_epilogue(action_struct * cur, texture_info * tex, bool primary)draw_epilogue
1089,34284
+prepare_color_control(action_struct * cur)prepare_color_control
1119,34991
+exec_color_control_proc(action_struct * cur, texture_info * tex, int x, int y)exec_color_control_proc
1135,35475
+prepare_fill_texture(action_struct * payload)prepare_fill_texture
1179,37313
+set_pixel_color_with_style(action_struct * payload, texture_info * tex, int x, int y)set_pixel_color_with_style
1195,37707
+
+actions.h,45
+#define GUARD_ACTIONS_HGUARD_ACTIONS_H
2,24
+
+bindings.c,2070
+sync sync_mode = eager_sync;sync_mode
31,585
+process_x_y_pairs(VALUE image, int num_pairs, VALUE * argv, ...)process_x_y_pairs
34,627
+M_create_macro(VALUE self, VALUE method_name) M_create_macro
78,1755
+M_remove_macro(VALUE self, VALUE method_name) M_remove_macro
96,2138
+M_refresh_cache_all(VALUE self) M_refresh_cache_all
107,2385
+M_create_blank(VALUE self, VALUE window, VALUE width, VALUE height)M_create_blank
116,2500
+rb_lazy_bounds_to_image_bounds(VALUE image, image_bounds * bounds)rb_lazy_bounds_to_image_bounds
128,2767
+parse_sync_mode(VALUE user_sync_mode)parse_sync_mode
143,3223
+m_paint(int argc, VALUE * argv, VALUE self) m_paint
166,3853
+m_force_sync(VALUE self, VALUE ary)m_force_sync
239,5754
+m_dup_image(VALUE self)m_dup_image
261,6219
+m_clone_image(VALUE self)m_clone_image
290,7033
+m_user_set_options(VALUE self, VALUE options)m_user_set_options
305,7329
+m_user_delete_options(VALUE self)m_user_delete_options
318,7587
+m_get_options(VALUE self)m_get_options
329,7723
+m_getpixel(int argc, VALUE * argv, VALUE self) m_getpixel
338,7882
+m_circle(int argc, VALUE * argv, VALUE self) m_circle
363,8384
+m_ngon(int argc, VALUE * argv, VALUE self)m_ngon
392,8958
+m_flood_fill(int argc, VALUE * argv, VALUE self)m_flood_fill
420,9519
+m_line(int argc, VALUE * argv, VALUE self) m_line
463,10488
+m_rect(int argc, VALUE * argv, VALUE self) m_rect
487,10973
+m_pixel(int argc, VALUE * argv, VALUE self) m_pixel
513,11463
+m_bezier(int argc, VALUE * argv, VALUE self)m_bezier
537,11925
+m_polyline(int argc, VALUE * argv, VALUE self)m_polyline
563,12455
+m_splice(int argc, VALUE * argv, VALUE self) m_splice
591,12982
+m_clear(int argc, VALUE * argv, VALUE self) m_clear
638,14314
+m_offset(int argc, VALUE * argv, VALUE self) m_offset
654,14599
+m_color(int argc, VALUE * argv, VALUE self) m_color
688,15349
+m_missing(int argc, VALUE * argv, VALUE self) m_missing
718,16182
+m_cache_refresh(VALUE self) m_cache_refresh
736,16672
+m_quad_cached(VALUE self) m_quad_cached
751,16895
+m_each(int argc, VALUE * argv, VALUE self)m_each
777,17450
+
+bindings.h,47
+#define GUARD_BINDINGS_HGUARD_BINDINGS_H
2,25
+
+cache.c,338
+static cache_t cache = {0}; cache
16,219
+cache_create_entry(int tname) {cache_create_entry
20,293
+find_in_cache(int tname) {find_in_cache
59,1556
+find_or_create_cache_entry(int tname) {find_or_create_cache_entry
73,1908
+cache_refresh_all(void) {cache_refresh_all
84,2130
+cache_refresh_entry(int tname) {cache_refresh_entry
109,2794
+
+cache.h,350
+#define GUARD_CACHE_HGUARD_CACHE_H
5,71
+#define CACHE_SIZE CACHE_SIZE
8,108
+    int tname;tname
12,167
+    int sidelength;sidelength
13,182
+    float * tdata;tdata
14,202
+} cache_entry;cache_entry
15,221
+    int len;len
18,254
+    cache_entry entry[CACHE_SIZE];                                          entry
19,267
+} cache_t;cache_t
20,344
+
+compat.h,241
+#define GUARD_COMPAT_HGUARD_COMPAT_H
4,102
+# define RUBY_19RUBY_19
10,218
+# define RCLASS_M_TBL(RCLASS_M_TBL
15,309
+# define RCLASS_SUPER(RCLASS_SUPER
16,353
+# define RCLASS_IV_TBL(RCLASS_IV_TBL
17,397
+#define KLASS_OF(KLASS_OF
21,534
+
+gen_eval.c,444
+retrieve_hidden_self(VALUE duped_context)retrieve_hidden_self
11,247
+set_hidden_self(VALUE duped_context, VALUE hidden_self)set_hidden_self
25,652
+rb_capture(VALUE self) {rb_capture
38,1103
+redirect_iv_for_object(VALUE obj, VALUE dest)redirect_iv_for_object
59,1553
+release_iv_for_object(VALUE obj)release_iv_for_object
79,2305
+rb_gen_eval(int argc, VALUE * argv, VALUE self) {rb_gen_eval
93,2658
+Init_gen_eval() {Init_gen_eval
185,5307
+
+gen_eval.h,87
+#define GUARD_GEN_EVAL_HGUARD_GEN_EVAL_H
4,43
+#define ADJUST_SELF(ADJUST_SELF
14,345
+
+object2module.c,410
+class_alloc(VALUE flags, VALUE klass)class_alloc
18,359
+j_class_new(VALUE module, VALUE sup)j_class_new
34,752
+rb_to_module(VALUE self)rb_to_module
81,1735
+rb_reset_tbls(VALUE self)rb_reset_tbls
115,2493
+rb_gen_extend(int argc, VALUE * argv, VALUE self)rb_gen_extend
124,2738
+rb_gen_include(int argc, VALUE * argv, VALUE self)rb_gen_include
145,3259
+void Init_object2module()Init_object2module
163,3696
+
+object2module.h,57
+#define GUARD_OBJECT2MODULE_HGUARD_OBJECT2MODULE_H
4,53
+
+texplay.c,410
+Init_ctexplay() {Init_ctexplay
29,843
+m_init_TPPoint(int argc, VALUE * argv, VALUE self)m_init_TPPoint
133,5456
+m_init_EmptyImageStub(int argc, VALUE * argv, VALUE self)m_init_EmptyImageStub
157,6066
+m_EmptyImageStub_columns(VALUE self)m_EmptyImageStub_columns
176,6583
+m_EmptyImageStub_rows(VALUE self)m_EmptyImageStub_rows
182,6672
+m_EmptyImageStub_to_blob(VALUE self)m_EmptyImageStub_to_blob
188,6758
+
+texplay.h,2622
+#define GUARD_TEXPLAY_HGUARD_TEXPLAY_H
8,201
+#define OOB_VAL OOB_VAL
13,260
+#define XMAX_OOB XMAX_OOB
14,281
+#define YMAX_OOB YMAX_OOB
15,306
+#define XMIN_OOB XMIN_OOB
16,331
+#define YMIN_OOB YMIN_OOB
17,357
+#define PI PI
19,384
+#define SWAP(SWAP
22,426
+#define ROUND(ROUND
23,485
+#define ARY_SIZE(ARY_SIZE
24,519
+#define SGN(SGN
25,562
+#define MAX(MAX
26,597
+#define MIN(MIN
27,638
+#define ABS(ABS
28,680
+typedef enum e_bool {e_bool
31,732
+    false, truefalse
32,754
+    false, truetrue
32,754
+} bool;bool
33,770
+typedef enum e_color {e_color
35,779
+    red, green, blue, alphared
36,802
+    red, green, blue, alphagreen
36,802
+    red, green, blue, alphablue
36,802
+    red, green, blue, alphaalpha
36,802
+} color_t;color_t
37,830
+typedef enum e_sync_mode {e_sync_mode
39,842
+    lazy_sync, eager_sync, no_synclazy_sync
40,869
+    lazy_sync, eager_sync, no_synceager_sync
40,869
+    lazy_sync, eager_sync, no_syncno_sync
40,869
+} sync;sync
41,904
+typedef struct s_rgba {s_rgba
44,927
+    float red, green, blue, alpha;red
45,951
+    float red, green, blue, alpha;green
45,951
+    float red, green, blue, alpha;blue
45,951
+    float red, green, blue, alpha;alpha
45,951
+} rgba;rgba
46,986
+    int width, height;    width
50,1036
+    int width, height;    height
50,1036
+    float top, left;    top
51,1063
+    float top, left;    left
51,1063
+    int tname;tname
52,1088
+    float * td_array;td_array
53,1103
+    int yincr, firstpixel;yincr
54,1125
+    int yincr, firstpixel;firstpixel
54,1125
+    int x_offset, y_offset;x_offset
55,1152
+    int x_offset, y_offset;y_offset
55,1152
+    VALUE image;image
56,1180
+} texture_info;texture_info
57,1197
+#define IMAGE_BOUNDS(IMAGE_BOUNDS
61,1239
+    int xmin;xmin
63,1303
+    int ymin;ymin
64,1317
+    int xmax;xmax
65,1331
+    int ymax;ymax
66,1345
+} image_bounds;image_bounds
67,1359
+typedef struct action_struct {action_struct
69,1376
+    int xmin, ymin, xmax, ymax;xmin
70,1407
+    int xmin, ymin, xmax, ymax;ymin
70,1407
+    int xmin, ymin, xmax, ymax;xmax
70,1407
+    int xmin, ymin, xmax, ymax;ymax
70,1407
+    rgba color;color
71,1439
+    sync sync_mode;sync_mode
72,1455
+    VALUE color_control_proc;color_control_proc
75,1504
+    bool has_color_control_proc;has_color_control_proc
76,1534
+    int color_control_arity;color_control_arity
77,1567
+    texture_info source_tex;source_tex
80,1620
+    bool has_source_texture;has_source_texture
81,1649
+    bool alpha_blend;alpha_blend
84,1701
+    texture_info * tex;tex
89,1880
+    VALUE hash_arg;hash_arg
91,1909
+} action_struct;action_struct
92,1929
+
+utils.c,4100
+static const rgba not_a_color_v = { -1.0, -1.0, -1.0, -1.0 };not_a_color_v
36,974
+lowercase(char * string) lowercase
40,1067
+sym2string(VALUE sym) sym2string
53,1228
+string2sym(char * string) string2sym
59,1298
+is_a_hash(VALUE try_hash)is_a_hash
65,1373
+is_an_array(VALUE try_array)is_an_array
71,1446
+bool is_a_num(VALUE try_num)is_a_num
76,1519
+get_from_hash(VALUE hash, char * sym) get_from_hash
82,1625
+set_hash_value(VALUE hash, char * sym, VALUE val)set_hash_value
91,1808
+delete_from_hash(VALUE hash, char * sym)delete_from_hash
101,2016
+hash_value_is(VALUE hash, char * sym, VALUE val)hash_value_is
111,2295
+has_optional_hash_arg(VALUE hash, char * sym) has_optional_hash_arg
122,2482
+set_array_value(VALUE array, int index, VALUE val)set_array_value
134,2710
+get_from_array(VALUE array, int index) get_from_array
144,2913
+init_image_local(VALUE image)init_image_local
154,3092
+set_image_local(VALUE image, int name, VALUE val)set_image_local
173,3553
+get_image_local(VALUE image, int name)get_image_local
183,3731
+convert_image_local_color_to_rgba(VALUE image)convert_image_local_color_to_rgba
252,5880
+save_rgba_to_image_local_color(VALUE image, rgba color)save_rgba_to_image_local_color
266,6319
+create_image(VALUE window, int width, int height)create_image
283,6877
+not_a_color(rgba color1) not_a_color
303,7451
+is_a_color(rgba color1)is_a_color
309,7516
+cmp_color(rgba color1, rgba color2) cmp_color
315,7583
+color_copy(float * source, float * dest) color_copy
323,7778
+zero_color(float * tex) zero_color
330,7908
+get_pixel_color_from_chunk(float * chunk, int width, int height, int x, int y)get_pixel_color_from_chunk
336,7982
+get_pixel_color(texture_info * tex, int x, int y) get_pixel_color
357,8429
+get_pixel_data(texture_info * tex, int x, int y) get_pixel_data
379,9024
+set_pixel_color(rgba * pixel_color, texture_info * tex, int x, int y) set_pixel_color
388,9204
+find_color_from_string(char * try_color) find_color_from_string
410,9769
+convert_rgba_to_rb_color(rgba * pix)convert_rgba_to_rb_color
471,12271
+convert_rb_color_to_rgba(VALUE cval)convert_rb_color_to_rgba
487,12747
+check_mask(VALUE mask) check_mask
530,13964
+check_image(VALUE image) check_image
548,14470
+is_gosu_image(VALUE try_image)is_gosu_image
555,14634
+#define outcode outcode
565,14808
+const int RIGHT = 8;  //1000RIGHT
566,14828
+const int TOP = 4;    //0100TOP
567,14857
+const int LEFT = 2;   //0010LEFT
568,14886
+const int BOTTOM = 1; //0001BOTTOM
569,14915
+ComputeOutCode (int x, int y, int xmin, int ymin, int xmax, int ymax)ComputeOutCode
574,15083
+cohen_sutherland_clip (int * x0, int * y0,int * x1, int * y1, int xmin, int ymin,cohen_sutherland_clip
592,15643
+constrain_boundaries(int * x0, int * y0, int * x1, int * y1, int width, int height) constrain_boundaries
669,18664
+bound_by_rect_and_inner(int x, int y, int x0, int y0, int x1, int y1, int inner) bound_by_rect_and_inner
692,19249
+bound_by_rect(int x, int y, int x0, int y0, int x1, int y1) bound_by_rect
701,19577
+calc_pixel_offset_for_action(action_struct * cur, texture_info * tex, int x, int y) calc_pixel_offset_for_action
708,19783
+calc_pixel_offset(texture_info * tex, int x, int y) calc_pixel_offset
717,20019
+max_quad_size(void)max_quad_size
726,20217
+check_for_texture_info(VALUE image) check_for_texture_info
751,20843
+allocate_texture(int width, int height)allocate_texture
772,21587
+sync_to_gl(int tex_name, int x_offset, int y_offset, int width, int height, void * sub)sync_to_gl
787,21894
+create_subtexture_and_sync_to_gl(image_bounds * img_bounds, texture_info * tex)create_subtexture_and_sync_to_gl
799,22251
+get_image_chunk(texture_info * tex, int xmin, int ymin, int xmax, int ymax)get_image_chunk
823,23096
+get_texture_info(VALUE image, texture_info * tex) get_texture_info
852,23802
+is_a_point(VALUE try_point)is_a_point
897,25165
+point_x(VALUE point)point_x
907,25380
+point_y(VALUE point)point_y
913,25461
+power(float base, int exp)power
920,25598
+fact(int n)fact
940,25926
+comb(int n, int k)comb
948,26031
+bernstein(int n, int k, float u)bernstein
955,26132
+
+utils.h,201
+#define GUARD_UTILS_HGUARD_UTILS_H
2,22
+#define DRAW_OFFSET DRAW_OFFSET
6,102
+#define LAZY_BOUNDS LAZY_BOUNDS
7,124
+#define IMAGE_COLOR IMAGE_COLOR
8,146
+#define USER_DEFAULTS USER_DEFAULTS
9,168

data/src/actions.c

@@ -0,0 +1,1306 @@
+#include "texplay.h"
+#include "utils.h"
+#include "actions.h"
+#include <assert.h>
+#include <math.h>
+#ifdef __APPLE__
+# include <glut.h>
+#else
+# include <GL/glut.h>
+#endif
+
+
+/* small helper functions */
+static void process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode, bool primary);
+static void update_bounds(action_struct * cur, int xmin, int ymin, int xmax, int ymax);
+static void update_lazy_bounds(action_struct * cur, texture_info * tex);
+static void set_local_bounds(action_struct * cur, int xmin, int ymin, int xmax, int ymax, texture_info * tex);
+
+static void draw_prologue(action_struct * cur, texture_info * tex,
+                          int xmin, int ymin, int xmax, int ymax, VALUE * hash_arg, sync sync_mode,
+                          bool primary, action_struct ** payload_ptr);
+static void draw_epilogue(action_struct * cur, texture_info * tex, bool primary);
+
+static void prepare_fill_texture(action_struct * cur);
+static void prepare_color_control(action_struct * cur);
+static rgba exec_color_control_proc(action_struct * cur, texture_info * tex, int x, int y);
+static void set_pixel_color_with_style(action_struct * payload, texture_info * tex,
+                                       int x, int y);
+/* end helpers */
+
+
+/** line_do_action, bresenham's algorithm **/
+void
+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)
+{
+    int x, y, W, H, F;
+    int xinc, yinc;
+    action_struct cur;
+    int thickness = 1;
+
+    draw_prologue(&cur, tex, x1, y1,
+                  x2, y2, &hash_arg, sync_mode, primary, &payload);
+
+    if(has_optional_hash_arg(hash_arg, "thickness")) 
+        thickness = NUM2INT(get_from_hash(hash_arg, "thickness"));
+
+    /* clip the line */
+    cohen_sutherland_clip(&x1, &y1, &x2, &y2, 0, 0, tex->width - 1, tex->height - 1);
+    
+    W = ABS(x2 - x1);
+    H = ABS(y2 - y1);
+    	
+    if(x1 < x2)
+        xinc = 1;
+    else
+        xinc = -1;
+		
+    if(y1 < y2)
+        yinc = 1;
+    else
+        yinc = -1;
+		
+    x = x1;
+    y = y1;
+	
+    if(W >= H) {
+        F = 2 * H - W;
+        while(x != x2) {
+            if(F < 0)
+                F += 2 * H;
+            else {
+                F += 2 * (H - W);
+                y += yinc;
+            }
+            x += xinc;
+
+            if(thickness <= 1) {
+                set_pixel_color_with_style(payload, tex, x, y);
+            }
+            else {
+                set_hash_value(hash_arg, "fill", Qtrue);
+                circle_do_action(x, y, thickness / 2, tex, hash_arg, no_sync, false, payload);
+            }
+        }
+    }
+    else {
+        F = 2 * W - H;
+        while(y != y2 ) {
+            if(F < 0)
+                F += 2 * W;
+            else {
+                F += 2 * (W - H);
+                x += xinc;
+            }
+            y += yinc;
+
+            if(thickness <= 1) {
+                set_pixel_color_with_style(payload, tex, x, y);
+            }
+            else {
+                set_hash_value(hash_arg, "fill", Qtrue);
+                circle_do_action(x, y, thickness / 2, tex, hash_arg, no_sync, false, payload);
+            }
+            
+        }
+    }
+			
+    draw_epilogue(&cur, tex, primary);
+}
+/** end line **/
+
+/** polyline algorithm **/
+
+/* used by both polyline and bezier */
+#define SIMPLE_FORMAT 0
+#define POINT_FORMAT 1
+
+/* calculate a single point */
+static void
+polyline_point(VALUE points, int k, int * x, int * y, int format, int draw_offset_x,
+               int draw_offset_y)
+{
+    int xy_index;
+    
+    switch(format) {
+    case POINT_FORMAT:
+        *x = NUM2INT(point_x(get_from_array(points, k))) + draw_offset_x;
+        *y = NUM2INT(point_y(get_from_array(points, k))) + draw_offset_y;
+        break;
+        
+    case SIMPLE_FORMAT:
+        xy_index = k * 2;
+        *x = NUM2INT(get_from_array(points, xy_index)) + draw_offset_x;
+        *y = NUM2INT(get_from_array(points, xy_index + 1)) + draw_offset_y;
+
+        break;
+    default:
+        rb_raise(rb_eArgError, "pixel format must be either POINT_FORMAT or SIMPLE_FORMAT");
+    }
+}
+        
+void
+polyline_do_action(VALUE points, texture_info * tex, VALUE hash_arg,
+                   sync sync_mode, bool primary, action_struct * payload)
+{
+    action_struct cur;
+    int x1, y1, x2, y2;
+    int format;
+    int num_point_pairs;
+    int k;
+    VALUE offset_val;
+    int draw_offset_x;
+    int draw_offset_y;
+    bool closed = false;
+    
+    draw_prologue(&cur, tex, XMAX_OOB, YMAX_OOB, XMIN_OOB, YMIN_OOB, &hash_arg, sync_mode, primary, &payload);
+
+    /* calculate offset */
+    offset_val = get_image_local(tex->image, DRAW_OFFSET);
+
+    draw_offset_x = NUM2INT(get_from_array(offset_val, 0));
+    draw_offset_y = NUM2INT(get_from_array(offset_val, 1));
+
+    /* if the polyline is 'closed' make the last point the first */
+    if(is_a_hash(hash_arg))
+        if(RTEST(get_from_hash(hash_arg, "closed")) || RTEST(get_from_hash(hash_arg, "close"))) {
+            
+            /* so that our additional point is not persistent */
+            points = rb_obj_dup(points);
+            closed = true;
+        }
+    /* determine format of points */
+    if(is_a_point(get_from_array(points, 0))) {
+        format = POINT_FORMAT;
+
+        /* if the polyline is closed to form a polygon then make the last point and first point identical */
+        if(closed)
+            rb_ary_push(points, get_from_array(points, 0));
+
+        num_point_pairs = RARRAY_LEN(points);
+    }
+    else {
+        format = SIMPLE_FORMAT;
+
+        /* ensure there is an 'x' for every 'y'  */
+        if(RARRAY_LEN(points) % 2)
+            rb_raise(rb_eArgError, "polyline needs an even number of points. got %d\n",
+                     (int)RARRAY_LEN(points));
+
+        if(closed) {
+            rb_ary_push(points, get_from_array(points, 0));
+            rb_ary_push(points, get_from_array(points, 1));
+        }
+
+        num_point_pairs = RARRAY_LEN(points) / 2;
+    }
+
+    /* calculate first point */
+    polyline_point(points, 0, &x1, &y1, format, draw_offset_x, draw_offset_y);
+    
+    /* calc the points and draw the polyline */
+    for(k = 1; k < num_point_pairs; k++) {
+
+        polyline_point(points, k, &x2, &y2, format, draw_offset_x, draw_offset_y);
+    
+        line_do_action(x1, y1, x2, y2, tex, hash_arg, no_sync, false, payload);
+
+        /* update drawing rectangle */
+        update_bounds(payload, x1, y1, x2, y2);
+        
+        x1 = x2; y1 = y2;
+    }
+    
+    draw_epilogue(&cur, tex, primary);
+}
+/** end polyline **/
+
+/* regular polygon algorithm */
+void
+ngon_do_action(int x, int y, int r, int num_sides, texture_info * tex, VALUE hash_arg,
+               sync sync_mode, bool primary, action_struct * payload)
+{
+    action_struct cur;
+    int x1, y1, x2, y2, x0, y0;
+    int n;
+    int thickness;
+
+    draw_prologue(&cur, tex, x - r, y - r,
+                  x + r, y + r, &hash_arg, sync_mode, primary, &payload);
+
+
+    if(is_a_hash(hash_arg))
+        if(RTEST(get_from_hash(hash_arg, "thickness"))) {
+            thickness = NUM2INT(get_from_hash(hash_arg, "thickness"));
+
+            /* TO DO: find a better way of doing this */
+            cur.xmin = x - r - thickness / 2;
+            cur.ymin = y - r - thickness / 2;
+            cur.xmax = x + r + thickness / 2;
+            cur.ymax = y + r + thickness / 2;
+        }
+
+    /* calculate first point */
+    x0 = x1 = x + r;
+    y0 = y1 = y;
+
+    for(n = 0; n < num_sides; n++) {
+        x2 = x + r * cos((2 * PI / num_sides) * n);
+        y2 = y + r * sin((2 * PI / num_sides) * n);
+
+        line_do_action(x1, y1, x2, y2, tex, hash_arg, no_sync, false, payload);
+
+        x1 = x2; y1 = y2;
+    }
+
+    line_do_action(x0, y0, x1, y1, tex, hash_arg, no_sync, false, payload);
+
+    draw_epilogue(&cur, tex, primary);
+}
+/** end of ngon */    
+
+/** rectangle algorithm **/
+void
+rect_do_action(int x1, int y1, int x2, int y2, texture_info * tex, VALUE hash_arg,
+               sync sync_mode, bool primary, action_struct * payload)
+{
+    action_struct cur;
+    bool fill = false;
+    int thickness = 1;
+
+    draw_prologue(&cur, tex, x1, y1,
+                  x2, y2, &hash_arg, sync_mode, primary, &payload);
+
+    
+    if(is_a_hash(hash_arg)) {
+
+        /* make our private copy of the hash so we can mess with it */
+        hash_arg = rb_obj_dup(hash_arg);
+
+        if(RTEST(get_from_hash(hash_arg, "fill")) || RTEST(get_from_hash(hash_arg, "filled"))) {
+            fill = true;
+
+            /* since we're filling the rect, line thickness is irrelevant */
+            delete_from_hash(hash_arg, "thickness");
+        }
+        else if(RTEST(get_from_hash(hash_arg, "thickness"))) {
+            thickness = NUM2INT(get_from_hash(hash_arg, "thickness"));
+            /* TO DO: find a better way of doing this */
+
+            if(thickness > 1) {
+                cur.xmin = x1 - thickness / 2;
+                cur.ymin = y1 - thickness / 2;
+                cur.xmax = x2 + thickness / 2 + 1;
+                cur.ymax = y2 + thickness / 2 + 1;
+            }
+        }
+    }
+    if(!fill) {
+        line_do_action(x1, y1, x2, y1, tex, hash_arg, no_sync, false, payload);
+        line_do_action(x1, y1, x1, y2, tex, hash_arg, no_sync, false, payload);
+        line_do_action(x1, y2, x2, y2, tex, hash_arg, no_sync, false, payload);
+        line_do_action(x2, y1, x2, y2, tex, hash_arg, no_sync, false, payload);
+    }
+    else {
+        int y;
+        if(y1 > y2) SWAP(y1, y2);
+
+        for(y = y1; y < y2; y++)
+            line_do_action(x1, y, x2, y, tex, hash_arg, no_sync, false, payload);
+    }
+
+    draw_epilogue(&cur, tex, primary);
+}
+
+
+/** midpoint circle algorithm **/
+void
+circle_do_action(int x1, int y1, int r, texture_info * tex, VALUE hash_arg,
+                 sync sync_mode, bool primary, action_struct * payload)
+{
+
+    int x, y;
+    float p;
+    action_struct cur;
+    bool fill = false;
+
+    draw_prologue(&cur, tex, x1 - r, y1 - r, x1 + r, y1 + r, &hash_arg,
+                  sync_mode, primary, &payload);
+
+
+    if(is_a_hash(hash_arg)) {
+
+        /* make our private copy of the hash so we can mess with it */
+        hash_arg = rb_obj_dup(hash_arg);
+
+        if(RTEST(get_from_hash(hash_arg, "fill")) || RTEST(get_from_hash(hash_arg, "filled"))) {
+            fill = true;
+
+            /* to prevent infinite recursion set line thickness to 1 :D
+               NB: a filled circle uses lines and a thick line uses filled circles :D */
+            delete_from_hash(hash_arg, "thickness");
+        }
+    }
+    
+    x = 0 ; y = r;
+    p = 5 / 4 - r;
+    if(!fill) {
+        while (x <= y) {
+            set_pixel_color_with_style(payload, tex, x1 + x, y1 + y);
+            set_pixel_color_with_style(payload, tex, x1 + x, y1 - y);
+            set_pixel_color_with_style(payload, tex, x1 - x, y1 + y);
+            set_pixel_color_with_style(payload, tex, x1 - x, y1 - y);
+            set_pixel_color_with_style(payload, tex, x1 + y, y1 + x);
+            set_pixel_color_with_style(payload, tex, x1 + y, y1 - x);
+            set_pixel_color_with_style(payload, tex, x1 - y, y1 + x);
+            set_pixel_color_with_style(payload, tex, x1 - y, y1 - x);
+
+            if (p < 0) {
+                p += 2 * x + 3;
+            }
+            else {
+                y--;
+                p += 2 * (x - y) + 5;
+            }
+            x++;
+        }
+    }
+    else {
+        while (x <= y) {
+            line_do_action(x1 - x, y1 + y, x1 + x, y1 + y, tex, hash_arg, no_sync, false, payload);
+            line_do_action(x1 - x, y1 - y, x1 + x, y1 - y, tex, hash_arg, no_sync, false, payload);
+            line_do_action(x1 - y, y1 + x, x1 + y, y1 + x, tex, hash_arg, no_sync, false, payload);
+            line_do_action(x1 - y, y1 - x, x1 + y, y1 - x, tex, hash_arg, no_sync, false, payload);
+
+            if (p < 0) {
+                p += 2 * x + 3;
+            }
+            else {
+                y--;
+                p += 2 * (x - y) + 5;
+            }
+            x++;
+        }
+    }
+
+    draw_epilogue(&cur, tex, primary);
+}
+/** end circle **/
+
+/** set pixel  algorithm **/
+void
+pixel_do_action(int x1, int y1, texture_info * tex, VALUE hash_arg,
+                sync sync_mode, bool primary, action_struct * payload)
+{
+    action_struct cur;
+
+    draw_prologue(&cur, tex, x1, y1, x1, y1, &hash_arg, sync_mode, primary, &payload);
+
+    set_pixel_color_with_style(payload, tex, x1, y1);
+
+    draw_epilogue(&cur, tex, primary);
+}
+/** end set pixel **/
+
+/*** non recursive FLOOD FILL, inspired by John R. Shaw ***/
+typedef struct { int x1, x2, y, dy; } LINESEGMENT;
+
+#define MAXDEPTH 10000
+
+#define PUSH(XL, XR, Y, DY)                                             \
+    if( sp < stack+MAXDEPTH && Y+(DY) >= nMinX && Y+(DY) <= nMaxY )     \
+        { sp->x1 = XL; sp->x2 = XR; sp->y = Y; sp->dy = DY; ++sp; }
+
+#define POP(XL, XR, Y, DY)                                              \
+    { --sp; XL = sp->x1; XR = sp->x2; Y = sp->y+(DY = sp->dy); }
+
+void
+flood_fill_do_action(int x, int y, texture_info * tex, VALUE hash_arg,
+                     sync sync_mode, bool primary, action_struct * payload)
+{
+    int left, x1, x2, dy;
+    rgba old_color;
+    LINESEGMENT stack[MAXDEPTH], *sp = stack;
+
+    action_struct cur;
+
+    int nMinX, nMinY, nMaxX, nMaxY;
+    
+    /* NOTE: 1024 is just a place-holder to indicate maximum possible width/height.
+       Values will be constrained to realistic dimensions by constrain_boundaries() function */
+    draw_prologue(&cur, tex, 0, 0, 1024, 1024, &hash_arg, sync_mode, primary, &payload);
+
+    /* fill hates alpha_blend so let's turn it off */
+    payload->pen.alpha_blend = false;
+
+    nMinX = cur.xmin; nMinY = cur.ymin;
+    nMaxX = cur.xmax; nMaxY = cur.ymax;
+
+    old_color = get_pixel_color(tex, x, y);
+    if( cmp_color(old_color, cur.color) )
+        return;
+
+    if( x < nMinX || x > nMaxX || y < nMinX || y > nMaxY )
+        return;
+
+    PUSH(x, x, y, 1);        /* needed in some cases */
+    PUSH(x, x, y + 1, -1);    /* seed segment (popped 1st) */
+
+    while( sp > stack ) {
+        POP(x1, x2, y, dy);
+
+        for( x = x1; x >= nMinX && cmp_color(get_pixel_color(tex, x, y), old_color); --x ) {
+            set_pixel_color_with_style(payload, tex, x, y);
+        }
+
+        if( x >= x1 )
+            goto SKIP;
+
+        left = x + 1;
+        if( left < x1 )
+            PUSH(y, left, x1 - 1, -dy);    /* leak on left? */
+
+        x = x1 + 1;
+
+        do {
+            for( ; x <= nMaxX && cmp_color(get_pixel_color(tex, x, y), old_color); ++x ){
+                set_pixel_color_with_style(payload, tex, x, y);
+            }
+
+            PUSH(left, x - 1, y, dy);
+
+            if( x > x2 + 1 )
+                PUSH(x2 + 1, x - 1, y, -dy);    /* leak on right? */
+
+        SKIP:        for( ++x; x <= x2 && !cmp_color(get_pixel_color(tex, x, y), old_color); ++x ) {;}
+
+            left = x;
+        } while( x <= x2 );
+    }
+
+    draw_epilogue(&cur, tex, primary);
+}
+/*** END FLOOD FILL ***/
+
+/** glow fill algorithm, from the gosu forums **/ 
+static void
+glow_floodFill( int x, int y, rgba * seed_color, action_struct * cur, texture_info * tex, texture_info * tex2 )
+{
+    /* used to flood in both horizontal directions from the given point to form a line. */
+    int fillL, fillR;     
+    int i;
+
+    /* initialize the flood directions */
+    fillL = fillR = x;
+
+    /* flood left until a new color is hit - or the edge of the image */
+    do {
+        /* for texture filling */
+        if(tex2)
+            cur->color = get_pixel_color(tex2, fillL % tex2->width, y % tex2->height);
+        
+        /* TWO VERSIONS of below */
+
+        /* SLOW BUT MODERN VERSION */
+        /*        set_pixel_color_with_style(cur, tex, fillL, y); */
+
+        /* FAST but old version */
+        set_pixel_color(&cur->color, tex, fillL, y);
+
+        fillL--;
+    } while( (fillL >= 0 ) && (cmp_color(get_pixel_color(tex, fillL, y), *seed_color)) );
+
+    /* flood right until a new color is hit - or the edge of the image */
+    do {
+        //        for texture filling
+        if(tex2)
+            cur->color = get_pixel_color(tex2, fillR % tex2->width, y % tex2->height);
+        
+        /*        set_pixel_color_with_style(cur, tex, fillR, y); */
+         
+        set_pixel_color(&cur->color, tex, fillR, y);
+
+        fillR++;
+    } while( (fillR < cur->xmax - 1) && (cmp_color(get_pixel_color(tex, fillR, y), *seed_color)) );
+
+    /* recurse to the line above and the line below at each point */
+    for( i = fillL + 1; i < fillR; i++ ) {
+        /* Flood above */
+        if( ( y > 0 ) && ( cmp_color(get_pixel_color(tex, i, y - 1), *seed_color)  ) ) {
+            
+            glow_floodFill( i, y-1, seed_color, cur, tex, tex2 );
+        }
+        /* flood below */
+        if( (y < cur->ymax - 1) && (cmp_color(get_pixel_color(tex, i, y + 1), *seed_color) )) {
+            glow_floodFill( i, y+1, seed_color, cur, tex, tex2 );
+        }
+    }
+}
+
+void
+glow_fill_do_action(int x, int y, texture_info * tex, VALUE hash_arg,
+                    sync sync_mode, bool primary, action_struct * payload)
+{
+    action_struct cur;
+    rgba seed_color;
+    texture_info fill_image;
+    texture_info * fill_image_ptr = NULL;
+    
+    if(!bound_by_rect(x, y, 0, 0, tex->width, tex->height)) return;
+
+    draw_prologue(&cur, tex, 0, 0, 1024, 1024, &hash_arg, sync_mode, primary, &payload);
+
+    /* fill hates alpha_blend so let's turn it off */
+    payload->pen.alpha_blend = false;
+
+    if(is_a_hash(hash_arg)) {
+        VALUE try_image = get_from_hash(hash_arg, "texture");
+        if(is_gosu_image(try_image)) {
+            get_texture_info(try_image, &fill_image);
+            fill_image_ptr = &fill_image;
+        }
+    }
+
+    seed_color = get_pixel_color(tex, x, y);
+
+    /* last argument is pointer to texture fill data (if it exists) or NULL (if it doesn't) */
+    glow_floodFill( x, y, &seed_color, &cur, tex, fill_image_ptr );
+
+    draw_epilogue(&cur, tex, primary);
+}
+/** end of glow fill **/
+
+/** scanfill algorithm **/
+/* the stack */
+#define stackSize 16777218
+int stack[stackSize];
+int stackPointer;
+
+static bool
+pop(int * x, int * y, int h) 
+{ 
+    if(stackPointer > 0) 
+        { 
+            int p = stack[stackPointer]; 
+            *x = p / h; 
+            *y = p % h; 
+            stackPointer--; 
+            return true; 
+        }     
+    else 
+        { 
+            return false;
+        }    
+}    
+
+static bool
+push(int x, int y, int h) 
+{ 
+    if(stackPointer < stackSize - 1) 
+        { 
+            stackPointer++; 
+            stack[stackPointer] = h * x + y; 
+            return true;
+        }     
+    else 
+        { 
+            return false;
+        }    
+}     
+
+static void
+emptyStack() 
+{ 
+    int x, y; 
+    while(pop(&x, &y, 0)); 
+}
+
+void
+scan_fill_do_action(int x, int y, texture_info * tex, VALUE hash_arg,
+                    sync sync_mode, bool primary, action_struct * payload)
+{
+    action_struct cur;
+    rgba old_color;
+    int y1;
+    bool spanLeft, spanRight;
+
+    if(!bound_by_rect(x, y, 0, 0, tex->width - 1, tex->height - 1)) return;
+
+    /* NB: using XMAX_OOB etc since we dont know the drawing area yet; drawing area will be set by
+       update_bounds() function in main loop */
+    draw_prologue(&cur, tex, XMAX_OOB, YMAX_OOB, XMIN_OOB, YMIN_OOB, &hash_arg, sync_mode, primary, &payload);
+
+    /* fill hates alpha_blend so let's turn it off */
+    payload->pen.alpha_blend = false;
+    
+    old_color = get_pixel_color(tex, x, y);
+
+    if(cmp_color(old_color, cur.color)) return;
+    
+    emptyStack();
+    
+    if(!push(x, y, tex->width - 1)) return;
+    
+    while(pop(&x, &y, tex->width - 1))
+        {    
+            y1 = y;
+            while(y1 >= 0 && cmp_color(old_color, get_pixel_color(tex, x, y1))) y1--;
+            y1++;
+            spanLeft = spanRight = false;
+            while(y1 < tex->height && cmp_color(old_color, get_pixel_color(tex, x, y1)) )
+                {
+                    set_pixel_color_with_style(payload, tex, x, y1);
+
+                    /* update the drawing rectangle */
+                    update_bounds(payload, x, y1, x, y1);
+
+                    if(!spanLeft && x > 1 && cmp_color(old_color, get_pixel_color(tex, x - 1, y1))) 
+                        {
+                            if(!push(x - 1, y1, tex->width - 1)) return;
+                            spanLeft = true;
+                        }
+
+                    else if(spanLeft && !cmp_color(old_color, get_pixel_color(tex, x - 1, y1)))
+                        {
+                            spanLeft = false;
+                        }
+
+                    if(!spanRight && x < tex->width - 1 && cmp_color(old_color,
+                                                                     get_pixel_color(tex, x + 1, y1))) 
+                        {
+                            if(!push(x + 1, y1, tex->width - 1)) return;
+                            spanRight = true;
+                        }
+
+                    else if(spanRight && x < tex->width - 1 && !cmp_color(old_color,get_pixel_color(tex, x + 1, y1)))
+                        {
+                            spanRight = false;
+                        } 
+                    y1++;
+                }
+        }
+    draw_epilogue(&cur, tex, primary);
+}
+/** end of scanfill **/
+
+/** bezier curve algorithm **/
+static void
+bezier_point(VALUE points, float u, float * x, float * y, int n, int format,
+             int draw_offset_x, int draw_offset_y)
+{
+    int k;
+    int xy_index;
+    double sumx = 0, sumy = 0;
+ 
+
+    for(k = 0; k < n; k++) {
+        switch(format) {
+        case POINT_FORMAT:
+            
+            sumx += NUM2DBL(point_x(get_from_array(points, k))) * bernstein(n - 1, k, u);
+            sumy += NUM2DBL(point_y(get_from_array(points, k))) * bernstein(n - 1, k, u);
+            break;
+        case SIMPLE_FORMAT:
+             
+            xy_index = k * 2;
+            sumx +=  NUM2DBL(get_from_array(points, xy_index)) * bernstein(n - 1, k, u);
+            sumy +=  NUM2DBL(get_from_array(points, xy_index + 1)) * bernstein(n - 1, k, u);
+            break;
+        default:
+            rb_raise(rb_eArgError, "pixel format must be either POINT_FORMAT or SIMPLE_FORMAT");
+        }
+    }
+
+    *x = sumx + draw_offset_x;
+    *y = sumy + draw_offset_y;
+}
+
+void
+bezier_do_action(VALUE points, texture_info * tex, VALUE hash_arg, sync sync_mode,
+                 bool primary, action_struct * payload)
+{
+    float u = 0.0;
+    action_struct cur;
+    float x1, y1, x2, y2;
+    int first_x, first_y;
+    int format;
+    int num_point_pairs;
+    bool closed = false;
+    VALUE offset_val;
+    int draw_offset_x, draw_offset_y;
+
+    /* defaults to 200 (1 / 0.005) samples per curve */
+    float step_size = 0.005;
+    
+    draw_prologue(&cur, tex, XMAX_OOB, YMAX_OOB, XMIN_OOB, YMIN_OOB, &hash_arg, sync_mode, primary, &payload);
+
+    /* calculate offset */
+    offset_val = get_image_local(tex->image, DRAW_OFFSET);
+
+    draw_offset_x = NUM2INT(get_from_array(offset_val, 0));
+    draw_offset_y = NUM2INT(get_from_array(offset_val, 1));
+
+    if(is_a_hash(hash_arg)) {
+
+        /* if the polyline is 'closed' make the last point the first */
+        if(RTEST(get_from_hash(hash_arg, "closed")) || RTEST(get_from_hash(hash_arg, "close"))) {
+
+            /* so that our additional point is not persistent */
+            points = rb_obj_dup(points);
+            closed = true;
+        }
+        
+        /* number of points to sample */
+        if(RTEST(get_from_hash(hash_arg, "sample_size"))) {
+            VALUE c = get_from_hash(hash_arg, "sample_size");
+            Check_Type(c, T_FIXNUM);
+            step_size = 1.0 / (float)FIX2INT(c);
+        }
+    }
+
+    if(is_a_point(get_from_array(points, 0))) {
+        format = POINT_FORMAT;
+
+        if(closed)
+            rb_ary_push(points, get_from_array(points, 0));
+        
+        num_point_pairs = RARRAY_LEN(points);
+    }
+    else {
+        format = SIMPLE_FORMAT;
+
+        /* ensure points are given in pairs */
+        if(RARRAY_LEN(points) % 2)
+            rb_raise(rb_eArgError, "bezier needs an even number of points. got %d\n", (int)RARRAY_LEN(points));
+
+        if(closed) {
+            rb_ary_push(points, get_from_array(points, 0));
+            rb_ary_push(points, get_from_array(points, 1));
+        }
+        
+        num_point_pairs = RARRAY_LEN(points) / 2;
+    }
+
+    if(num_point_pairs > 13)
+        rb_raise(rb_eArgError, "too many points for bezier curve. 13 points is current maximum. got %d\n",
+                 num_point_pairs);
+
+    /* get the first point */
+    bezier_point(points, 0, &x1, &y1, num_point_pairs, format, draw_offset_x, draw_offset_y);
+
+    /* save it so we can link up with last point properly if the curve is 'closed' */
+    first_x = x1;
+    first_y = y1;
+
+    while(u <= 1) {
+        bezier_point(points, u, &x2, &y2, num_point_pairs, format, draw_offset_x, draw_offset_y);
+ 
+        line_do_action(x1, y1, x2, y2, tex, hash_arg, no_sync, false, payload);
+
+        /* update drawing rectangle */
+        update_bounds(payload, x1, y1, x2, y2);
+
+        x1 = x2;
+        y1 = y2;
+
+        u += step_size;
+    }
+
+    /* sometimes beziers dont close properly, so we'll ensure it's closed */
+    if(closed)
+        line_do_action(x2, y2, first_x, first_y, tex, hash_arg, no_sync, false, payload);
+
+    draw_epilogue(&cur, tex, primary);
+}
+/** end of bezier **/
+
+/** each_pixel  **/
+static void
+set_color_array(VALUE ary, rgba * color)
+{
+    set_array_value(ary, 0, rb_float_new(color->red));
+    set_array_value(ary, 1, rb_float_new(color->green));
+    set_array_value(ary, 2, rb_float_new(color->blue));
+    set_array_value(ary, 3, rb_float_new(color->alpha));
+}
+    
+void
+each_pixel_do_action(int x1, int y1, int x2, int y2, VALUE proc, texture_info * tex, VALUE hash_arg,
+                     sync sync_mode, bool primary, action_struct * payload)
+{
+    action_struct cur;
+    int x, y, arity;
+    VALUE rb_pix = rb_ary_new2(4);
+    
+    draw_prologue(&cur, tex, x1, y1, x2, y2, &hash_arg, sync_mode, primary, &payload);
+
+    arity = FIX2INT(rb_funcall(proc, rb_intern("arity"), 0));
+
+    for(y = y1; y < y2 + 1; y++)
+        for(x = x1; x < x2 + 1; x++) {
+            rgba pix = get_pixel_color(tex, x, y);
+
+            set_color_array(rb_pix, &pix);
+            
+            /* invoke the block */
+            switch(arity) {
+            case 1:
+                rb_funcall(proc, rb_intern("call"), 1, rb_pix);
+                break;
+            case 3:
+                rb_funcall(proc, rb_intern("call"), 3, rb_pix, INT2FIX(x), INT2FIX(y));
+                break;
+            default:
+                rb_raise(rb_eArgError, "permissible arities for each are 1 & 3. Got %d\n",
+                         arity);
+
+            }
+
+            pix = convert_rb_color_to_rgba(rb_pix);
+
+            set_pixel_color(&pix, tex, x, y);
+        }
+
+    draw_epilogue(&cur, tex, primary);
+}
+/** end each_pixel iterator **/
+
+/** splice algorithm **/
+void
+splice_do_action(int x0, int y0, int cx1, int cy1, int cx2, int cy2, texture_info * splice_tex,
+                 texture_info * tex, VALUE hash_arg, sync sync_mode,
+                 bool primary, action_struct * payload)
+{
+    action_struct cur;
+    int xbound;
+    int ybound;
+    rgba chromakey;
+    int x, y;
+    float * image_buf = NULL;
+    bool inverse_chroma = false;
+    bool has_chroma = false;
+    bool same_image = false;
+
+    constrain_boundaries(&cx1, &cy1, &cx2, &cy2, splice_tex->width, splice_tex->height);
+    xbound = cx2 - cx1 + 1;
+    ybound = cy2 - cy1 + 1;
+
+    draw_prologue(&cur, tex, x0, y0,
+                  x0 + xbound, y0 + ybound, &hash_arg, sync_mode, primary, &payload);
+
+
+    if(has_optional_hash_arg(hash_arg, "chroma_key")) {
+        VALUE c = get_from_hash(hash_arg, "chroma_key");
+        chromakey = convert_rb_color_to_rgba(c);
+        has_chroma = true;
+    }
+    else if(has_optional_hash_arg(hash_arg, "chroma_key_not")) {
+        chromakey = convert_rb_color_to_rgba(get_from_hash(hash_arg, "chroma_key_not"));
+        inverse_chroma = true;
+        has_chroma = true;
+    }
+
+    if(splice_tex->image == tex->image)
+        same_image = true;
+
+    /* NB: we do not use this in the general case since it's almost 1.5 times as slow.
+       It is necessary for splicing from/to the same region of pixels though.
+    */
+    if(same_image) 
+        image_buf = get_image_chunk(splice_tex, cx1, cy1, cx2, cy2);
+    
+    for(y = 0; y < ybound; y++)
+        for(x = 0; x < xbound; x++) {
+            
+            if(!same_image)
+                payload->color = get_pixel_color(splice_tex, cx1 + x, cy1 + y);
+            else 
+                payload->color = get_pixel_color_from_chunk(image_buf, xbound, ybound, x, y);
+                
+            if(has_chroma) {
+                bool cmp = cmp_color(payload->color, chromakey);
+                if(!cmp && !inverse_chroma)
+                    set_pixel_color_with_style(payload, tex, x0 + x, y0 + y);
+                else if(cmp && inverse_chroma)
+                    set_pixel_color_with_style(payload, tex, x0 + x, y0 + y);
+            }
+            else
+                set_pixel_color_with_style(payload, tex, x0 + x, y0 + y);
+        }
+
+    if(same_image)
+        free(image_buf);
+
+    draw_epilogue(&cur, tex, primary);
+}
+/** end splice **/
+
+static void
+initialize_action_struct(action_struct * cur, VALUE hash_arg, sync sync_mode)
+{
+    /* initialize action-struct to default values */
+    cur->sync_mode = sync_mode;
+    cur->hash_arg = hash_arg;
+
+    cur->color = convert_image_local_color_to_rgba(cur->tex->image);
+    cur->pen.has_color_control_proc = false;
+    cur->pen.has_color_control_transform = false;
+    cur->pen.has_source_texture = false;
+    cur->pen.alpha_blend = false;
+
+    /* set static color control transformations to defaults */
+    cur->pen.color_mult.red = 1.0;
+    cur->pen.color_mult.green = 1.0;
+    cur->pen.color_mult.blue = 1.0;
+    cur->pen.color_mult.alpha = 1.0;
+
+    cur->pen.color_add.red = 0.0;
+    cur->pen.color_add.green = 0.0;
+    cur->pen.color_add.blue = 0.0;
+    cur->pen.color_add.alpha = 0.0;
+}
+    
+/* TODO: fix this function below, it's too ugly and bulky and weird **/
+static void
+process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode, bool primary)
+{
+    
+    VALUE user_defaults;  
+    VALUE hash_blend;
+
+
+    /* if a hash doesn't exist then create one */
+    if(!is_a_hash(*hash_arg)) 
+        *hash_arg = rb_hash_new();
+
+    /* init the action to default values */
+    initialize_action_struct(cur, *hash_arg, sync_mode);
+
+    /* get the user default options & merge with given options */
+    user_defaults = get_image_local(cur->tex->image, USER_DEFAULTS);
+    hash_blend = rb_funcall(user_defaults, rb_intern("merge"), 1, *hash_arg);
+    rb_funcall(*hash_arg, rb_intern("merge!"), 1, hash_blend);
+
+    if(has_optional_hash_arg(*hash_arg, "color")) {
+        VALUE c = get_from_hash(*hash_arg, "color");
+        cur->color = convert_rb_color_to_rgba(c);
+        if(c == string2sym("random")) {
+            set_hash_value(*hash_arg, "color", convert_rgba_to_rb_color(&cur->color));
+        }
+    }
+
+    /* shadows */
+    if(RTEST(get_from_hash(*hash_arg, "shadow"))) {
+        cur->pen.color_mult.red = 0.66;
+        cur->pen.color_mult.green = 0.66;
+        cur->pen.color_mult.blue = 0.66;
+        cur->pen.color_mult.alpha = 1;
+
+        cur->pen.has_color_control_transform = true;
+    }
+    
+    /* sync mode */
+    if(has_optional_hash_arg(*hash_arg, "sync_mode")) {
+        VALUE user_sync_mode = get_from_hash(*hash_arg, "sync_mode");
+
+        Check_Type(user_sync_mode, T_SYMBOL);
+        
+        if(user_sync_mode == string2sym("lazy_sync"))
+            cur->sync_mode = lazy_sync;
+        else if(user_sync_mode == string2sym("eager_sync"))
+            cur->sync_mode = eager_sync;
+        else if(user_sync_mode == string2sym("no_sync"))
+            cur->sync_mode = no_sync;
+        else
+            rb_raise(rb_eArgError, "unrecognized sync mode: %s\n. Allowable modes are "
+                     ":lazy_sync, :eager_sync, :no_sync.",
+                     sym2string(user_sync_mode));
+
+        delete_from_hash(*hash_arg, "sync_mode");
+        
+    }
+
+    /* process the color_control block or transform (if there is one) */
+    prepare_color_control(cur);
+
+    /* process the filling texture (if there is one) */
+    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;
+
+}
+
+static void
+update_lazy_bounds(action_struct * cur, texture_info * tex)
+{
+    
+    /* only update global bounds if we're doing a lazy_sync */
+    if(cur->sync_mode == lazy_sync) {
+        int xmin, ymin, xmax, ymax;
+        VALUE lazy_bounds;
+
+        lazy_bounds = get_image_local(tex->image, LAZY_BOUNDS);
+
+        xmin = INT2FIX(MIN(cur->xmin, FIX2INT(get_from_array(lazy_bounds, 0))));
+        ymin = INT2FIX(MIN(cur->ymin, FIX2INT(get_from_array(lazy_bounds, 1))));
+        xmax = INT2FIX(MAX(cur->xmax, FIX2INT(get_from_array(lazy_bounds, 2))));
+        ymax = INT2FIX(MAX(cur->ymax, FIX2INT(get_from_array(lazy_bounds, 3))));
+
+        set_array_value(lazy_bounds, 0, xmin);
+        set_array_value(lazy_bounds, 1, ymin);
+        set_array_value(lazy_bounds, 2, xmax);
+        set_array_value(lazy_bounds, 3, ymax);
+    }
+}
+
+static void
+update_bounds(action_struct * cur, int xmin, int ymin, int xmax, int ymax)
+{
+    if(xmin > xmax) SWAP(xmin, xmax);
+    if(ymin > ymax) SWAP(ymin, ymax);
+    
+    cur->xmin = MIN(cur->xmin, xmin);
+    cur->ymin = MIN(cur->ymin, ymin);
+    cur->xmax = MAX(cur->xmax, xmax);
+    cur->ymax = MAX(cur->ymax, ymax);
+}
+
+static void
+set_local_bounds(action_struct * cur, int xmin, int ymin, int xmax, int ymax, texture_info * tex)
+{
+    if(cur->sync_mode == no_sync)
+        return;
+
+    /* local bounds used by both eager_sync and lazy_sync: */
+    
+    /* eager sync: to demarcate precise area to sync to opengl */
+    /* lazy sync: to update global bounds */
+    cur->xmin = xmin;
+    cur->ymin = ymin;
+    cur->xmax = xmax;
+    cur->ymax = ymax;
+}
+
+static void
+draw_prologue(action_struct * cur, texture_info * tex, int xmin, int ymin, int xmax, int ymax,
+              VALUE * hash_arg, sync sync_mode, bool primary, action_struct ** payload_ptr)
+{
+    if(!primary) return;
+
+    /* set the payload pointer */
+    *payload_ptr = cur;
+    
+    /* not too happy about having this here, look at texplay.h for why */
+    cur->tex = tex;
+    
+    process_common_hash_args(cur, hash_arg, sync_mode, primary);
+    
+    set_local_bounds(cur, xmin, ymin, xmax, ymax, tex);
+}
+
+void
+draw_epilogue(action_struct * cur, texture_info * tex, bool primary)
+{
+    /* only primary actions get sync'd */
+    if(!primary) return;
+    
+    switch(cur->sync_mode) {
+
+        /* do not sync */
+    case no_sync:
+        return;
+        break;
+
+        /* sync immediately */
+    case eager_sync:
+        create_subtexture_and_sync_to_gl(IMAGE_BOUNDS(cur), tex);
+        break;
+
+        /* sync later (at end of paint block?) */
+    case lazy_sync:
+        update_lazy_bounds(cur, tex);
+        break;
+        
+    default:
+        rb_raise(rb_eRuntimeError,
+                 "sync_mode may only be: lazy_sync, eager_sync, no_sync. got %d\n", cur->sync_mode);
+    }
+}
+
+/* set action color to return value of color_control proc */
+static void
+prepare_color_control(action_struct * cur)
+{
+
+    if(is_a_hash(cur->hash_arg)) {
+        VALUE try_val = get_from_hash(cur->hash_arg, "color_control");
+        
+        if(rb_respond_to(try_val, rb_intern("call"))) {
+            cur->pen.color_control_proc = try_val;
+            cur->pen.color_control_arity = FIX2INT(rb_funcall(try_val, rb_intern("arity"), 0));
+            cur->pen.has_color_control_proc = true;
+        }
+        else if(is_a_hash(try_val)) {
+            VALUE try_add = get_from_hash(try_val, "add");
+            VALUE try_mult = get_from_hash(try_val, "mult");
+
+            if(is_an_array(try_add)) {
+                if(RARRAY_LEN(try_add) < 4)
+                    rb_raise(rb_eArgError, ":color_control transform :add needs 4 parameters");
+                
+                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;
+            }
+            if(is_an_array(try_mult)) {
+                if(RARRAY_LEN(try_mult) < 4)
+                    rb_raise(rb_eArgError, ":color_control transform :mult needs 4 parameters");
+
+                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;
+            }
+                
+        }
+    }
+}
+
+static rgba 
+exec_color_control_proc(action_struct * cur, texture_info * tex, int x, int y)
+{
+    int arity = cur->pen.color_control_arity;
+    VALUE proc = cur->pen.color_control_proc;
+    rgba old_color = get_pixel_color(tex, x, y);
+    rgba current_color = cur->color;
+    rgba new_color;
+
+    if(!cur->pen.has_color_control_proc)
+        rb_raise(rb_eRuntimeError, "needs a proc");
+
+    switch(arity) {
+    case 1:
+        new_color = convert_rb_color_to_rgba(rb_funcall(proc, rb_intern("call"), arity,
+                                                        convert_rgba_to_rb_color(&old_color)));
+        break;
+            
+    case 2:
+        new_color = convert_rb_color_to_rgba(rb_funcall(proc, rb_intern("call"), arity,
+                                                        convert_rgba_to_rb_color(&old_color),
+                                                        convert_rgba_to_rb_color(&current_color)));
+        break;
+            
+    case 3:
+        new_color = convert_rb_color_to_rgba(rb_funcall(proc, rb_intern("call"), arity,
+                                                        convert_rgba_to_rb_color(&old_color),
+                                                        INT2FIX(x), INT2FIX(y)));
+        break;
+    case 4:
+        new_color = convert_rb_color_to_rgba(rb_funcall(proc, rb_intern("call"), arity,
+                                                        convert_rgba_to_rb_color(&old_color),
+                                                        convert_rgba_to_rb_color(&current_color),
+                                                        INT2FIX(x), INT2FIX(y)));
+        break;
+    default:
+        rb_raise(rb_eArgError, "permissible arities for color_control proc are 1, 2, 3  and 4. Got %d\n",
+                 arity);
+    }
+        
+    /* update the action color */
+    return new_color;
+}
+
+static void
+prepare_fill_texture(action_struct * payload)
+{
+    if(is_a_hash(payload->hash_arg)) {
+        VALUE try_image = get_from_hash(payload->hash_arg, "texture");
+        if(is_gosu_image(try_image)) {
+
+            get_texture_info(try_image, &payload->pen.source_tex);
+            payload->pen.has_source_texture = true;
+        }
+    }
+}
+
+static void
+apply_color_control_transform(action_struct * payload, texture_info * tex, int x, int y)
+{
+    payload->color = get_pixel_color(tex, x, y);
+        
+    payload->color.red += payload->pen.color_add.red; 
+    payload->color.green += payload->pen.color_add.green; 
+    payload->color.blue += payload->pen.color_add.blue; 
+    payload->color.alpha += payload->pen.color_add.alpha;
+
+    payload->color.red *= payload->pen.color_mult.red; 
+    payload->color.green *= payload->pen.color_mult.green; 
+    payload->color.blue *= payload->pen.color_mult.blue; 
+    payload->color.alpha *= payload->pen.color_mult.alpha;
+}
+
+static void
+set_pixel_color_with_style(action_struct * payload, texture_info * tex, int x, int y)
+{
+
+    rgba blended_pixel;
+
+    /* for color_control transform */
+    if(payload->pen.has_color_control_transform)
+        apply_color_control_transform(payload, tex, x, y);
+    
+    /*    for texture fill  */
+    if(payload->pen.has_source_texture)
+        payload->color = get_pixel_color(&payload->pen.source_tex,
+                                         x % payload->pen.source_tex.width,
+                                         y % payload->pen.source_tex.height);
+
+    /* for color_control block */
+    if(payload->pen.has_color_control_proc)
+        payload->color = exec_color_control_proc(payload, tex, x,  y);
+    
+
+    /*  TO DO: do bitwise pixel combinations here */
+    
+    /* if i do not use blended_pixel and instead use payload->color in the
+       code below i get an interesting blurring effect in images (with alpha_blend => true)
+    */
+    blended_pixel = payload->color;
+    
+    
+    /*  alpha blending
+        TO DO: refactor into its own helper function
+        & rewrite using sse2 */
+    if(payload->pen.alpha_blend) {
+        rgba dest_pixel = get_pixel_color(tex, x, y);
+            
+        /* 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 */
+        if(is_a_color(payload->color) && is_a_color(dest_pixel)) {
+
+            /** TO DO: rewrite this using sse2 instructions **/
+            blended_pixel.red = payload->color.alpha * payload->color.red + (1 - payload->color.alpha)
+                * dest_pixel.red;
+
+            blended_pixel.green = payload->color.alpha * payload->color.green + (1 - payload->color.alpha)
+                * dest_pixel.green;
+
+            blended_pixel.blue = payload->color.alpha * payload->color.blue + (1 - payload->color.alpha)
+                * dest_pixel.blue;
+
+            blended_pixel.alpha = payload->color.alpha;
+        }
+    }
+
+    set_pixel_color(&blended_pixel, tex, x, y);
+}
+