texplay 0.2.1-x86-mswin32-60 → 0.2.2-x86-mswin32-60

data/README

@@ -1,21 +0,0 @@
-INSTRUCTIONS 
-
-TexPlay version 0.2.1
-
-To compile TexPlay, ensure you are in the directory with the Rakefile and type:
-=> rake
-OR
-=> rake19  (assuming this is the name of your 1.9.1 version of rake)
-
-!!NB!! be sure to run the version of rake that corresponds to the ruby version you wish to use! on my system I use rake19 for ruby 1.9.1!!
-
-If all goes well, run the example programs:
-=> cd examples
-=> ruby example_melt.rb
-=> ruby example_simple.rb
-=> ..etc
-
-*like any gosu application, gosu.so must be in the current directory (or the gosu gem installed) when running the examples.
-
-Enjoy!
-(note that TexPlay has only been tested on 32 bit linux systems and WindowsXP using VS 6.0)

data/examples/basic.rb

@@ -1,48 +0,0 @@
-
-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")
-        @img.rect 0,0, @img.width - 1, @img.height - 1
-
-        @img.instance_variable_set(:@horse, :love)
-        class << @img
-            def little
-                :little
-            end
-        end
-        @bunk = @img.clone
-        puts @bunk.instance_variable_get(:@horse)
-        puts @bunk.little
-    end
-    
-    def draw
-        x = @img.width * rand
-        y = @img.height * rand
-
-        @img.
-            line(0, 0, 1024, 1024).
-            circle(20, 20, 50).
-            rect 30, 30, 100, 100
-        
-        @img.draw 100, 50,1
-        @bunk.draw 500, 300,1
-        @bunk.line 0, 0, 1024, 1024, :color => :red
-
-        
-
-        @bunk.pixel x, y, :color => :none
-    end
-    
-end
-
-
-w = W.new
-w.show
-        

data/examples/basic2.rb

@@ -1,37 +0,0 @@
-require 'rubygems'
-require 'common'
-require 'gosu'
-require 'texplay'
-
-class Proc
-    def __context__
-        eval('self', self.binding)
-    end
-end
-
-class W < Gosu::Window
-    def initialize
-        super(1024, 769, false, 20)
-        @img = Gosu::Image.new(self, "#{Common::MEDIA}/texplay.png")
-    end
-
-    def trick
-        @img.dup_eval { self }
-    end
-
-    def draw
-        @img.paint {
-            circle -5100, -9700, 20
-            circle(@img.width * rand * 2 - @img.width, @img.height * rand * 2 - @img.height, 40)
-        }
-        @img.draw(100,100,1)
-    end
-
-    def img
-        @img
-    end
-end
-
-w = W.new
-w.show
-        

data/examples/benchmark.rb

