texplay 0.2.0

data/examples/example_gen_eval.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 769, 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, 769, 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_melt.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'common'
+require 'gosu'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 769, 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, 769, 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_simple.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'common'
+require 'gosu'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 769, 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
+
+        # 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,37 @@
+require 'rubygems'
+require 'common'
+require 'texplay'
+
+
+class W < Gosu::Window
+    def initialize
+        super(1024, 769, false, 20)
+        @img = Gosu::Image.new(self, "#{Common::MEDIA}/texplay.png")
+        @gosu = Gosu::Image.new(self, "#{Common::MEDIA}/gosu.png")
+
+#        @img.rect 20,20,100, 100, :fill => true, :texture => @gosu, :alpha_blend => true
+#        @img.rect 20,20, 100, 100, :color => [1, 0, 0, 0.1], :alpha_blend => true, :fill => true 
+        @img.splice @gosu, 20,20, :color_control => { :add => [0.5, 0.5, 0.5, 0.5]}
+        @img.splice @gosu, 100,20, :alpha_blend => true,
+        :color_control => proc { |c1, c2, x, y|
+            @img.set_pixel x + rand, y + 2 *rand, :color => c2
+            :none
+        }
+            
+        
+            
+    end
+
+    
+    # NOTE: turtle is currently written in Ruby so is very slow, look at texplay-contrib.rb for source code.
+    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, 769, 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, 769, 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/specs.rb

