texplay 0.2.7-x86-mswin32

data/ext/texplay/bindings.h

@@ -0,0 +1,46 @@
+#ifndef GUARD_BINDINGS_H
+#define GUARD_BINDINGS_H
+
+/* class methods */
+VALUE M_create_macro(VALUE self , VALUE method_name);
+VALUE M_remove_macro(VALUE self, VALUE method_name);
+VALUE M_refresh_cache_all(VALUE self);
+VALUE M_create_blank(VALUE self, VALUE window, VALUE width, VALUE height);
+
+/* instance methods */
+VALUE m_paint(int argc, VALUE * argv, VALUE self);
+VALUE m_getpixel(int argc, VALUE * argv, VALUE self);
+VALUE m_circle(int argc, VALUE * argv, VALUE self);
+VALUE m_line(int argc, VALUE * argv, VALUE self);
+VALUE m_rect(int argc, VALUE * argv, VALUE self);
+VALUE m_pixel(int argc, VALUE * argv, VALUE self);
+VALUE m_flood_fill(int argc, VALUE * argv, VALUE self);
+VALUE m_bezier(int argc, VALUE * argv, VALUE self);
+VALUE m_polyline(int argc, VALUE * argv, VALUE self);
+VALUE m_ngon(int argc, VALUE * argv, VALUE self);
+VALUE m_special_pixel(int argc, VALUE * argv, VALUE self);
+VALUE m_splice(int argc, VALUE * argv, VALUE self);
+VALUE m_clear(int argc, VALUE * argv, VALUE self);
+VALUE m_offset(int argc, VALUE * argv, VALUE self);
+VALUE m_color(int argc, VALUE * argv, VALUE self);
+VALUE m_missing(int argc, VALUE * argv, VALUE self);
+VALUE m_bitmask(int argc, VALUE * argv, VALUE self);
+VALUE m_lshift(int argc, VALUE * argv, VALUE self);
+VALUE m_rshift(int argc, VALUE * argv, VALUE self);
+
+VALUE m_each(int argc, VALUE * argv, VALUE self);
+
+VALUE m_quad_cached(VALUE self);
+VALUE m_cache_refresh(VALUE self);
+
+VALUE m_user_set_options(VALUE self, VALUE options);
+VALUE m_user_delete_options(VALUE self);
+VALUE m_get_options(VALUE self);
+VALUE m_force_sync(VALUE self, VALUE ary);
+
+VALUE m_dup_image(VALUE self);
+VALUE m_clone_image(VALUE self);
+
+VALUE m_to_blob(VALUE self);
+
+#endif

data/ext/texplay/cache.c

@@ -0,0 +1,135 @@
+/* cache.c */
+
+#include <ruby.h>
+
+#ifdef __APPLE__
+#include <glut.h>
+#else
+#include <GL/glut.h>
+#endif
+
+#include "cache.h"
+#include "texplay.h"
+
+typedef struct {
+    int len;
+    cache_entry entry[CACHE_SIZE];                                          
+} cache_t;
+
+/* var has internal linkage, static duration */
+/* contains cache data */
+static cache_t cache = {0}; 
+
+/* create a new cache entry */
+cache_entry*
+cache_create_entry(int tname) {
+    float * new_array;
+    int sidelength, new_element = cache.len;
+    GLint saved_tname;
+
+    if(cache.len >= CACHE_SIZE) {  rb_raise(rb_eRuntimeError, "cache is full! increase CACHE_SIZE");  }
+
+    /* save current texture binding */
+    /*  glGetIntegerv(GL_TEXTURE_BINDING_2D, &saved_tname); */
+
+    /* opengl initialization code */
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, tname);
+
+    /* get length of a side, since square texture */
+    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &sidelength);
+
+    /* initialize texture data array, mult. by 4 because {rgba} */
+    new_array = malloc(sidelength * sidelength * 4 * sizeof(float));
+
+    /* get texture data from video memory */
+    glGetTexImage(GL_TEXTURE_2D,  0, GL_RGBA, GL_FLOAT,(void*)(new_array));
+
+    /* save texture data in the cache */
+    cache.entry[new_element].tname = tname;
+    cache.entry[new_element].sidelength = sidelength;
+    cache.entry[new_element].tdata = new_array;
+
+    /* update size of cache */
+    cache.len++;
+
+    /* restore saved texture binding */
+    /* glBindTexture(GL_TEXTURE_2D, saved_tname); */
+
+    glDisable(GL_TEXTURE_2D);
+
+
+    return &cache.entry[new_element];
+}
+
+/* return the entry if it exists, otherwise return NULL */
+cache_entry*
+find_in_cache(int tname) {
+    /* check if entry exists in cache */
+    int index;
+    for(index = 0; index < cache.len; index++) 
+        if(cache.entry[index].tname == tname) 
+            return &cache.entry[index];
+    
+    
+    return NULL;
+}
+
+/* if the entry doesn't exist then create it and return it.
+   otherwise just return it */
+cache_entry*
+find_or_create_cache_entry(int tname) {
+    cache_entry * entry;
+
+    if((entry=find_in_cache(tname)))
+        return entry;
+    else
+        return cache_create_entry(tname);
+}
+
+/* refresh the cache for all quads */
+void
+cache_refresh_all(void) {
+    float * tdata;
+    int tname, index;
+    GLint saved_tname;
+
+    /* save current texture binding */
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &saved_tname);
+
+    for(index = 0; index < cache.len; index++) {
+        tdata = cache.entry[index].tdata;
+        tname = cache.entry[index].tname;
+
+        /* opengl initialization code */
+        glEnable(GL_TEXTURE_2D);
+        glBindTexture(GL_TEXTURE_2D, tname);
+
+        glGetTexImage(GL_TEXTURE_2D,  0, GL_RGBA, GL_FLOAT, (void*)(tdata));
+    }
+
+    /* restore saved texture binding */
+    glBindTexture(GL_TEXTURE_2D, saved_tname);
+}
+
+/* refresh the cache for a specific quad */
+void
+cache_refresh_entry(int tname) {
+    GLint saved_tname;
+    cache_entry * entry;
+
+    /* save current texture binding */
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &saved_tname);
+
+    entry = find_in_cache(tname);
+    
+    /* opengl initialization code */
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, entry->tname);
+
+    glGetTexImage(GL_TEXTURE_2D,  0, GL_RGBA, GL_FLOAT, (void*)(entry->tdata));
+
+    /* restore saved texture binding */
+    glBindTexture(GL_TEXTURE_2D, saved_tname);
+}
+

