texplay 0.2.7-x86-mswin32

data/ext/texplay/utils.h

@@ -0,0 +1,145 @@
+#ifndef GUARD_UTILS_H
+#define GUARD_UTILS_H
+
+
+/* for use with get_image_local, and set_image_local */
+#define DRAW_OFFSET 0
+#define LAZY_BOUNDS 1
+#define IMAGE_COLOR 2
+#define USER_DEFAULTS 3 
+
+
+/* color and pixel related functions */
+rgba find_color_from_string(char * try_color);
+bool cmp_color(rgba color1, rgba color2);
+void color_copy(float * source, float * dest);
+rgba get_pixel_color(texture_info * tex, int x, int y) ;
+float* get_pixel_data(texture_info * tex, int x, int y);
+void set_pixel_color(rgba * pixel_color, texture_info * tex, int x, int y);
+void zero_color(float * tex);
+bool not_a_color(rgba color1);
+bool is_a_color(rgba color1);
+VALUE convert_rgba_to_rb_color(rgba * pix);
+rgba convert_rb_color_to_rgba(VALUE cval);
+
+VALUE save_rgba_to_image_local_color(VALUE image, rgba color);
+rgba convert_image_local_color_to_rgba(VALUE image);
+
+
+/* string/symbol related functions */
+char* lowercase(char*);
+char* sym2string(VALUE);
+VALUE string2sym(char*);
+
+/* is it a hash? */
+bool is_a_hash(VALUE try_hash);
+
+/* is an array? */
+bool is_an_array(VALUE try_array);
+
+/* is a num? */
+bool is_a_num(VALUE try_num);
+
+/* helpful C wrapper for rb_hash_aref */
+VALUE get_from_hash(VALUE hash, char * sym);
+
+/* a wrapper for rb_hash_aset */
+VALUE set_hash_value(VALUE hash, char * sym, VALUE val);
+
+/* a wrapper for rb_hash_delete */
+VALUE delete_from_hash(VALUE hash, char * sym);
+
+/* does the hash key 'sym' map to value 'val'? */
+bool hash_value_is(VALUE hash, char * sym, VALUE val);
+
+/* determine whether (1) hash is a T_HASH (2) the sym exists in the hash */
+bool has_optional_hash_arg(VALUE hash, char * sym);
+
+
+/* helpful C wrapper for rb_array_store */
+VALUE set_array_value(VALUE array, int index, VALUE val);
+
+/* helpful C wrapper for rb_array_entry */
+VALUE get_from_array(VALUE array, int index);
+
+/* set the lazy_bounds ivar for an image */
+VALUE set_ivar_array(VALUE obj, char * ivar, int argc, ...);
+
+/* initialize lazy_bounds */
+void init_lazy_bounds(VALUE image);
+
+/* initialize the image_local var array */
+VALUE init_image_local(VALUE image);
+
+/* return an image local variable */
+VALUE get_image_local(VALUE image, int name);
+
+/* set an image local variable */
+void set_image_local(VALUE image, int name, VALUE val);
+
+/* error checking functions */
+void check_mask(VALUE mask);
+
+void check_image(VALUE image);
+
+/* is try_image a Gosu::Image ? */
+bool is_gosu_image(VALUE try_image);
+
+/* create a blank gosu image of width and height */
+VALUE create_image(VALUE window, int width, int height);
+
+/* make boundaries sane */
+void constrain_boundaries(int * x0, int * y0, int * x1, int * y1, int width, int height);
+
+/* line clipping */
+void cohen_sutherland_clip (int * x0, int * y0,int * x1, int * y1, int xmin, int ymin,
+                            int xmax, int ymax);
+
+/* check if point is bound by rect and inner thickness */
+bool bound_by_rect_and_inner(int x, int y, int x0, int y0, int x1, int y1, int inner);
+
+/* check if point is bound by rect */
+bool bound_by_rect(int x, int y, int x0, int y0, int x1, int y1);
+
+/* calculate the array offset for a given pixel */
+int calc_pixel_offset(texture_info * tex, int x, int y);
+
+/* calculate the array offset for a given pixel in an action context */
+int calc_pixel_offset_for_action(action_struct * cur, texture_info * tex, int x, int y);
+
+/* return a pointer to a new texture */
+float* allocate_texture(int width, int height);
+
+/* other function prototypes, get info for a texture */
+void get_texture_info(VALUE image, texture_info * tex);
+
+/* ensure gl_tex_info returns non nil */
+VALUE check_for_texture_info(VALUE image);
+
+/* responsible for syncing a subimage to gl */
+void sync_to_gl(int tex_name, int x_offset, int y_offset, int width, int height, void * sub);
+
+/* create a subtexture and sync to gl */
+void create_subtexture_and_sync_to_gl(image_bounds * img_bounds, texture_info * tex);
+
+float * get_image_chunk(texture_info * tex, int xmin, int ymin, int xmax, int ymax);
+
+rgba get_pixel_color_from_chunk(float * chunk, int width, int height, int x, int y);
+
+/* from Texture.cpp in Gosu Graphics folder */
+unsigned max_quad_size(void);
+
+/* point utils */
+bool is_a_point(VALUE try_point);
+VALUE point_x(VALUE point);
+VALUE point_y(VALUE point);
+
+/* mathematical utils, used by bezier curves */
+double power(float base, int exp);
+unsigned fact(int n);
+unsigned comb(int n, int k);
+unsigned perm(int n, int r);
+
+double bernstein(int n, int k, float u);
+
+#endif

