texplay 0.2.720-i386-mswin32 → 0.2.721-i386-mswin32

data/Rakefile

@@ -28,8 +28,7 @@ specification = Gem::Specification.new do |s|
     s.extensions = ["ext/texplay/extconf.rb"]
     s.files =  ["Rakefile", "README.markdown", "CHANGELOG", 
                 "lib/texplay.rb", "lib/texplay-contrib.rb", "lib/texplay/version.rb"] +
-        FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c", "examples/*.rb",
-                 "examples/media/*"].to_a 
+        FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c", "examples/*.rb", "examples/media/*"].to_a 
 end
 
 Rake::ExtensionTask.new('texplay', specification)  do |ext|
@@ -57,9 +56,8 @@ end
 
     s.files =  ["Rakefile", "README.markdown", "CHANGELOG", 
                 "lib/texplay.rb", "lib/texplay-contrib.rb", "lib/texplay/version.rb", "lib/1.8/texplay.so",
-                "lib/1.9/texplay.so"]
-    FileList["examples/*.rb",
-             "examples/media/*"].to_a
+                "lib/1.9/texplay.so"] +
+    FileList["examples/*.rb", "examples/media/*"].to_a
 end
   
 Rake::GemPackageTask.new(specification) do |package|

data/examples/common.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.push(File.dirname(__FILE__) + '/../lib/')
+
+require 'rubygems'
+require 'texplay'
+
+module Common
+    MEDIA = File.dirname(__FILE__) + '/media'
+end

data/examples/example_alpha_blend.rb

@@ -0,0 +1,31 @@
+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
+
+        @img.rect 1, 1, @img.width - 2, @img.height - 2, :fill => true, :texture => @tp
+
+        # NOTE: the current implementation of alpha blending is a bit tempermental, i need to think it
+        # through a bit more...
+        @img.rect 100, 100, 300, 300, :color => [1, 1, 1, 0.8], :alpha_blend => true, :fill => true
+    end
+    
+    def draw
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_bezier.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = TexPlay::create_blank_image(self, 500, 500)
+
+        # 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'
+        # NOTE: current maximum points for a bezier is 13
+        (0..@img.width + 100).step(40) { |x|
+            p = TexPlay::TPPoint.new
+            p.x = x
+            p.y = @img.height * rand
+
+            points << p
+        }
+
+        # making the bezier 
+        @img.bezier points, :color => :red
+
+        # NOTE: can 'close' a bezier curve too (as with polylines)
+    end
+    
+    def draw
+
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_color_control.rb

@@ -0,0 +1,69 @@
+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")
+        @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
+
+        # When using color_control the pixel the draw action is currently manipulating is yielded
+        # to the proc. This gives you pixel-level control over the drawing.
+        # (NOTE: the return value of the proc is used as the pixel color, so it should be a 4 element array or
+        # a valid color symbol)
+        
+        # color_control accepts procs of 4 types:
+        # arity of 0: nothing is yielded and color is set by return value of block
+        # arity of 1: just the destination pixel color is yielded
+        # arity of 2: both the destination and the source pixel colors are yielded (in that order)
+        # arity of 3: the destination pixel color is yielded along with the x and y coords of the current pixel
+        # arity of 4: both the destination and the source pixel colours are yielded as well as the x and y vals
+
+        # just drawing an area to fill
+        @img.polyline [30, 30, 100, 100, 200, 76, 300, 9, 50, 200], :color => :random, :closed => true
+
+        # below we are 'faking' a texture fill using color_control
+        @img.fill 42, 70, :color_control => proc { |c, x, y|
+            @tp.get_pixel(x % @tp.width, y % @tp.height)
+        }
+
+        # merging two images together
+        @img.rect 100, 200, 400, 300, :fill => true, :texture => @gosu,
+        :color_control => proc { |c1, c2, x, y|
+            c1 = @tp.get_pixel(x % @tp.width, y % @tp.height)
+            c1[0] = (c1[0] + c2[0]) / 2
+            c1[1] = (c1[1] + c2[1]) / 2
+            c1[2] = (c1[2] + c2[2]) / 2
+            c1[3] = 1
+            c1
+        }
+
+        # we can even use color_control just for the use of the (x, y) values.
+        # here we simply use the x, y values to make our own circle with a rough edge
+        @img.circle 200,400, 70,
+        :color_control => proc { |c,x,y|
+            @img.pixel(x + (rand(4) - 2), y + (rand(4) - 2)) 
+            :none   # this ensures that the 'actual' circle isn't drawn, instead its coordinates are
+                    # simply utilized to draw a ragged edge of another circle (using @img.pixel)
+        }
+
+        # this just fills a rect with random colours
+        @img.rect 400, 400, 470, 470, :fill => true, :color_control => proc { :rand }
+    end
+
+    def draw
+
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_color_transform.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'common'
+require 'gosu'
+require 'texplay'
+#require 'devil/gosu'
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/sunset.png")
+        @x = 100
+        @y = 100
+        
+        @x2 = 400
+        @y2 = 100
+        @rad = 50
+        @s = true
+
+        @copy = TexPlay.create_blank_image(self, @rad * 2 + 1, @rad * 2 + 1)
+        @copy2 = TexPlay.create_blank_image(self, @rad * 2 + 1, @rad * 2 + 1)
+    end
+    
+    def draw
+
+
+        @x += 1
+        @y += 1
+
+        @x2 -= 1
+        @y2 += 1
+
+
+        @copy2.splice @img, 0, 0, :crop => [@x2 - @rad, @y2 - @rad, @x2 + @rad, @y2 + @rad]
+        @copy.splice @img, 0, 0, :crop => [@x - @rad, @y - @rad, @x + @rad, @y + @rad]
+        @img.
+            circle @x, @y, @rad, :fill => true,
+        :color_control => { :mult => [1.0, 0.5, 0.5, 1] }
+
+         #    circle @x2, @y2, @rad, :fill => true,
+#             :color_control => { :mult => [0.3, 0.9, 0.3, 1] }
+        
+
+#        @img.force_sync [0,0, @img.width, @img.height]
+
+        @img.draw 10, 10,1
+
+        if button_down?(Gosu::KbEscape)
+            IL.Enable(IL::ORIGIN_SET)
+            IL.OriginFunc(IL::ORIGIN_UPPER_LEFT)
+#            screenshot.crop(0,0, 500, 500).save("screenshot.jpg").free
+            exit
+        end  
+        
+    end
+
+    def update
+        @img.splice @copy, @x - @rad, @y - @rad if !@s
+        @img.splice @copy2, @x2 - @rad, @y2 - @rad if !@s
+        @s = nil if @s
+
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_dup.rb

@@ -0,0 +1,75 @@
+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
+
+        # testing Gosu::Image#dup
+        # adding an ivar
+        @img.instance_variable_set(:@horse, :love)
+
+        # adding a method on the singleton
+        class << @img
+            def little
+                :little
+            end
+        end
+        
+        # clone the image.
+        # NB #clone also copies singleton
+        @bunk = @img.clone
+
+        # should output :love
+        puts @bunk.instance_variable_get(:@horse)
+
+        # should output :little
+        puts @bunk.little
+
+        # add a red line to the copy to identify it
+        #@bunk.line 0, 0, 1024, 1024, :color => :red
+
+        @bunk.each(:region =>[200,200,350,350]) { |c,x,y|
+
+            num_pixels = 0
+            total = [0, 0, 0, 0]
+            @bunk.circle x, y, 2,
+            :color_control => proc { |v|
+                if v
+                    total[0] += v[0]
+                    total[1] += v[1]
+                    total[2] += v[2]
+                    total[3] += v[3]
+
+                    num_pixels += 1
+                end
+                :none
+            }
+
+            c[0] = total[0] / num_pixels.to_f
+            c[1] = total[1] / num_pixels.to_f
+            c[2] = total[2] / num_pixels.to_f
+            c[3] = total[3] / num_pixels.to_f
+        }
+
+    end
+    
+    def draw
+        x = @img.width * rand
+        y = @img.height * rand
+
+        @img.draw 100, 50,1
+        @bunk.draw 500, 300,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_each.rb

@@ -0,0 +1,42 @@
+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")
+
+        # each can accept a block of two types of arity:
+        # arity 1 - yields just the pixel color
+        # arity 3 - yield the pixel color, and the x and y
+
+        # max out the blue component of every pixel
+        @img.each { |v| v[2] = 1 }
+
+        # a gradient from 0 red to 1 red
+        @img.each(:region => [100, 100, 200, 200]) do |c, x, y|
+            c[0] = (x - 100) / 100.0
+        end
+
+        # another gradient, this time blocking out everything except red (and alpha)
+        @img.each(:region => [100, 250, 200, 350]) do |c, x, y|
+            c[0] = (x - 100) / 100.0
+            c[1] = 0
+            c[2] = 0
+        end
+    end
+    
+    def draw
+    
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_effect.rb

@@ -0,0 +1,35 @@
+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
+    
+    def draw
+
+        # quite a cool effect, very slow of course, because it's using turtle and fill
+        @img.paint { 
+            forward(@length, true, :color => :red)
+            turn(170)
+            @length += 5
+            fill (@img.width * rand), (@img.height * rand), :color => :random, :glow => true
+        }
+
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+

data/examples/example_fill.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 768, false, 20)
+        @img = TexPlay::create_blank_image(self, 1022, 800)
+        @tp = Gosu::Image.new(self, "#{Common::MEDIA}/texplay.png")
+        @gosu = Gosu::Image.new(self, "#{Common::MEDIA}/sand1.png")
+
+        points = []
+
+        # NOTE: TexPlay also accepts points. a 'point' is any object that responds to 'x' or y
+        # NOTE: current maximum points for a bezier is 13
+        (0..@img.width + 90).step(185) { |x|
+            p = TexPlay::TPPoint.new
+            p.x = x
+            p.y = @img.height * rand
+
+            points << p
+        }
+
+        @img.bezier points
+
+        # NOTE: the :texture hash argument works on ALL drawing actions; not just fills
+        @img.fill 300, 650, :texture => @gosu
+
+        # let's demonstrate by drawing a circle using the gosu.png texture
+        # NOTE: :texture even works on lines, boxes, polylines, beziers etc. 
+        @img.circle 400, 50, 40, :fill => true, :texture => @tp
+    end
+    
+    def draw
+        @img.draw 10, 10,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

data/examples/example_fill_old.rb

@@ -0,0 +1,49 @@
+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")
+        @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
+
+        points = []
+
+        # NOTE: TexPlay also accepts points. a 'point' is any object that responds to 'x' or 'y'
+        # NOTE: current maximum points for a bezier is 13
+        (0..@img.width).step(50) { |x|
+            p = TexPlay::TPPoint.new
+            p.x = x
+            p.y = @img.height * rand
+
+            points << p
+        }
+
+        @img.bezier points, :color => :white
+
+
+        # NOTE: the :texture hash argument works on ALL drawing actions; not just fills
+        @img.fill 300, 480, :texture => @tp
+
+        # let's demonstrate by drawing a circle using the gosu.png texture
+        # NOTE: :texture even works on lines, boxes, polylines, beziers etc. 
+        @img.circle 400, 50, 40, :fill => true, :texture => @gosu
+        
+    end
+    
+    def draw
+
+        @img.draw 100, 50,1
+    end
+    
+end
+
+
+w = W.new
+w.show
+        

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

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

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: texplay
 version: !ruby/object:Gem::Version 
-  version: 0.2.720
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 721
+  version: 0.2.721
 platform: i386-mswin32
 authors: 
 - John Mair (banisterfiend)
@@ -14,14 +19,18 @@ default_executable:
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: gosu
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - 14
         version: 0.7.14
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: TexPlay is a light-weight image manipulation framework for Ruby and Gosu
 email: jrmair@gmail.com
 executables: []
@@ -39,6 +48,39 @@ files:
 - lib/texplay/version.rb
 - lib/1.8/texplay.so
 - lib/1.9/texplay.so
+- examples/common.rb
+- examples/example_alpha_blend.rb
+- examples/example_bezier.rb
+- examples/example_color_control.rb
+- examples/example_color_transform.rb
+- examples/example_dup.rb
+- examples/example_each.rb
+- examples/example_effect.rb
+- examples/example_fill.rb
+- examples/example_fill_old.rb
+- examples/example_fluent.rb
+- examples/example_gen_eval.rb
+- examples/example_hash_arguments.rb
+- examples/example_lsystem.rb
+- examples/example_melt.rb
+- examples/example_polyline.rb
+- examples/example_scale.rb
+- examples/example_simple.rb
+- examples/example_splice.rb
+- examples/example_sync.rb
+- examples/example_turtle.rb
+- examples/example_weird.rb
+- examples/media/bird.png
+- examples/media/empty2.png
+- examples/media/gob.png
+- examples/media/gosu.png
+- examples/media/green.png
+- examples/media/logo.png
+- examples/media/maria.png
+- examples/media/rose.bmp
+- examples/media/sand1.png
+- examples/media/sunset.png
+- examples/media/texplay.png
 has_rdoc: true
 homepage: http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/
 licenses: []
@@ -52,18 +94,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: TexPlay is a light-weight image manipulation framework for Ruby and Gosu