data/ext/texplay/cache.h

@@ -0,0 +1,24 @@
+/* cache.h */
+/* see cache.c for annotations */
+
+#ifndef GUARD_CACHE_H
+#define GUARD_CACHE_H
+
+/* defines */
+#define CACHE_SIZE 10000
+
+/* data types */
+typedef struct {
+    int tname;
+    int sidelength;
+    float * tdata;
+} cache_entry;
+
+/* functions */
+void cache_refresh_all(void);
+void cache_refresh_entry(int tname);
+cache_entry * cache_create_entry(int texture_name);
+cache_entry * find_in_cache(int texture_name);
+cache_entry * find_or_create_cache_entry(int texture_name);
+
+#endif

data/ext/texplay/compat.h

@@ -0,0 +1,27 @@
+/* contains basic macros to facilitate ruby 1.8 and ruby 1.9 compatibility */
+
+#ifndef GUARD_COMPAT_H
+#define GUARD_COMPAT_H
+
+#include <ruby.h>
+
+/* this is the test we use to identify ruby 1.9.1 */
+
+/* commenting out this test because it doesn't seem to work in 1.8.7 */
+/*
+#ifdef RCLASS_M_TBL
+# define RUBY_19
+#endif
+*/
+
+/* macros for backwards compatibility with 1.8 */
+#ifndef RUBY_19
+# define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
+# define RCLASS_SUPER(c) (RCLASS(c)->super)
+# define RCLASS_IV_TBL(c) (RCLASS(c)->iv_tbl)
+#endif
+
+/* a useful macro. cannot use ordinary CLASS_OF as it does not return an lvalue */
+#define KLASS_OF(c) (RBASIC(c)->klass)
+
+#endif

data/ext/texplay/extconf.rb

@@ -0,0 +1,30 @@
+require 'mkmf'
+
+
+# linux
+if RUBY_PLATFORM =~ /linux/ then
+    exit unless have_library("glut")
+    exit unless have_library("GL")
+    
+# macosx
+elsif RUBY_PLATFORM =~ /darwin/
+    $LDFLAGS +=  " -framework GLUT"
+    $CFLAGS += " -I/System/Library/Frameworks/GLUT.framework/Headers"
+
+# windows    
+else
+    
+    exit unless have_library("freeglut_static") 
+    exit unless have_library("opengl32")
+    
+    if RUBY_PLATFORM =~ /mingw/
+        $CFLAGS += " -I/home/john/.rake-compiler/ruby/ruby-1.9.1-p243/include"
+        $CFLAGS += " -I/home/john/.rake-compiler/ruby/ruby-1.8.6-p287/include"
+        $CFLAGS += " -D FREEGLUT_STATIC"
+    end
+end
+
+# 1.9 compatibility
+$CFLAGS += " -DRUBY_19" if RUBY_VERSION =~ /1.9/
+
+create_makefile('texplay')