data/lib/texplay-contrib.rb

@@ -0,0 +1,171 @@
+begin
+    require 'rubygems'
+rescue LoadError
+end
+
+require 'texplay'
+
+# to bring in String#each_char for 1.8
+if RUBY_VERSION =~ /1.8/
+    require 'jcode'
+end
+
+# setup will be executed straight after Gosu::Image instantiation
+TexPlay::on_setup do
+    @turtle_pos = TexPlay::TPPoint.new(width / 2, height / 2 )
+    @turtle_angle = 0
+end
+
+
+TexPlay::create_macro(:move_to) do |x, y|
+    capture { 
+        @turtle_pos.x = x
+        @turtle_pos.y = y
+    }
+end
+
+TexPlay::create_macro(:move_rel) do |dx, dy|
+    capture { 
+        @turtle_pos.x += dx
+        @turtle_pos.y += dy
+    }
+end
+
+TexPlay::create_macro(:line_to) do |x, y, *other|
+    capture { 
+        line(@turtle_pos.x, @turtle_pos.y, x, y, *other)
+
+        @turtle_pos.x, @turtle_pos.y = x, y
+    }
+end
+
+TexPlay::create_macro(:line_rel) do |dx, dy, *other|
+    capture { 
+        x = @turtle_pos.x + dx
+        y = @turtle_pos.y + dy
+
+        line(@turtle_pos.x, @turtle_pos.y, x, y, *other)
+
+        @turtle_pos.x, @turtle_pos.y = x, y
+    }
+end
+
+TexPlay::create_macro(:turn_to) do |a|
+    capture {
+        @turtle_angle = a
+    }
+end
+
+TexPlay::create_macro(:turn) do |da|
+    capture { 
+        @turtle_angle += da
+    }
+end
+
+TexPlay::create_macro(:forward) do |dist, *other|
+    capture {
+        visible = other.shift
+
+        radians_per_degree = 0.0174532925199433
+
+        x = @turtle_pos.x + dist * Math::cos(radians_per_degree * @turtle_angle)
+        y = @turtle_pos.y + dist * Math::sin(radians_per_degree * @turtle_angle)
+
+        if(visible) then
+            line_to(x, y, *other)
+        else
+            move_to(x, y)
+        end
+    }
+end
+
+# L-System code
+# adding LSystem class to TexPlay module
+class TexPlay::LSystem
+    def initialize(&block)
+        @rules = {}
+        
+        instance_eval(&block) if block
+    end
+    
+    def rule(new_rule)
+        @rules.merge!(new_rule)
+    end
+
+    def atom(new_atom)
+        @atom = new_atom
+    end
+
+    def angle(new_angle=nil)
+        return @angle if !new_angle
+        @angle = new_angle
+    end
+
+    def produce_string(order)
+        order = order[:order]
+        string = @atom.dup
+        
+        order.times do
+            i = 0
+            while(i < string.length)
+                sub = @rules[string[i, 1]]
+                
+                string[i] = sub if sub
+                
+                i += sub ? sub.length : 1
+            end
+        end
+        
+        string
+    end
+end
+
+# L-System macro
+TexPlay::create_macro(:lsystem) do |x, y, system, options|
+    capture {
+        theta = system.angle
+        turtle_stack = []
+        move_to(x, y)
+        line_length = options[:line_length] || 1
+        
+        system.produce_string(options).each_char do |v|
+                      
+            case v
+            when "F"
+                forward(line_length, true)
+            when "+"
+                turn(theta)
+            when "-"
+                turn(-theta)
+            when "["
+                turtle_stack.push([@turtle_pos.dup, @turtle_angle])
+            when "]"
+                @turtle_pos, @turtle_angle = turtle_stack.pop
+            end
+        end
+    }
+end
+
+# Scaling
+# uses nearest-neighbour
+TexPlay::create_macro(:splice_and_scale) do |img, cx, cy, *options|
+    options = options.first ? options.first : {}
+
+    options = {
+        :color_control => proc do |c1, c2, x, y|
+            factor = options[:factor] || 1
+            factor_x = options[:factor_x] || factor
+            factor_y = options[:factor_y] || factor
+
+            x = factor_x * (x - cx) + cx
+            y = factor_y * (y - cy) + cy
+           
+            rect x, y, x + factor_x, y + factor_y, :color => c2, :fill => true
+            :none
+        end
+    }.merge!(options)
+   
+    splice img, cx, cy, options
+
+    self
+end

