texplay 0.2.0

data/src/bindings.h

@@ -0,0 +1,45 @@
+#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);
+
+#endif

data/src/cache.c

@@ -0,0 +1,132 @@
+/* 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);
+
+    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/src/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/src/compat.h

@@ -0,0 +1,23 @@
+/* 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 */
+#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/src/extconf.rb

@@ -0,0 +1,18 @@
+require 'mkmf'
+
+
+# linux
+if RUBY_PLATFORM =~ /linux/ then
+    exit unless have_library("glut")
+    
+# macosx
+elsif RUBY_PLATFORM =~ /darwin/
+    $LDFLAGS +=  " -framework GLUT"
+    $CPPFLAGS += " -I/System/Library/Frameworks/GLUT.framework/Headers"
+
+# windows    
+else
+    exit unless have_library("glut32") 
+end
+
+create_makefile('ctexplay')

data/src/gen_eval.c

@@ -0,0 +1,209 @@
+/* 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;
+    
+    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))
+        rb_obj_instance_eval(0, 0, hidden_self);
+    else
+        rb_yield(Qnil);
+
+    return hidden_self;
+}
+
+/** 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");
+}
+
+    
+    
+
+