texplay 0.2.800 → 0.2.900

data/ext/texplay/graphics_utils.c

@@ -16,6 +16,7 @@ static void process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync
 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 void prepare_color_select(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);
@@ -30,22 +31,23 @@ 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))));
+    if (cur->sync_mode != lazy_sync)
+      return;
+    
+    VALUE lazy_bounds;
+    int xmin, ymin, xmax, ymax;
 
-        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);
-    }
+    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);
 }
 
 void
@@ -63,11 +65,11 @@ update_bounds(action_struct * cur, int xmin, int ymin, int xmax, int ymax)
 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: */
-    
+    if(cur->sync_mode == no_sync)
+        return;
+            
     /* eager sync: to demarcate precise area to sync to opengl */
     /* lazy sync: to update global bounds */
     cur->xmin = xmin;
@@ -145,6 +147,55 @@ set_pixel_color(rgba * pixel_color, texture_info * tex, int x, int y)
     tex_data[alpha] = pixel_color->alpha;    
 }
 
+static bool
+skip_pixel(rgba source_color, action_struct * payload, texture_info * tex, int x, int y)
+{
+  
+  if (!payload->pen.has_color_select) return false;
+  
+  rgba dest_color = get_pixel_color(tex, x, y);
+  bool color_match = false;
+  
+  if (payload->pen.source_select.size > 0) {
+    for (int i = 0; i < payload->pen.source_select.size; i++) {
+      if (cmp_color(source_color, payload->pen.source_select.colors[i])) {
+              color_match = true;
+              break;
+      }
+    }
+    if (!color_match) return true;
+  }
+  
+
+  if (payload->pen.source_ignore.size > 0) {
+    for (int i = 0; i < payload->pen.source_ignore.size; i++) {
+          if (cmp_color(source_color, payload->pen.source_ignore.colors[i]))
+              return true;
+    }
+  }
+
+  color_match = false;
+  if (payload->pen.dest_select.size > 0) {
+    for (int i = 0; i < payload->pen.dest_select.size; i++) {
+        if (cmp_color(dest_color, payload->pen.dest_select.colors[i])) {
+            color_match = true;
+            break;
+        }
+    }
+    if (!color_match) return true;
+  }
+
+  if (payload->pen.dest_ignore.size > 0) {
+    for (int i = 0; i < payload->pen.dest_ignore.size; i++) {
+          if (cmp_color(dest_color, payload->pen.dest_ignore.colors[i]))
+              return true;
+    }
+  }
+
+  return false;
+}
+
+
 void
 set_pixel_color_with_style(action_struct * payload, texture_info * tex, int x, int y)
 {
@@ -153,6 +204,7 @@ 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);
@@ -168,12 +220,15 @@ set_pixel_color_with_style(action_struct * payload, texture_info * tex, int x, i
                                          x % payload->pen.source_tex.width,
                                          y % payload->pen.source_tex.height);
 
-    /* for color_control block */
+    /* for color_control proc */
     if(payload->pen.has_color_control_proc)
         blended_pixel = exec_color_control_proc(payload, tex, x,  y, blended_pixel);
-    
 
-    /*  TO DO: do bitwise pixel combinations here */
+    /* should skip this pixel? */
+    if (skip_pixel(blended_pixel, payload, tex, x, y))
+      return;
+
+    /* drawing modes */
     if(payload->pen.has_drawing_mode) {
       blended_pixel = apply_drawing_mode(payload, tex, x, y);
     }
@@ -245,12 +300,16 @@ get_pixel_data(texture_info * tex, int x, int y)
 VALUE
 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"));
+    static VALUE empty_image_stub = 0;
+    static VALUE image = 0;
+
+    if (empty_image_stub == 0) {
+        VALUE gosu = rb_const_get(rb_cObject, rb_intern("Gosu"));
+        VALUE tp = rb_const_get(rb_cObject, rb_intern("TexPlay"));
+        empty_image_stub = rb_const_get(tp, rb_intern("EmptyImageStub"));
+        image = rb_const_get(gosu, rb_intern("Image"));
+    }
 
-    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;
 
@@ -293,6 +352,13 @@ initialize_action_struct(action_struct * cur, VALUE hash_arg, sync sync_mode)
 
     /* drawing mode is off by deafult */
     cur->pen.has_drawing_mode = false;
