texplay 0.2.721-i386-mingw32

data/CHANGELOG

@@ -0,0 +1,119 @@
+12/03/10
+version 0.2.721	
+* fixed bug in alpha_blend (now blends alpha channels too)
+
+6/12/09
+version 0.2.710
+* fixed bug in line drawing code (wasn't drawing final pixel)
+* fixed bug in filled rect code (wasn't drawing final row)
+* fixed bug in flood fill (wasn't drawing on first column)
+* added glDisable(GL_TEXTURE_2D) calls to cache.c, and removed 'restore previous texture binding' (i doubt there is any previous binding to restore)
+* using version.rb to help manage versions
+
+23/11/09
+* fixed bug in texplay.rb. Replaced TexPlay::TP_MAX_QUAD_SIZE - 2 with
+just TexPlay::TP_MAX_QUAD_SIZE (the -2 is now built into the constant)
+
+16/10/09
+version 0.2.700
+* removed memory leak from Gosu::Image#to_blob, now writing directly to RSTRING_PTR
+
+12/10/09
+version 0.2.666
+* added Gosu::Image#to_blob
+* to_blob functionality enables Gosu::Images to work with DevIL library
+
+6/10/09
+version 0.2.5
+* fixed quad_draw flicker bug
+* added splice_and_scale (to texplay-contrib.rb)
+* now using rake-compiler to run build process
+
+15/9/09
+version 0.2.4
+* added lsystem
+* made lsystem both 1.9.1 and 1.8.6 compatible
+
+11/9/09
+version 0.2.3
+* added Ruby 1.8.7 compatibility by modifying extconf.rb to define RUBY_19 macro
+* and modified compat.h to get rid of feature test (fails on 1.8.7)
+
+8/9/09
+version 0.2.2
+* fixed color_control bug, action_struct->color was being overwritten (now using a temp).
+* fixed faulty error msg where max tex size was being displayed as 1024 but is actually 1022
+* added :start_angle parameter to ngon action
+* fixed example screen height from 769 to 768
+* arity of -1 and 0 now supported for color_control procs
+* fixed parameter checks for circle and ngon
+* updated documentation to reflect changes, and added details on caching
+
+2/9/09
+version 0.2.1
+* releasing a gem for TexPlay
+* bumped version number so can add add gosu 0.7.14 dependency to github gem
+* hopefully gem works on both github and rubyforge
+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.markdown

@@ -0,0 +1,41 @@
+![Alt text](https://dl.getdropbox.com/u/239375/texplay.png)
+
+*an image manipulation tool for ruby and gosu*
+
+INSTRUCTIONS 
+============
+
+**TexPlay version 0.2.710**
+
+Gem installation:
+
++ sudo gem install texplay
+
+How to build the gems? (maintainers only)
+
++ Install rake-compiler (http://github.com/luislavena/rake-compiler)
++ Install 1.9.1 and 1.8.6 mingw ruby versions (instructions above)
++ Type: rake cross native gem RUBY_CC_VERSION=1.8.6:1.9.1
++ Upload new gems to rubyforge and gemcutter.
+
+How to build from source?    
++ rake compile
+
+OR
+
++ rake19 compile (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!

data/Rakefile

@@ -0,0 +1,66 @@
+
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/extensiontask'
+
+# get the texplay version
+require 'lib/texplay/version'
+
+$dlext = Config::CONFIG['DLEXT']
+
+CLEAN.include("ext/**/*.#{$dlext}", "ext/**/*.log", "ext/**/*.o", "ext/**/*~", "ext/**/*#*", "ext/**/*.obj", "ext/**/*.def", "ext/**/*.pdb")
+CLOBBER.include("**/*.#{$dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o")
+
+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 = TexPlay::VERSION
+    s.date = Time.now.strftime '%Y-%m-%d'
+    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.platform = Gem::Platform::RUBY
+    s.homepage = "http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/"
+    s.has_rdoc = false
+
+    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 
+end
+
+Rake::ExtensionTask.new('texplay', specification)  do |ext|
+  # ext.config_script = 'extconf.rb' 
+  # ext.cross_compile = true                
+  #ext.cross_platform = 'i386-mswin32'
+#  ext.platform = 'i386-mswin32'
+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 = TexPlay::VERSION
+    s.date = Time.now.strftime '%Y-%m-%d'
+    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.platform = 'i386-mingw32'
+    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.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
+end
+  
+Rake::GemPackageTask.new(specification) do |package|
+  package.need_zip = false
+  package.need_tar = false
+end

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
+