texplay 0.2.4-x86-mswin32-60 → 0.2.5-x86-mswin32-60

data/examples/example_lsystem.rb

@@ -1,51 +1,59 @@
-require 'common'
-require 'texplay'
-
-Dragon = TexPlay::LSystem.new do
-    rule "F" => "F"
-    rule "X" => "X+YF+"
-    rule "Y" => "-FX-Y"
-    angle 90
-
-    atom "FX"
-end
-
-Bush1 = TexPlay::LSystem.new do
-    rule "F" => "F[-F]F[+F][F]"
-    
-    angle 20
-    atom "F"
-end
-
-Bush2 = TexPlay::LSystem.new do
-    rule "F" => "FF"
-    rule "X" => "F[+X]F[-X]+X"
-    
-    angle 20
-    atom "X"
-end
-
-Bush3 = TexPlay::LSystem.new do
-    rule "F" => "FF"
-    rule "X" => "F-[[X]+X]+F[+FX]-X"
-    
-    angle 22.5
-    atom "X"
-end
-
-
-
-class W < Gosu::Window
-    def initialize
-        super(1024, 768, false, 20)
-        @img = TexPlay::create_blank_image(self, 500, 500)
-        @img.lsystem(0, 250, Bush2, :order => 5, :line_length => 5)
-    end
-
-    def draw
-        @img.draw(100,0,1)
-    end
-end
-
-w = W.new
-w.show
+require 'common'
+require 'texplay'
+
+Dragon = TexPlay::LSystem.new do
+    rule "F" => "F"
+    rule "X" => "X+YF+"
+    rule "Y" => "-FX-Y"
+    angle 90
+
+    atom "FX"
+end
+
+Koch = TexPlay::LSystem.new do
+    rule "F" => "F-F++F-F"
+
+    angle 60
+
+    atom "F"
+end
+
+Bush1 = TexPlay::LSystem.new do
+    rule "F" => "F[-F]F[+F][F]"
+    
+    angle 20
+    atom "F"
+end
+
+Bush2 = TexPlay::LSystem.new do
+    rule "F" => "FF"
+    rule "X" => "F[+X]F[-X]+X"
+    
+    angle 20
+    atom "X"
+end
+
+Bush3 = TexPlay::LSystem.new do
+    rule "F" => "FF"
+    rule "X" => "F-[[X]+X]+F[+FX]-X"
+    
+    angle 22.5
+    atom "X"
+end
+
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = TexPlay::create_blank_image(self, 500, 500)
+        @img.lsystem(250, 250, Koch, :order => 8, :line_length => 10)
+    end
+
+    def draw
+        @img.draw(100,0,1)
+    end
+end
+
+w = W.new
+w.show

data/examples/example_scale.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'common'
+require 'gosu'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/logo.png")
+        @img2 = TexPlay::create_blank_image(self, 500, 500)
+
+        @img2.splice_and_scale @img, 0, 50, :factor => 2
+        @img2.splice @img, 0, 200 
+    end
+    
+    def draw
+        x = @img.width * rand
+        y = @img.height * rand
+
+        @img2.draw 100, 100,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/{src → ext/texplay}/actions.c

@@ -787,8 +787,8 @@ bezier_do_action(VALUE points, texture_info * tex, VALUE hash_arg, sync sync_mod
         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",
+    if(num_point_pairs > 17)
+        rb_raise(rb_eArgError, "too many points for bezier curve. 17 points is current maximum. got %d\n",
                  num_point_pairs);
 
     /* get the first point */

data/{src → ext/texplay}/cache.c

@@ -30,7 +30,7 @@ cache_create_entry(int 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);
+    /*  glGetIntegerv(GL_TEXTURE_BINDING_2D, &saved_tname); */
 
     /* opengl initialization code */
     glEnable(GL_TEXTURE_2D);
@@ -54,7 +54,10 @@ cache_create_entry(int tname) {
     cache.len++;
 
     /* restore saved texture binding */
-    glBindTexture(GL_TEXTURE_2D, saved_tname);
+    /* glBindTexture(GL_TEXTURE_2D, saved_tname); */
+
+    glDisable(GL_TEXTURE_2D);
+
 
     return &cache.entry[new_element];
 }

data/{src → ext/texplay}/extconf.rb

@@ -11,11 +11,11 @@ elsif RUBY_PLATFORM =~ /darwin/
     $CPPFLAGS += " -I/System/Library/Frameworks/GLUT.framework/Headers"
 
 # windows    
-else
+else 
     exit unless have_library("glut32") 
 end
 
 # 1.9 compatibility
 $CPPFLAGS += " -DRUBY_19" if RUBY_VERSION =~ /1.9/
 
-create_makefile('ctexplay')
+create_makefile('texplay')

data/{src → ext/texplay}/texplay.c

@@ -19,7 +19,7 @@
 static VALUE m_init_TPPoint(int argc, VALUE * argv, VALUE self);
 
 void
-Init_ctexplay() {
+Init_texplay() {
 
     VALUE jm_Module = rb_define_module("TexPlay");
     VALUE TPPoint = rb_define_class_under(jm_Module, "TPPoint", rb_cObject);

data/{src → ext/texplay}/utils.c

@@ -793,6 +793,8 @@ sync_to_gl(int tex_name, int x_offset, int y_offset, int width, int height, void
     /* sync subtexture */
     glTexSubImage2D(GL_TEXTURE_2D, 0, x_offset, y_offset, width, height,
                     GL_RGBA, GL_FLOAT, sub);
+
+    glDisable(GL_TEXTURE_2D);
 }
 
 void
@@ -948,21 +950,22 @@ fact(int n)
 unsigned
 comb(int n, int r)
 {
-    double temp = fact(n) / (fact(r) * fact(n - r));
-    return temp;
-    /*    if(r > (n / 2))
+    /* double temp = fact(n) / (fact(r) * fact(n - r)); */
+    /* return temp; */
+
+    /* nCr is symmetrical about n / 2 */
+    if(r > (n / 2))
         r = n - r;
     
     return perm(n, r) / fact(r);
-    */
 }
 
 unsigned
 perm(int n, int r)
 {
-    int val = n;
+    int val = 1;
     int i;
-    for(i = n - 1; i > (n - r); i--)
+    for(i = n; i > (n - r); i--)
         val *= i;
 
     return val;
@@ -971,6 +974,6 @@ perm(int n, int r)
 double
 bernstein(int n, int k, float u)
 {
-    double temp = comb(n, k) * pow(u, k) * power(1 - u, n - k);
+    double temp = comb(n, k) * pow(u, k) * pow(1 - u, n - k);
     return temp;
 }

data/lib/texplay-contrib.rb

@@ -1,149 +1,171 @@
-begin
-    require 'rubygems'
-rescue LoadError
-end
-
-require 'texplay'
-
-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
-
-# monkeypatches to TexPlay class
-module TexPlay
-    class 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
-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
+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