data/ext/texplay/gen_eval.c

@@ -0,0 +1,211 @@
+/* gen_eval.c */
+/* (C) John Mair 2009
+ * This program is distributed under the terms of the MIT License
+ *                                                                */
+
+#include <ruby.h>
+#include "object2module.h"
+#include "compat.h"
+
+VALUE
+retrieve_hidden_self(VALUE duped_context)
+{
+    VALUE thread_id, unique_name, hidden_self;
+    
+    /* retrieve hidden self (if it exists) */
+    thread_id = rb_funcall(rb_obj_id(rb_thread_current()), rb_intern("to_s"), 0);
+    unique_name = rb_str_plus(rb_str_new2("__hidden_self__"), thread_id);
+    
+    hidden_self = rb_ivar_get(duped_context, rb_to_id(unique_name));
+
+    return hidden_self;
+}
+
+void
+set_hidden_self(VALUE duped_context, VALUE hidden_self)
+{
+    VALUE thread_id, unique_name;
+    
+    /* generate a unique (thread safe) name for the hidden self  */
+    thread_id = rb_funcall(rb_obj_id(rb_thread_current()), rb_intern("to_s"), 0);
+    unique_name = rb_str_plus(rb_str_new2("__hidden_self__"), thread_id);
+
+    /* store self in hidden var in duped context */
+    rb_ivar_set(duped_context, rb_to_id(unique_name), hidden_self);
+}
+
+VALUE
+rb_capture(VALUE self) {
+    VALUE hidden_self;
+    VALUE result;
+    
+    rb_need_block();
+    
+    hidden_self = retrieve_hidden_self(self);
+
+    /* 2 cases: (1) if rb_gen_eval is active then instance_eval wrt hidden_self
+                (2) otherwise simply yield to the block
+    */
+    if(!NIL_P(hidden_self))
+        result = rb_obj_instance_eval(0, 0, hidden_self);
+    else
+        result = rb_yield(Qnil);
+
+    /* we want the return value of capture to be the return value of the block */
+    return result;
+}
+
+/** ruby 1.9 funcs **/
+#ifdef RUBY_19
+void
+redirect_iv_for_object(VALUE obj, VALUE dest)
+{
+    if(TYPE(obj) != T_OBJECT)
+        rb_raise(rb_eArgError, "must provide a T_OBJECT");
+
+    if (!(RBASIC(dest)->flags & ROBJECT_EMBED) && ROBJECT_IVPTR(dest)) {
+        rb_raise(rb_eArgError, "im sorry gen_eval does not yet work with this type of ROBJECT");
+    }
+    if (RBASIC(obj)->flags & ROBJECT_EMBED) {
+        rb_raise(rb_eArgError, "im sorry gen_eval does not yet work with ROBJECT_EMBED types");
+    }
+    else {
+        ROBJECT(dest)->as.heap.ivptr = ROBJECT(obj)->as.heap.ivptr;
+        ROBJECT(dest)->as.heap.numiv = ROBJECT(obj)->as.heap.numiv;
+        ROBJECT(dest)->as.heap.iv_index_tbl = ROBJECT(obj)->as.heap.iv_index_tbl;
+        RBASIC(dest)->flags &= ~ROBJECT_EMBED;
+    }
+}
+
+void
+release_iv_for_object(VALUE obj)
+{
+    if(TYPE(obj) != T_OBJECT)
+        rb_raise(rb_eArgError, "must provide a T_OBJECT");
+    
+    ROBJECT(obj)->as.heap.ivptr = (void *) 0;
+    ROBJECT(obj)->as.heap.numiv = 0;
+    ROBJECT(obj)->as.heap.iv_index_tbl = (void *) 0;
+    RBASIC(obj)->flags &= ~ROBJECT_EMBED;
+}
+#endif
+/** end of ruby 1.9 funcs **/
+
+VALUE
+rb_gen_eval(int argc, VALUE * argv, VALUE self) {
+    VALUE duped_context;
+    VALUE is_a_module;
+    VALUE context;
+    VALUE result;
+    
+    rb_need_block();
+        
+    context = rb_funcall(rb_block_proc(), rb_intern("__context__"), 0);
+
+    /* using Class instead of Object (where possible) because Object's iv_tbl setup in 1.9 is weird */
+#ifdef RUBY_19
+    if(TYPE(context) == T_OBJECT)
+        duped_context = rb_funcall(rb_cObject, rb_intern("new"), 0);
+    else 
+        duped_context = rb_funcall(rb_cClass, rb_intern("new"), 0);
+
+#else
+
+    duped_context = rb_funcall(rb_cClass, rb_intern("new"), 0);
+
+#endif    
+    
+    
+    /* the duped_context shares the context's iv_tbl.
+       2 cases: (1) external iv_tbl, (2) local iv_tbl
+       
+       NOTE: we do not need to save original iv_tbl before replacing it, a brand new Class
+       instance does not yet have an iv_tbl (the pointer is set to 0) 
+    */
+    if(FL_TEST(context, FL_EXIVAR)) 
+        RCLASS_IV_TBL(duped_context) = (struct st_table *) rb_generic_ivar_table(context);
+    else {
+#ifdef RUBY_19
+        if(TYPE(context) == T_OBJECT)
+            redirect_iv_for_object(context, duped_context);
+        else {
+            RCLASS_IV_TBL(duped_context) = (struct st_table *) RCLASS_IV_TBL(context);
+        }
+#else
+        RCLASS_IV_TBL(duped_context) = (struct st_table *) RCLASS_IV_TBL(context);
+#endif        
+
+        
+    }
+        
+    /* ensure singleton exists */
+    rb_singleton_class(context);
+    
+    /* set up the class hierarchy for our dup_context */
+    KLASS_OF(duped_context) = rb_singleton_class_clone(context);
+
+    /* if no args then default to mixing in 'self' */
+    if(argc == 0) {
+        argc = 1;
+        argv = &self;
+    }
+
+    /* mix the objects (or self) into the duped context */
+    rb_gen_extend(argc, argv, duped_context);
+
+    /* store self in hidden var in duped context */
+    set_hidden_self(duped_context, self);
+
+    is_a_module = rb_funcall(duped_context, rb_intern("is_a?"), 1, rb_cModule);
+
+    /* eval block wrt duped_context */
+    if(is_a_module == Qtrue)
+        result = rb_mod_module_eval(0, 0, duped_context);
+    else
+        result = rb_obj_instance_eval(0, 0, duped_context);
+
+    /* clean up goes below */
+
+    /* release context's iv_tbl from duped_context. */
+#ifdef RUBY_19
+    if(TYPE(duped_context) == T_OBJECT)
+        release_iv_for_object(duped_context);
+    else {
+        RCLASS_IV_TBL(duped_context) = (struct st_table *) 0;
+    }
+#else
+    RCLASS_IV_TBL(duped_context) = (struct st_table *) 0;
+#endif
+
+    /* delete hidden self */
+    set_hidden_self(duped_context, Qnil);
+    
+    return result;
+}
+
+void
+Init_gen_eval() {
+
+    rb_define_method(rb_cObject, "gen_eval", rb_gen_eval, -1);
+    rb_define_method(rb_cObject, "capture", rb_capture, 0);
+    
+    rb_define_method(rb_cObject, "to_module", rb_to_module , 0);
+    rb_define_method(rb_cObject, "reset_tbls", rb_reset_tbls , 0);
+    rb_define_method(rb_cObject, "gen_extend", rb_gen_extend, -1);
+    rb_define_method(rb_cModule, "gen_include", rb_gen_include, -1);
+
+    /* below is much too hard to achieve in pure C */
+    rb_eval_string("class Proc;"
+                   "    def __context__;"
+                   "        eval('self', self.binding);"
+                   "    end;"
+                   "end;"
+                   );
+    
+    rb_define_alias(rb_cObject, "gen_eval_with", "gen_eval");
+}
+
+    
+    
+
+    