data/lib/texplay.rb

@@ -0,0 +1,134 @@
+# (C) John Mair 2009, under the MIT licence
+
+begin
+    require 'rubygems'
+rescue LoadError
+end
+
+# include gosu first
+require 'rbconfig'
+require 'gosu'
+
+module TexPlay
+    TEXPLAY_VERSION = "0.2.7"
+
+    def self::on_setup(&block)
+        raise "need a block" if !block
+        
+        @__init_procs__ ||= []
+        @__init_procs__.push(block)
+    end
+
+    def self::setup(receiver)
+        if @__init_procs__ then
+            @__init_procs__.each do |init_proc|
+                receiver.instance_eval(&init_proc)
+            end
+        end
+    end
+
+    def self::create_blank_image(window, width, height)
+        Gosu::Image.new(window, EmptyImageStub.new(width, height))
+    end
+
+    module Colors
+        Red = [1, 0, 0, 1]
+        Green = [0, 1, 0, 1]
+        Blue = [0, 0, 1, 1]
+        Black = [0, 0, 0, 1]
+        White = [1, 1, 1, 1]
+        Grey = [0.5, 0.5, 0.5, 1]
+        Alpha = [0, 0, 0, 0]
+        Purple = [1, 0, 1, 1]
+        Yellow = [1, 1, 0, 1]
+        Cyan = [0, 1, 1, 1]
+        Orange = [1, 0.5, 0, 1]
+        Brown = [0.39, 0.26, 0.13, 1]
+        Turquoise = [1, 0.6, 0.8, 1]
+        Tyrian = [0.4, 0.007, 0.235, 1]
+    end
+    include Colors
+end
+
+# credit to philomory for this class
+class EmptyImageStub
+    def initialize(w, h)
+        @w, @h = w, h
+    end
+    
+    def to_blob
+        "\0" * @w * @h * 4
+    end
+    
+    def rows
+        @h
+    end
+    
+    def columns
+        @w
+    end
+end
+
+# bring in user-defined extensions to TexPlay
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+begin
+    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+        require "#{direc}/1.9/texplay.#{dlext}"
+    else
+        require "#{direc}/1.8/texplay.#{dlext}"
+    end
+rescue LoadError => e
+    require "#{direc}/texplay.#{dlext}"
+end
+    
+require "#{direc}/texplay-contrib"
+
+# monkey patching the Gosu::Image class to add image manipulation functionality
+module Gosu
+    class Image
+
+        # bring in the TexPlay image manipulation methods
+        include TexPlay
+        
+        class << self 
+            alias_method :original_new, :new
+            
+            def new(*args, &block)
+
+                # invoke old behaviour
+                obj = original_new(*args, &block)
+
+                # refresh the TexPlay image cache
+                if obj.width <= (TexPlay::TP_MAX_QUAD_SIZE - 2) &&
+                        obj.height <= (TexPlay::TP_MAX_QUAD_SIZE - 2) && obj.quad_cached? then
+                    
+                    obj.refresh_cache
+                end
+
+                # run custom setup
+                TexPlay::setup(obj)
+
+                 obj.instance_variable_set(:@__window__, args.first)
+
+                # return the new image
+                obj
+            end
+        end
+        
+        def __window__
+            @__window__
+        end
+    end
+end
+
+# a bug in ruby 1.8.6 rb_eval_string() means i must define this here (rather than in texplay.c)
+class Proc  
+    def __context__
+        eval('self', self.binding)
+    end
+end
+
+
+
+

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: texplay
+version: !ruby/object:Gem::Version 
+  version: 0.2.7
+platform: x86-mswin32
+authors: 
+- John Mair (banisterfiend)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-16 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gosu
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.14
+    version: 
+description: TexPlay is a light-weight image manipulation framework for Ruby and Gosu
+email: jrmair@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.markdown
+- CHANGELOG
+- lib/texplay.rb
+- lib/texplay-contrib.rb
+- ext/texplay/extconf.rb
+- ext/texplay/object2module.h
+- ext/texplay/bindings.h
+- ext/texplay/utils.h
+- ext/texplay/actions.h
+- ext/texplay/compat.h
+- ext/texplay/cache.h
+- ext/texplay/texplay.h
+- ext/texplay/gen_eval.h
+- ext/texplay/texplay.c
+- ext/texplay/actions.c
+- ext/texplay/object2module.c
+- ext/texplay/utils.c
+- ext/texplay/bindings.c
+- ext/texplay/gen_eval.c
+- ext/texplay/cache.c
+- examples/example_dup.rb
+- examples/example_turtle.rb
+- examples/example_color_control.rb
+- examples/example_effect.rb
+- examples/common.rb
+- examples/example_color_transform.rb
+- examples/example_hash_arguments.rb
+- examples/example_gen_eval.rb
+- examples/example_polyline.rb
+- examples/example_fill.rb
+- examples/example_bezier.rb
+- examples/example_simple.rb
+- examples/example_fill_old.rb
+- examples/example_blur.rb
+- examples/example_each.rb
+- examples/example_fluent.rb
+- examples/example_sync.rb
+- examples/example_splice.rb
+- examples/example_alpha_blend.rb
+- examples/example_melt.rb
+- examples/example_lsystem.rb
+- examples/example_scale.rb
+- examples/media/sand1.png
+- examples/media/rose.bmp
+- examples/media/maria.png
+- examples/media/sunset.png
+- examples/media/texplay.png
+- examples/media/gosu.png
+- examples/media/logo.png
+- examples/media/empty2.png
+- lib/1.8/texplay.so
+- lib/1.9/texplay.so
+has_rdoc: false
+homepage: http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TexPlay is a light-weight image manipulation framework for Ruby and Gosu
+test_files: []
+