@@ -1,299 +0,0 @@
-# TexPlay test program
-
-begin
-    require 'rubygems'
-rescue LoadError
-
-end
-
-require 'common'
-require 'gosu'
-require 'texplay'
-require 'benchmark'
-
-class MyWindow < Gosu::Window
-    
-    # set to true for visible output
-    # note, benchmarks will not happen until
-    # viewing window is closed
-    SHOW = false
-
-    def initialize
-        super(1024, 768, false, 20)        
-        @img = Gosu::Image.new(self,"#{Common::MEDIA}/texplay.png")
-        @img2 = Gosu::Image.new(self,"#{Common::MEDIA}/texplay.png")
-        @gosu = Gosu::Image.new(self, "#{Common::MEDIA}/gosu.png")
-        @empty1 = Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
-        @empty2 = Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
-        @empty3 = Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
-        @width = @img.width
-        @height = @img.height
-
-        # default number of iterations 
-        @repeat = 1000
-
-        if ARGV.first.to_i != 0 then
-            @repeat = ARGV.shift.to_i
-        end
-
-        if SHOW then
-            class << self
-                alias_method :draw, :_draw
-            end
-        end
-    end
-    
-    def bench_all
-        x1 = rand @width
-        y1 = rand @height
-        x2 = rand @width
-        y2 = rand @height
-        
-        @img.paint { 
-            color :random
-            circle x1, y1, 10
-            line x1, y1, x2, y2 
-            rect x1, y1, x2 + 100, y2 + 100
-            pixel x1, y1
-        }
-    end
-
-    def bench_clear
-        @img.paint { 
-            clear
-        }
-    end
-
-    def bench_circle
-        x = rand @width
-        y = rand @height
-        r = 50
-        
-        @img.circle x, y, r
-                
-    end
-
-    def bench_pixel
-        @img.paint {
-            color :random
-            pixel (@img.width * rand), (@img.width * rand)
-        }
-    end
-
-    def bench_splice
-        @img.paint {
-            splice(@img2, (@img.width * rand), (@img.height * rand))
-        }
-    end
-
-    
-    def bench_splice_same
-        @img.paint {
-            splice(@img, (@img.width * rand), (@img.height * rand))
-        }
-    end
-
-    def bench_special_pixel
-        @img.paint {
-            self[(@img.width * rand), (@img.height * rand)] = :random
-        }
-    end
-    
-    def bench_line
-        x1 = rand @width
-        y1 = rand @height
-        x2 = rand @width
-        y2 = rand @height
-        
-        
-        @img.line x1, y1, x2, y2
-                
-    end
-
-    def bench_pline
-        x1 = rand @width
-        y1 = rand @height
-        x2 = rand @width
-        y2 = rand @height
-        
-        
-        @img.paint {
-            line x1, y1, x2, y2
-        }
-                
-    end        
-
-    def bench_box
-        x1 = rand @width
-        y1 = rand @height
-        x2 = rand @width
-        y2 = rand @height
-        
-        @img.paint {
-            rect rand(@width),rand(@width),rand(@width),rand(@width)
-        }        
-    end
-
-    def bench_anti_each
-        0.upto(@img.width - 1) { |x|
-            0.upto(@img.height - 1) { |y|
-                clr = @img.get_pixel(x, y) 
-                
-                clr[0] += 1
-                
-                @img.color clr
-                @img.pixel(x, y)
-            }
-        }
-    end
-
-    def bench_each
-        @img.each { |v| v[0] = 1}
-    end
-
-    def bench_each2
-        @img.each2 { |v| v[0] = 1}
-    end
-
-    def bench_image_new
-        Gosu::Image.new(self, "#{Common::MEDIA}/empty2.png")
-    end
-
-    def bench_create_blank
-        truck = TexPlay::create_blank_image(self, @img.width, @img.height)
-        truck.splice(@img, 0, 0)
-        
-    end
-
-    def bench_dup
-        @img.dup
-    end
-
-    def bench_clone
-        @img.clone
-    end
-
-    def bench_composite
-        @img.splice @img2, 0, 0
-    end
-
-    def bench_rect
-        @img.rect 0, 0, 1024, 1024, :fill => true
-    end
-
-    def bench_gen_eval
-        @img.paint {
-            0.upto(1000) { 
-                circle 100,100, 10
-            }
-        }
-    end
-
-    def bench_eager_sync
-        @img.paint(:lazy_sync => false) {
-#            1.upto(1000) { 
-   #             color :blue
-            ###                circle (10), (10), 10
-            clear
-                #circle (@img.width * rand), (@img.height * rand), 10
-  #          }
-        }
-    end
-
-    def bench_lazy_sync
-        @img.paint(:lazy_sync => true) {
-#            1.upto(1000) { 
- #               color :blue
-            #              circle (10), (10), 10
-            clear
-                #circle (@img.width * rand), (@img.height * rand), 10
- #           }
-
-        }
-    end
-
-
-    def bench_yield
-        @img.paint { |c|
-            0.upto(1000) { 
-                c.circle 100,100, 10
-            }
-        }
-    end
-
-    def bench_instance_eval
-        @img.instance_eval {
-            0.upto(1000) { 
-                circle 100,100, 10
-            }
-        }
-    end
-
-    def bench_glow_fill
-        @empty2.fill 100,100
-    end
-
-    def bench_scan_fill_style
-        @empty2.fill 100,100, :scan => true, :style => true, :color => :random
-    end
-
-    def bench_scan_fill
-        @empty3.fill 100,100, :scan => true, :color => :random
-    end
-
-    def bench_iter_fill
-        @empty3.fill 100,100, :iter => true
-    end
-
-    def bench_polyline_thick
-        @empty2.polyline [100, 200, 0, 0, 150, 500, 500, 0], :closed => true, :texture => @tp, :thickness => 2,
-        :alpha_blend => true, :sync_mode => :no_sync
-    end
-
-    def bench_polyline
-        ps = []
-        13.times {
-            p = [@empty2.width * rand, @empty2.height * rand]
-            ps += p
-                }
-       # ps = [110, 110, 210, 210]
-        @empty2.polyline ps
-    end
-
-    def bench_bezier
-        ps = []
-        13.times {
-            p = [@empty2.width * rand, @empty2.height * rand]
-            ps += p
-        }
-        @empty2.bezier ps
-    end
-
-    def _draw
-        @img.draw(200, 200, 0)
-    end
-
-    def do_benchmarks
-        puts "performing #{@repeat} iterations..."
-
-        bench_meths = ARGV
-        
-        if ARGV.empty? then
-            bench_meths  = self.methods.select { |x| x =~ /bench/ }.map { |x| x.to_s.sub("bench_", "") }
-        end
-        
-        Benchmark.bmbm do |v|
-            bench_meths.each { |meth|
-                v.report(meth) {  @repeat.times { self.send("bench_#{meth}") } }
-            }
-        end
-    end
-end
-
-w = MyWindow.new
-
-if MyWindow::SHOW
-    w.show
-end
-
-w.do_benchmarks

