texplay 0.2.721-i386-mingw32

data/examples/example_fluent.rb

@@ -0,0 +1,31 @@
+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}/sunset.png")
+        @img.rect 0,0, @img.width - 1, @img.height - 1
+
+        # test the fluent interface
+        @img.
+            line(0, 0, 1024, 1024).
+            circle(20, 20, 50).
+            rect 30, 30, 100, 100
+    end
+    
+    def draw
+        x = @img.width * rand
+        y = @img.height * rand
+        
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_gen_eval.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
+
+        @width = @img.width
+        @height = @img.height
+
+        # turn alpha blending and filling on
+        @img.set_options :alpha_blend => true, :fill => true
+    end
+    
+    def draw
+        
+        # Gen_eval lets us use local instance vars within the block
+        # even though the block appears to be getting instance_eval'd
+        # for more information see gen_eval.c and object2module.c
+        @img.paint {
+            rect @width * rand, @height * rand, @width * rand, @height * rand,
+            :color => [rand, rand ,rand, rand]
+        }  
+        
+        @img.draw 100, 50,1
+    end
+end
+
+w = W.new
+w.show
+        

data/examples/example_hash_arguments.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
+        @tp = Gosu::Image.new(self, "#{Common::MEDIA}/texplay.png")
+
+
+        # put a border on the image
+        @img.rect 0,0, @img.width - 1, @img.height - 1
+
+        # it can be annoying having to specify a bunch of :hash_arguments for every action
+        # here is how you specify common hash args that all actions will use (in the same image)
+
+        # all actions that respond to 'thickness' use a thickness of 8 pixels
+        # also set the color to random
+        @img.set_options :thickness => 8, :color => :rand
+
+        @img.rect 100, 100, 200, 200, :fill => false
+
+        # NOTE: for ngon, the parameters are as follows: x, y, radius, num_sides
+        @img.ngon 400, 400, 40, 3
+
+        # NOTE: the defaults can also be overidden:
+        @img.ngon 400, 200, 90, 6, :thickness => 1
+
+        # you can also delete the defaults
+        @img.delete_options
+
+        # this action will no longer have any default values
+        @img.ngon 200, 400, 90, 10
+    end
+    
+    def draw
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_lsystem.rb

@@ -0,0 +1,61 @@
+require 'common'
+require 'gosu'
+
+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.set_options :color => :rand
+        @img.lsystem(400, 150, Koch, :order => 8, :line_length => 6)
+        #@img.save("dragon.jpg")
+    end
+
+    def draw
+        @img.draw(100,0,1)
+    end
+end
+
+w = W.new
+w.show

data/examples/example_melt.rb

@@ -0,0 +1,27 @@
+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}/sunset.png")
+    end
+    
+    def draw
+        x = (@img.width - 100/2) * rand 
+        y = (@img.height - 100/2) * rand 
+
+        @img.splice @img, x, y + 1, :crop => [x, y, x + 100, y + 100]
+
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_polyline.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
+
+        # put a border on the image
+        @img.rect 0,0, @img.width - 1, @img.height - 1
+
+        points = []
+
+        # NOTE: TexPlay also accepts points. a 'point' is any object that responds to 'x' or 'y'
+        10.times {
+            p = TexPlay::TPPoint.new
+            p.x = @img.width * rand
+            p.y = @img.height * rand
+
+            points << p
+        }
+
+
+        # what if we want to turn a polyline into a polygon?
+        @img.polyline points, :closed => true, :color => :blue
+        @img.polyline points, :color => :red
+    end
+    
+    def draw
+
+        # NOTE: (when viewing) the blue line is the extra line added to close the polygon,
+        # red lines are original polyline
+        @img.draw 100, 50,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/examples/example_simple.rb