+
+    /* color selection */
+    cur->pen.has_color_select = false;
+    cur->pen.source_select.size = 0;
+    cur->pen.source_ignore.size = 0;
+    cur->pen.dest_select.size = 0;
+    cur->pen.dest_ignore.size = 0;
 }
     
 /* TODO: fix this function below, it's too ugly and bulky and weird **/
@@ -365,6 +431,9 @@ process_common_hash_args(action_struct * cur, VALUE * hash_arg, sync sync_mode,
         
     }
 
+    /* prepare color selection */
+    prepare_color_select(cur);
+    
     /* process drawing mode */
     prepare_drawing_mode(cur);
 
@@ -450,14 +519,14 @@ prepare_drawing_mode(action_struct * cur)
         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("color_dodge"))
+        cur->pen.drawing_mode = color_dodge;
+      else if(draw_mode == string2sym("color_burn"))
+        cur->pen.drawing_mode = color_burn;
+      else if(draw_mode == string2sym("hard_light"))
+        cur->pen.drawing_mode = hard_light;
+      else if(draw_mode == string2sym("soft_light"))
+        cur->pen.drawing_mode = soft_light;
       else if(draw_mode == string2sym("difference"))
         cur->pen.drawing_mode = difference;
       else if(draw_mode == string2sym("exclusion"))
@@ -488,24 +557,23 @@ prepare_color_control(action_struct * cur)
             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.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;
             }
             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.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;
             }
@@ -576,6 +644,65 @@ prepare_fill_texture(action_struct * payload)
     }
 }
 
+static void
+process_select_color_list(rgba_list * clist, VALUE try_color)
+{
+    /* is a general array of colors? i.e [:red, Gosu::Color::RED, [1,1,1,1] ] */
+    if (TYPE(try_color) == T_ARRAY && not_rb_raw_color(try_color)) {
+      int num_colors = RARRAY_LEN(try_color);
+
+      if (num_colors > RGBA_LIST_SIZE)
+        rb_raise(rb_eArgError, "Too many colors given in array. Maximum is %d\n. Got %d\n",
+                 RGBA_LIST_SIZE, num_colors);
+
+      for (int i = 0; i < RARRAY_LEN(try_color); ++i) {
+        clist->colors[i] = convert_rb_color_to_rgba(get_from_array(try_color, i));
+      }
+      
+      clist->size = num_colors;
+    }
+
+    /* is a single color value? i.e :red, [1,1,1,1], Gosu::Color::GREEN */
+    else {
+        clist->colors[0] = convert_rb_color_to_rgba(try_color);
+        clist->size = 1;
+    }
+}  
+  
+
+static void
+prepare_color_select(action_struct * payload)
+{
+  VALUE try_color = get_from_hash(payload->hash_arg,
+                                        "source_select");
+  if (!NIL_P(try_color)) {
+    process_select_color_list(&payload->pen.source_select, try_color);
+    payload->pen.has_color_select = true;
+  }
+
+  try_color = get_from_hash(payload->hash_arg,
+                                        "source_ignore");
+  if (!NIL_P(try_color)) {
+    process_select_color_list(&payload->pen.source_ignore, try_color);
+    payload->pen.has_color_select = true;
+  }
+
+  try_color = get_from_hash(payload->hash_arg,
+                                        "dest_select");
+  if (!NIL_P(try_color)) {
+    process_select_color_list(&payload->pen.dest_select, try_color);
+    payload->pen.has_color_select = true;
+  }
+  
+  try_color = get_from_hash(payload->hash_arg,
+                                        "dest_ignore");
+  if (!NIL_P(try_color)) {
+    process_select_color_list(&payload->pen.dest_ignore, try_color);
+    payload->pen.has_color_select = true;
+  }
+
+}
+
 /***********************************/
 /**** drawing mode related code ****/
 /***********************************/
@@ -720,32 +847,32 @@ apply_drawing_mode(action_struct * payload, texture_info * tex, int x, int y)
       finished_pixel = color_int_vals_to_float_format(~source_pixel_char.red,
                                                ~source_pixel_char.green,
                                                ~source_pixel_char.blue,
-                                               ~source_pixel_char.alpha);
+                                               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);
+                                               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);
+                                               source_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);
+                                               source_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);
+                                               source_pixel_char.alpha);
       
       break;
     case nand:
@@ -759,34 +886,34 @@ apply_drawing_mode(action_struct * payload, texture_info * tex, int x, int y)
       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));
+                                               source_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);
+                                               source_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));
+                                               source_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);      
+                                               source_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);
+                                               source_pixel_char.alpha);
       
       break;
 
@@ -809,7 +936,6 @@ apply_drawing_mode(action_struct * payload, texture_info * tex, int x, int y)
       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),
@@ -822,24 +948,24 @@ apply_drawing_mode(action_struct * payload, texture_info * tex, int x, int y)
                                 MAX(source_pixel.blue, dest_pixel.blue),
                                 MAX(source_pixel.alpha, dest_pixel.alpha) };
       break;
-    case colordodge:
+    case color_dodge:
       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:
+    case color_burn:
       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:
+    case hard_light:
       finished_pixel = mode_hardlight(dest_pixel, source_pixel);
 
       break;
-    case softlight:
+    case soft_light:
       finished_pixel = mode_softlight(dest_pixel, source_pixel);
 
       break;
@@ -915,7 +1041,7 @@ apply_alpha_blend(action_struct * payload, texture_info * tex, int x, int y, rgb
     rgba finished_pixel;
 
 
-    if(not_a_color(blended_pixel))
+    if (not_a_color(blended_pixel))
         return blended_pixel;
     
     /* alpha blending is nothing more than a weighted average of src and dest pixels
@@ -948,7 +1074,6 @@ allocate_texture(int width, int height)
     int mval;
     
     mval = 4 * width * height * sizeof(float);
-    //    assert(mval > 0); 
         
     new_texture = malloc(mval);
     

data/ext/texplay/graphics_utils.h

@@ -19,5 +19,4 @@ float* get_pixel_data(texture_info * tex, int x, int y);
 /* create a blank gosu image of width and height */
 VALUE create_image(VALUE window, int width, int height);
 
-
 #endif

data/ext/texplay/object2module.c

@@ -1,171 +1,171 @@
-/* object2module.c */
-/* (C) John Mair 2009
- * This program is distributed under the terms of the MIT License
- *                                                                */
-
-#include <ruby.h>
-#include "compat.h"
-
-#ifdef RUBY_19
-# include <ruby/st.h>
-#else
-# include <st.h>
-#endif
-
-/* class creation. from class.c in 1.9.1 */
-#ifdef RUBY_19
-static VALUE
-class_alloc(VALUE flags, VALUE klass)
-{
-    rb_classext_t *ext = ALLOC(rb_classext_t);
-    NEWOBJ(obj, struct RClass);
-    OBJSETUP(obj, klass, flags);
-    obj->ptr = ext;
-    RCLASS_IV_TBL(obj) = 0;
-    RCLASS_M_TBL(obj) = 0;
-    RCLASS_SUPER(obj) = 0;
-    RCLASS_IV_INDEX_TBL(obj) = 0;
-    return (VALUE)obj;
-}
-#endif
-
-/* a modified version of include_class_new from class.c */
-static VALUE
-j_class_new(VALUE module, VALUE sup)
-{
-
-#ifdef RUBY_19
-    VALUE klass = class_alloc(T_ICLASS, rb_cClass);
-#else
-    NEWOBJ(klass, struct RClass);
-    OBJSETUP(klass, rb_cClass, T_ICLASS);
-#endif
-
-    if (BUILTIN_TYPE(module) == T_ICLASS) {
-        module = KLASS_OF(module);
-    }
-
-    if (!RCLASS_IV_TBL(module)) {
-
-        RCLASS_IV_TBL(module) = (struct st_table *)st_init_numtable();
-    }
-
-    /* assign iv_tbl, m_tbl and super */
-    RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);
-    RCLASS_SUPER(klass) = sup;
-    if(TYPE(module) != T_OBJECT) {
-
-        RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);
-    }
-    else {
-        RCLASS_M_TBL(klass) = RCLASS_M_TBL(CLASS_OF(module));
-    }
-
-    /* */
-
-    if (TYPE(module) == T_ICLASS) {
-        KLASS_OF(klass) = KLASS_OF(module);
-    }
-    else {
-        KLASS_OF(klass) = module;
-    }
-
-    if(TYPE(module) != T_OBJECT) {
-        OBJ_INFECT(klass, module);
-        OBJ_INFECT(klass, sup);
-    }
-    return (VALUE)klass;
-}
-
-VALUE
-rb_to_module(VALUE self)
-{
-    VALUE rclass, chain_start, jcur, klass;
-
-    switch(BUILTIN_TYPE(self)) {
-    case T_MODULE:
-        return self;
-    case T_CLASS:
-        klass = self;
-        break;
-    case T_OBJECT:
-    default:
-        klass = rb_singleton_class(self);            
-    }
-            
-    chain_start = j_class_new(klass, rb_cObject);
-
-    KLASS_OF(chain_start) = rb_cModule;
-    RBASIC(chain_start)->flags = T_MODULE;
-
-    jcur = chain_start;
-    for(rclass = RCLASS_SUPER(klass); rclass != rb_cObject;
-        rclass = RCLASS_SUPER(rclass)) {
-                
-        RCLASS_SUPER(jcur) = j_class_new(rclass, rb_cObject);
-        jcur = RCLASS_SUPER(jcur);
-    }
-
-    RCLASS_SUPER(jcur) = (VALUE)NULL;
-
-    return chain_start;
-}
-
-VALUE
-rb_reset_tbls(VALUE self)
-{
-    RCLASS_IV_TBL(self) = (struct st_table *) 0;
-    RCLASS_M_TBL(self) = (struct st_table *) st_init_numtable();
-    return Qnil;
-}
-
-/* cannot simply forward to gen_include as need to invoke 'extended' hook */
-VALUE
-rb_gen_extend(int argc, VALUE * argv, VALUE self)
-{
-    int i;
-
-    if (argc == 0) rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
-    
-    rb_singleton_class(self);
-
-    for(i = 0; i < argc; i++) {
-        VALUE mod = rb_to_module(argv[i]); 
-        rb_funcall(mod, rb_intern("extend_object"), 1, self);
-        rb_funcall(mod, rb_intern("extended"), 1, self);
-        
-        /* only redirect if argv[i] is not a module */
-        if(argv[i] != mod) rb_reset_tbls(mod);
-    }
-
-    return self;
-}
-
-VALUE
-rb_gen_include(int argc, VALUE * argv, VALUE self)
-{
-    int i;
-
-    if (argc == 0) rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
-
-    for(i = 0; i < argc; i++) {
-        VALUE mod = rb_to_module(argv[i]); 
-        rb_funcall(mod, rb_intern("append_features"), 1, self);
-        rb_funcall(mod, rb_intern("included"), 1, self);
-        
-        if(argv[i] != mod) rb_reset_tbls(mod);       
-    }
-
-    return self;
-}
- 
-
-void Init_object2module()
-{
-
-    rb_define_method(rb_cObject, "to_module", rb_to_module , 0);
-    rb_define_method(rb_cObject, "gen_extend", rb_gen_extend, -1);
-    rb_define_method(rb_cModule, "gen_include", rb_gen_include, -1);
-    rb_define_method(rb_cModule, "reset_tbls", rb_reset_tbls, 0);
-}
-
+/* object2module.c */
+/* (C) John Mair 2009
+ * This program is distributed under the terms of the MIT License
+ *                                                                */
+
+#include <ruby.h>
+#include "compat.h"
+
+#ifdef RUBY_19
+# include <ruby/st.h>
+#else
+# include <st.h>
+#endif
+
+/* class creation. from class.c in 1.9.1 */
+#ifdef RUBY_19
+static VALUE
+class_alloc(VALUE flags, VALUE klass)
+{
+    rb_classext_t *ext = ALLOC(rb_classext_t);
+    NEWOBJ(obj, struct RClass);
+    OBJSETUP(obj, klass, flags);
+    obj->ptr = ext;
+    RCLASS_IV_TBL(obj) = 0;
+    RCLASS_M_TBL(obj) = 0;
+    RCLASS_SUPER(obj) = 0;
+    RCLASS_IV_INDEX_TBL(obj) = 0;
+    return (VALUE)obj;
+}
+#endif
+
+/* a modified version of include_class_new from class.c */
+static VALUE
+j_class_new(VALUE module, VALUE sup)
+{
+
+#ifdef RUBY_19
+    VALUE klass = class_alloc(T_ICLASS, rb_cClass);
+#else
+    NEWOBJ(klass, struct RClass);
+    OBJSETUP(klass, rb_cClass, T_ICLASS);
+#endif
+
+    if (BUILTIN_TYPE(module) == T_ICLASS) {
+        module = KLASS_OF(module);
+    }
+
+    if (!RCLASS_IV_TBL(module)) {
+
+        RCLASS_IV_TBL(module) = (struct st_table *)st_init_numtable();
+    }
+
+    /* assign iv_tbl, m_tbl and super */
+    RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);
+    RCLASS_SUPER(klass) = sup;
+    if(TYPE(module) != T_OBJECT) {
+
+        RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);
+    }
+    else {
+        RCLASS_M_TBL(klass) = RCLASS_M_TBL(CLASS_OF(module));
+    }
+
+    /* */
+
+    if (TYPE(module) == T_ICLASS) {
+        KLASS_OF(klass) = KLASS_OF(module);
+    }
+    else {
+        KLASS_OF(klass) = module;
+    }
+
+    if(TYPE(module) != T_OBJECT) {
+        OBJ_INFECT(klass, module);
+        OBJ_INFECT(klass, sup);
+    }
+    return (VALUE)klass;
+}
+
+VALUE
+rb_to_module(VALUE self)
+{
+    VALUE rclass, chain_start, jcur, klass;
+
+    switch(BUILTIN_TYPE(self)) {
+    case T_MODULE:
+        return self;
+    case T_CLASS:
+        klass = self;
+        break;
+    case T_OBJECT:
+    default:
+        klass = rb_singleton_class(self);            
+    }
+            
+    chain_start = j_class_new(klass, rb_cObject);
+
+    KLASS_OF(chain_start) = rb_cModule;
+    RBASIC(chain_start)->flags = T_MODULE;
+
+    jcur = chain_start;
+    for(rclass = RCLASS_SUPER(klass); rclass != rb_cObject;
+        rclass = RCLASS_SUPER(rclass)) {
+                
+        RCLASS_SUPER(jcur) = j_class_new(rclass, rb_cObject);
+        jcur = RCLASS_SUPER(jcur);
+    }
+
+    RCLASS_SUPER(jcur) = (VALUE)NULL;
+
+    return chain_start;
+}
+
+VALUE
+rb_reset_tbls(VALUE self)
+{
+    RCLASS_IV_TBL(self) = (struct st_table *) 0;
+    RCLASS_M_TBL(self) = (struct st_table *) st_init_numtable();
+    return Qnil;
+}
+
+/* cannot simply forward to gen_include as need to invoke 'extended' hook */
+VALUE
+rb_gen_extend(int argc, VALUE * argv, VALUE self)
+{
+    int i;
+
+    if (argc == 0) rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
+    
+    rb_singleton_class(self);
+
+    for(i = 0; i < argc; i++) {
+        VALUE mod = rb_to_module(argv[i]); 
+        rb_funcall(mod, rb_intern("extend_object"), 1, self);
+        rb_funcall(mod, rb_intern("extended"), 1, self);
+        
+        /* only redirect if argv[i] is not a module */
+        if(argv[i] != mod) rb_reset_tbls(mod);
+    }
+
+    return self;
+}
+
+VALUE
+rb_gen_include(int argc, VALUE * argv, VALUE self)
+{
+    int i;
+
+    if (argc == 0) rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
+
+    for(i = 0; i < argc; i++) {
+        VALUE mod = rb_to_module(argv[i]); 
+        rb_funcall(mod, rb_intern("append_features"), 1, self);
+        rb_funcall(mod, rb_intern("included"), 1, self);
+        
+        if(argv[i] != mod) rb_reset_tbls(mod);       
+    }
+
+    return self;
+}
+ 
+
+void Init_object2module()
+{
+
+    rb_define_method(rb_cObject, "to_module", rb_to_module , 0);
+    rb_define_method(rb_cObject, "gen_extend", rb_gen_extend, -1);
+    rb_define_method(rb_cModule, "gen_include", rb_gen_include, -1);
+    rb_define_method(rb_cModule, "reset_tbls", rb_reset_tbls, 0);
+}
+