texplay 0.2.0

data/CHANGELOG

@@ -0,0 +1,63 @@
+31/8/09
+version 0.2.0
+* added each iterator
+* added alternative to proc for :color_control proc (allowing static linear transforms to pixels)
+* no longer segfaulting on windows (no idea why not)
+* rewrote EmptyImageStub in ruby, using philomory's code. now alot faster.
+* implemented 'shadow' in terms of static :color_control pixel transform
+* added more example code demonstrating each iterator (example_each.rb) and new color_control behaviour
+  i.e example_color_transform.rb
+* should be relatively stable now! 
+
+28/8/09
+version 0.1.9.1 (still BETA)
+* experimental features: Gosu::Image#dup and Gosu::Image#clone
+* also TexPlay::create_blank_image(window, width, height)
+* I noticed these features SEG FAULT on my setup in windows, so be warned
+* This is a BETA release
+
+14/8/09
+version 0.1.9.0 (BETA)
+* major rewrite. TP now supports beziers, polylines, polygons, and more
+* also supports alpha_blending (though still tempermental)
+* This is a BETA release
+
+1/7/09
+version 0.1.6.2
+* fixed another subtle bug in constrain_local_boundaries(). Function was 
+unable to deal with drawing actions that were 100% outside the image 
+boundaries.
+
+28/6/09
+version 0.1.6
+* gen_eval now working as a replacement for instance_eval in the #paint block. Allows for more user-friendly interface.
+* #paint can now be called without a block; if invoked this way it executes any commands in the action queue, e.g
+  @img.circle 20, 20, 40
+  @img.pixel 30, 30
+  @img.paint
+* above will function as if: @img.paint { circle 20, 20, 40; pixel 30, 30 }
+* collected 1.8.6/1.9.1 compatibility into compat.h
+
+16/6/09
+version 0.1.4.6
+* allowed arity of 0 (as well as -1) for ruby 1.9 compatibility
+
+13/6/09
+version 0.1.4.5
+* major bugfix with TexPlay#splice method (segfaut). Also added new color format parameter: color [1, 1, 0, 1] (e.g purple with full alpha).
+Also fixed subtle edge-case bug in constrain_local_boundaries().
+
+9/6/09
+version 0.1.4
+* improved error checking. should work better with later gosu releases
+
+20/2/09 
+version 0.1.1
+* rerelease of this version fixing the oversized image bug for refresh_cache (i.e images over 500 x 500
+
+version 0.1.1
+* oops, bug in leftshift/rightshift functions, fixed!
+
+version 0.1.0
+* release!
+

data/README

@@ -0,0 +1,21 @@
+INSTRUCTIONS 
+
+TexPlay version 0.2.0
+
+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/README1st

@@ -0,0 +1,9 @@
+INSTRUCTIONS
+
+TexPlay version 0.2.0
+
+*Ensure that ctexplay.so and gosu.so, and texplay.rb and texplay-contrib.rb are in the working directory for your project
+*require 'texplay' in your ruby program to access the TexPlay module
+*see example programs, for illustration of use
+
+

data/Rakefile

@@ -0,0 +1,85 @@
+require 'rake/clean'
+require 'rake/gempackagetask'
+
+$dlext = Config::CONFIG['DLEXT']
+
+CLEAN.include("src/*.#{$dlext}", "src/*.log", "src/*.o", "src/*~", "src/*#*", "src/*.obj", "src/*.def", "src/*.pdb")
+CLOBBER.include("**/*.#{$dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o")
+
+$make_program = if RUBY_PLATFORM =~ /win/ 
+                    "nmake"
+                else
+                    "make"
+                end
+
+task :default => [:build]
+
+desc "Build TexPlay"
+task :build => :clean do
+    puts "(2) building Makefile..."
+    chdir("./src/") do
+        ruby "extconf.rb"
+        puts "(3) building ctexplay.#{$dlext}..."
+        sh "#{$make_program}"
+        puts "(4) copying ctexplay.#{$dlext} to current directory..."
+        cp "ctexplay.#{$dlext}", "../lib" , :verbose => true
+
+        if RUBY_PLATFORM =~ /mswin/
+            if RUBY_VERSION =~ /1.9/
+                File.rename("../lib/ctexplay.#{dlext}", "../lib/ctexplay19.#{$dlext}")
+            else
+                File.rename("../lib/ctexplay.#{dlext}", "../lib/ctexplay18.#{$dlext}")
+            end
+        end
+        puts "(5) ...done!"
+    end
+end
+
+specification = Gem::Specification.new do |s|
+    s.name = "texplay"
+    s.summary = "TexPlay is a light-weight image manipulation framework for Ruby and Gosu"
+    s.version = "0.2.0"
+    s.date = "2009-09-02"
+    s.author = "John Mair (banisterfiend)"
+    s.email = 'jrmair@gmail.com'
+    s.description = s.summary
+    s.require_path = 'lib'
+    s.add_dependency("gosu",">=0.7.14")
+    s.homepage = "http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/"
+    s.has_rdoc = false
+    s.files =  ["Rakefile", "README", "CHANGELOG", "README1st",
+                "lib/texplay.rb", "lib/texplay-contrib.rb"] +
+        FileList["src/*", "examples/*.rb", "examples/media/*"].to_a 
+
+    if RUBY_PLATFORM =~ /mswin/
+        s.platform = Gem::Platform::CURRENT
+        s.files += ["lib/ctexplay18.so", "lib/ctexplay19.so"]
+        
+    else
+        s.platform = Gem::Platform::RUBY
+        s.extensions = ["src/extconf.rb"]
+    end
+end
+Rake::GemPackageTask.new(specification) do |package|
+    package.need_zip = false
+    package.need_tar = false
+end
+
+SELENE = '/home/john/ruby/projects/selene'
+desc "update selene's version of texplay"
+task :selene => ["#{SELENE}/lib/texplay.rb", "#{SELENE}/lib/texplay-contrib.rb",
+              "#{SELENE}/lib/ctexplay.so"] do
+    puts "...done!"
+end
+
+file "#{SELENE}/lib/texplay.rb" => "texplay.rb" do |t|
+    cp t.prerequisites.first, t.name, :verbose => true
+end
+
+file "#{SELENE}/lib/texplay-contrib.rb" => "texplay-contrib.rb" do |t|
+    cp t.prerequisites.first, t.name, :verbose => true
+end
+
+file "#{SELENE}/lib/ctexplay.#{$dlext}" => "ctexplay.#{$dlext}" do |t|
+    cp t.prerequisites.first, t.name, :verbose => true
+end

data/examples/basic.rb

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

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

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