data/examples/specs.rb

@@ -1,240 +0,0 @@
-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
-

data/examples/test.rb

@@ -1,70 +0,0 @@
-require 'common'
-require 'gosu'
-require 'texplay'
-
-class MyWindow < Gosu::Window
-    def initialize
-        super(1024, 768, false, 20)
-
-        # image for texture filling
-        @gosu = Gosu::Image.new(self,"#{Common::MEDIA}/gosu.png")
-
-        # images for testing
-        @unchanged = Gosu::Image.new(self,"#{Common::MEDIA}/texplay.png")  
-        @simple = Gosu::Image.new(self,"#{Common::MEDIA}/texplay.png")  
-        @polyline = Gosu::Image.new(self,"#{Common::MEDIA}/texplay.png") 
-        @bezier = Gosu::Image.new(self,"#{Common::MEDIA}/texplay.png") 
-        @flood_fill = Gosu::Image.new(self,"#{Common::MEDIA}/texplay.png") 
-
-        # height and width
-        @width = @simple.width
-        @height = @simple.height
-
-        # initializations
-        setup_simple
-        setup_polyline
-        setup_bezier
-        setup_flood_fill
-
-    end
-
-    def setup_simple
-        @simple.line 0, 0, 1024, 1024
-        @simple.rect 0,0, @width - 1, @height - 1
-        @simple.circle @simple.width/2, @simple.height/2, 30
-    end
-
-    def setup_polyline
-        @polyline.polyline [0, 0, @width / 2, @height - 1, @width - 1, 0]
-    end
-
-    def setup_bezier
-        points = []
-        10.times {
-            point = []
-            point[0] = @width * rand
-            point[1] = @height * rand
-
-            points += point
-        }
-        @bezier.bezier points
-    end
-
-    def setup_flood_fill
-        @flood_fill.fill 100, 96, :color => :random, :scan => true
-    end
-
-    def draw
-
-        @simple.draw(20, 10, 1)
-        @polyline.draw(20, 210, 1)
-        @bezier.draw(20, 410, 1)
-        @flood_fill.draw(400, 10, 1)
-
-    end
-end
-
-w = MyWindow.new
-w.show
-
-