@@ -0,0 +1,240 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+rquire 'common'
+require 'gosu'
+require 'texplay'
+
+class MyWindow < Gosu::Window
+    def initialize
+        super(1024, 769, false, 20)
+    end
+end
+
+W = MyWindow.new
+
+class MyTest < Test::Unit::TestCase
+    
+    context "TexPlay Bug Eradicator" do
+        setup do
+            @img = Gosu::Image.new(W, "#{Common::MEDIA}/empty2.png")
+            @gosu = Gosu::Image.new(W, "#{Common::MEDIA}/gosu.png")
+            @points = []
+        end
+        
+        should "not have gaps in polyline from 2nd to 3rd point" do
+            @img.polyline 0, 0, 40, 40, 38, 1024
+        end
+
+        should "not freeze when using floodfill and a color_control block" do
+            # rectangle to fill
+            @img.rect 40, 40, 100, 100
+
+            # works fine WITHOUT color_control block, wtf?
+            @img.fill 90, 90, :color_control => proc { |c, x, y| :red }
+        end
+
+        # this problem is due to inability to calculate factorials > 15
+        should "beziers should not CLUSTER around top left hand corner when num random points > 15" do
+            15.times { 
+                p = [(@img.width * rand()), (@img.height * rand())]
+                @points += p
+            }
+            @img.paint { 
+                bezier @points
+            }
+        end
+
+        # fixed
+        should "make composite actions imitate primitives, i.e random color does not trickle to sub actions" do
+            # comprised of filled circles
+            @img.line 300, 300, 500, 500, :color => :random, :thickness => 5
+
+            # comprised of lines
+            @img.circle 40, 300, 10, :color => :random, :fill => true
+        end
+
+        should "this crashes the stack after a little while" do
+            l = ->() { 2 * @img.width * rand - @img.width / 2 }
+
+            points = []
+            10.times {
+                points += [l.(), l.()]
+            }
+
+            @img.bezier points, :closed => true
+            
+            @img.fill l.(), l.(), :color => :random#, :scan => true
+            
+        end
+
+        should "fill crashes when using alpha_blend => true" do
+            @img.fill 250, 487, :texture => @tp, :scan => true, :alpha_blend => true
+        end
+
+        # FIXED ! simply did not initialize TexPlay::TPPoint, duh!
+        should "not ERROR about finding ivar @turtle_pos, SUPPOSED to be eval'd in context of @img" do
+            @img.paint {
+                forward(50, true, :color => :red)
+                turn(@length)
+            }
+        end
+    end
+
+    context "effects" do
+        setup do
+            @length = 1
+            @img = Gosu::Image.new(W, "empty2.png")
+        end
+
+        
+        should "this is just a cool effect using turtle and random fill" do
+            @img.paint { 
+                forward(@length, true, :color => :red)
+                turn(170)
+                @length += 5
+            }
+            @img.fill (@img.width * rand), (@img.height * rand), :color => :random
+        end
+
+        should "another cool effect using turtle" do
+            @length = 0
+            @img.paint {
+                forward(20, true, :color => red)
+                turn(@length)
+                @length += 10
+            }
+        end
+        
+        should "draw a circle with a rough edge utilizing color_control block and :none (no color)" do
+            @img.circle 200,200, 100,
+            :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)
+            }
+        end
+
+        context "examples" do
+            setup do
+                @img = Gosu::Image.new(W, "empty2.png")
+                @tp = Gosu::Image.new(W, "texplay.png")
+            end
+
+            should "draw closed polyline" do
+                @img.polyline 0,0 , 40, 40, 400, 300, 100, 20, :closed => true, :thickness => 1
+            end
+
+            should "texture fill an area using :texture hash arg" do
+                @img.polyline 30, 30, 100, 100, 200, 76, 300, 9, 50, 200, :color => :random, :closed => true
+                @img.fill 42, 70, :texture => @tp
+            end
+
+            should "texture fill an area using color_control" do
+                @img.polyline 30, 30, 100, 100, 200, 76, 300, 9, 50, 200, :color => :random, :closed => true
+                @img.fill 42, 70, :color_control => proc { |c, x, y|
+                    @tp.get_pixel(x % @tp.width, y % @tp.height)
+                }
+            end
+
+            should "average the color between the texture image and the background image" do
+                @img.rect 10, 10, 100, 100, :filled => true, :texture => @tp,
+                :color_control => proc { |c1, c2|
+                    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
+                }
+            end
+
+            should "force a texture to alpha blend even when it has a full opacity" do
+                @img.circle 100, 100, 50, :alpha_blend => true, :fill => true, :texture => @gosu,
+                :color_control => proc { |c, c1|
+                    c1[3] = 0.1
+                    c1
+                }
+            end
+
+            should "draw lines with thickness, using color_control block" do
+                x1 = @img.width * rand
+                y1 = @img.height * rand
+                x2 = @img.width * rand
+                y2 = @img.height * rand
+
+                # thickness of lines
+                t = 30
+                
+                @img.paint {
+                    line x1, y1, x2, y2, :color_control => proc {  |c, x, y|
+
+                        # vectors
+                        vx = x2 - x1
+                        vy = y2 - y1
+
+                        # unit vectors
+                        uvx = vx / Math::hypot(vx, vy)
+                        uvy = vy / Math::hypot(vx, vy)
+
+                        # draw lines at perpendicular
+                        line x, y, x - (uvy*t), y + (uvx*t), :color => :red
+
+                        # original line is white
+                        :white
+                    }
+                }
+
+                
+            end
+
+            should "do an alternative way to thick draw lines" do
+                x1 = @img.width * rand
+                y1 = @img.height * rand
+                x2 = @img.width * rand
+                y2 = @img.height * rand
+
+                t = 30
+
+                vx = x2 - x1
+                vy = y2 - y1
+
+                uvx = vx / Math::hypot(vx, vy)
+                uvy = vy / Math::hypot(vx, vy)
+                
+                @img.paint {
+                    line x1, y1, x2, y2
+                    t.times { |i|
+                        line x1 - (uvy * i), y1 + (uvx * i), x2 - (uvy * i), y2 + (uvx*t), :color => :random
+                    }
+                }
+
+            end
+
+            
+
+
+            context "bezier context" do
+                setup do
+                    @points = []
+                    @p = TexPlay::TPPoint.new
+                    @p.x, @p.y = 0, 0
+                    @points << @p
+                    (0..@img.width).step(80) do |x|
+                        @p = TexPlay::TPPoint.new
+                        @p.x = x
+                        @p.y = rand(@img.height) * 2 - @img.height / 2
+                        @points << @p
+                    end
+                    @p = TexPlay::TPPoint.new
+                    @p.x, @p.y = @img.width, 0
+                    @points << @p
+                end
+
+                should "draw a bezier curve that spans the image width" do
+                    @img.bezier(*@points)
+                end
+                
+            end
+        end        
+    end
+