data/ext/texplay/gen_eval.h

@@ -0,0 +1,20 @@
+/* gen_eval.h */
+
+#ifndef GUARD_GEN_EVAL_H
+#define GUARD_GEN_EVAL_H
+
+#include <ruby.h>
+
+VALUE rb_gen_eval(int argc, VALUE * argv, VALUE self);
+VALUE rb_capture(VALUE self);
+VALUE retrieve_hidden_self(VALUE duped_context);
+void set_hidden_self(VALUE duped_context, VALUE hidden_self);
+
+/* change self to hidden self if __hidden_self__ defined */
+#define ADJUST_SELF(X)                                                    \
+  do {                                                                    \
+      if(!NIL_P(retrieve_hidden_self((X))))                               \
+          (X) = retrieve_hidden_self((X));                                \
+  } while(0)
+        
+#endif

data/ext/texplay/object2module.c

@@ -0,0 +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);
+}
+

data/ext/texplay/object2module.h

@@ -0,0 +1,11 @@
+/* object2module.h */
+
+#ifndef GUARD_OBJECT2MODULE_H
+#define GUARD_OBJECT2MODULE_H
+        
+VALUE rb_gen_include(int argc, VALUE * argv, VALUE self);
+VALUE rb_gen_extend(int argc, VALUE * argv, VALUE self);
+VALUE rb_to_module(VALUE self);
+VALUE rb_reset_tbls(VALUE self);
+
+#endif