@@ -0,0 +1,38 @@
+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}/empty2.png")
+        @gosu = Gosu::Image.new(self, "#{Common::MEDIA}/gosu.png")
+
+        # put a border on the image
+        @img.rect 0,0, @img.width - 1, @img.height - 1
+
+        # perform some simple drawing actions 
+        @img.line 0,0, @img.width - 1, @img.height - 1, :color => :yellow
+        @img.circle 400, 100, 40, :fill => true, :color => [rand, rand, rand, 1]
+        @img.rect 200, 300, 300, 400, :fill => true, :color => :red
+
+        @img.ngon 400,300,50, 5, :start_angle => 90
+        @img.ngon 300,300,50, 5, :start_angle => 45
+
+        # NOTE: chroma_key means NOT to splice in that color (pixels with that color are skipped)
+        # (chroma_key_not does the opposite, it skips pixels that do NOT have that color)
+        @img.splice @gosu, 210, 330, :chroma_key => :alpha
+    end
+    
+    def draw
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_splice.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/texplay.png")
+        @gosu = Gosu::Image.new(self, "#{Common::MEDIA}/gosu.png")
+
+        @img.splice @gosu, 140,20, :alpha_blend => true
+        @img.rect 140,20, 160, 180, :color => [1,1,1,0.5], :alpha_blend => true, :fill => true
+
+        @img.splice @gosu, 50,20, :chroma_key => :alpha
+    end
+
+    def draw
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_sync.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
+
+        # sets the 'global' color for all actions in this image
+        @img.color :red
+
+        # let's draw the circle without syncing it to gl
+        @img.circle 100, 100, 50, :fill => true, :sync_mode => :no_sync
+
+        # now let's sync half of it to gl
+        @img.force_sync [100, 50, 150, 150]
+
+        # let's draw some lazy shapes
+        @img.set_options :sync_mode => :lazy_sync
+        
+        @img.ngon 200, 300, 40, 5, :color => :red
+        @img.ngon 280, 300, 40, 6, :color => :green
+        @img.ngon 360, 300, 40, 7, :color => :blue
+
+        # now let's sync the lazy shapes to gl
+        @img.paint
+        
+        # NOTE: the lazy drawing (above) is identical to using the following paint block
+        # @img.paint {
+        #     ngon 200, 300, 50, 5
+        #     ...etc
+        # }
+
+        # end lazy drawing mode
+        @img.delete_options
+        
+        # the default sync mode is eager_sync
+        # in this mode actions are drawn and sync'd immediately
+        # NOTE: TexPlay only syncs the part of the image that changed to gl
+        @img.ngon 440, 300, 40, 8, :color => :tyrian
+
+        # paint blocks can also accept a sync_mode parameter
+        # NOTE: the line below will not be visible until you
+        # explictly sync it to gl; probably using @img.force_sync
+        @img.paint(:sync_mode => :no_sync) {
+            line 0, 0, @img.width, @img.height
+        }
+    end
+    
+    def draw
+        
+        @img.draw 100, 50,1
+    end
+end
+
+w = W.new
+w.show
+        

data/examples/example_turtle.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
+
+        # put a border on the image
+        @img.rect 0, 0, @img.width - 1, @img.height - 1
+
+        @length = 0
+    end
+
+    
+    # NOTE: turtle is currently written in Ruby so is very slow, look at texplay-contrib.rb for source code.
+    def draw
+
+        # NOTE: putting actions in paint block means they are only sync'd to gl at end of block.
+        # compare to calling an action directly (on an @img) where it is sync'd to gl immediately
+        
+        @img.paint {
+
+            # a 2nd arg of 'true' means to show the turtle
+            forward(@length, true, :color => :red)
+            turn(89.5)
+            @length += 2
+        }
+
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_weird.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+  def initialize
+    super(1024, 768, false, 20)
+    @img = Gosu::Image.new(self, "#{Common::MEDIA}/bird.png")
+    @green = Gosu::Image.new(self, "#{Common::MEDIA}/gob.png")
+    ###    @img = Gosu::Image.new(self, "gob.png")
+    #@img = TexPlay.create_image(self, 500, 500).fill(0,0, :color => :red)
+
+    @img.splice @green, 0, 0, :alpha_blend => true
+    puts @img.get_pixel 15, 15
+    #        @img.rect 0, 0, @img.width, @img.height, :texture => @gob, :fill => true, :alpha_blend => true
+
+  end
+
+  def draw
+    @img.draw 100, 50,1
+  end
+  
+end
+
+
+w = W.new
+w.show
+

data/lib/texplay/version.rb

@@ -0,0 +1,3 @@
+module TexPlay
+    VERSION = "0.2.721"
+end

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