texplay 0.4.3-x86-mingw32

data/lib/texplay/alone.rb

@@ -0,0 +1,20 @@
+direc = File.dirname(__FILE__)
+
+require "#{direc}/../texplay"
+
+module TexPlay
+  Win = Gosu::Window.new(100, 100, false)
+
+  set_options :sync_mode => :no_sync
+
+  class << self
+    def load(name)
+      Gosu::Image.new(Win, name)
+    end
+  
+    alias_method :original_create_image, :create_image
+    def create_image(width, height, options={})
+      original_create_image(Win, width, height, options)
+    end      
+  end
+end

data/lib/texplay/c_function_docs.rb

@@ -0,0 +1,178 @@
+# -*- coding: iso-8859-1 -*-
+# This code is never run; it is just here so we can document the C functions.
+
+
+module TexPlay
+  # Draw a bezier curve.
+  #
+  # @param (see #polyline)
+  # @option (see #polyline)
+  # @return [Gosu::Image]
+  def bezier(points, options = {})
+  end
+
+  # Draw a circle.
+  #
+  # @note :thickness not implemented for circle.
+  #
+  # @param [Number] center_x Horizontal center.
+  # @param [Number] center_y Vertical center.
+  # @param [Number] radius Radius.
+  # @option (see #set_pixel)
+  # @option options [Boolean] :fill (false) Whether to fill in the shape.
+  # @option options [Boolean] :filled (false) Synonym for +:fill+
+  # @return [Gosu::Image]
+  def circle(center_x, center_y, radius, options = {})
+  end
+
+  # Make a copy of the image.
+  #
+  # @return [Gosu::Image] Deep copy of the image.
+  def clone()
+  end
+
+  # (see #clone)
+  def dup()
+  end
+
+  # Iterate through every pixel of the image, allowing modification of each pixels.
+  #
+  # @yield [color, x, y] Colour and position (arity == 3).
+  # @yield [color] Colour only (arity == 1).
+  # @yieldparam [Array<Float>] color RGBA colour array. This can be modified to affect the image directly.
+  # @yieldparam [Integer] x X position of the pixel.
+  # @yieldparam [Integer] y Y position of the pixel.
+  def each(&block)
+  end
+
+  # Perform a Flood Fill at a given position.
+  #
+  # @param [Number] x
+  # @param [Number] y
+  # @option options [Gosu::Color, Array<Float>, Symbol] :color (:white) Colour to apply to the drawing action.
+  # @option options [Proc, Hash] :color_control Effect to apply to the drawing action.
+  # @return [Gosu::Image]
+  def fill(x, y, options = {})
+  end
+
+  # Force synchronisation of the image (send from RAM to VRAM).
+  #
+  # @param [Array<Number>] rectangle Area to synchronise.
+  # @return [Gosu::Image]
+  def force_sync(rectangle = [0, 0, width, height])
+  end
+
+  # Get the colour of an individual pixel.
+  #
+  # @param [Number] x Horizontal position.
+  # @param [Number] y Vertical position.
+  # @return [Array<Float>] 4-element, RGBA colour array.
+  def get_pixel(x, y)
+  end
+
+  # @param [Number] x1 X position of start of line.
+  # @param [Number] y1 Y position of start of line.
+  # @param [Number] x2 X position of end of line.
+  # @param [Number] y2 Y position of end of line.
+  # @option (see #set_pixel)
+  # @option options [Number] :thickness (1) Thickness of the line.
+  # @option options [Hash] :trace Trace
+  # @return [Gosu::Image]
+  def line(x1, y1, x2, y2, options = {})
+  end
+
+  # Draw an n-sided polygon.
+  #
+  # @param (see #circle)
+  # @param [Integer] sides Number of sides for the polygon.
+  # @option (see #circle)
+  # @return [Gosu::Image]
+  def ngon(center_x, center_y, radius, sides, options = {})
+  end
+
+  # Offset all future drawing actions.
+  #
+  # The offset is non-stacking.
+  #
+  # Can also use +offset(:default)+ to reset offset to (0, 0).
+  #
+  # @param [Number] x
+  # @param [Number] y
+  # @return [Gosu::Image]
+  def offset(x, y)
+  end
+
+  # Perform drawing operations in the context of the image using _lazy_ syncing.
+  #
+  # A peculiarity of paint blocks is how they sync the drawing actions (syncing will be discussed in greater depth
+  # later on). The drawing actions in a Paint Block are not sync�d until the very end of the Paint Block and are then
+  # sync'd to video memory all in one go (This style of syncing is called _lazy_ syncing in TexPlay)
+  #
+  # @example Drawing to the image within a paint block
+  #   image1.paint do
+  #     circle 10, 10, 20, :color => :green
+  #     bezier [0, 0, 10, 10, 50, 0], :closed => true
+  #   end
+  #
+  # @option options [Symbol] :sync_mode (:lazy_sync) One of +:lazy_sync+, +:no_sync+ or +:eager_sync+
+  # @yield Block evaluated as the image.
+  # @return [Gosu::Image]
+  def paint(options = {}, &block)
+  end
+
+  # Draw a series of connected lines.
+  #
+  # @param [Array<Number, TPPoint>] points Series of points (either [x1, y1, x2, y2, ...] or [point1, point2]).
+  # @option (see #rect)
+  # @option options [Boolean] :closed Whether the last point is linked to the first.
+  # @return [Gosu::Image]
+  def polyline(points, options = {})
+  end
+
+  # Draw a rectangle.
+  #
+  # @param [Number] x1 Top of the rectangle.
+  # @param [Number] y1 Left of the rectangle.
+  # @param [Number] x2 Right of the rectangle.
+  # @param [Number] y2 Bottom of the rectangle.
+  # @option (see #circle)
+  # @option options [Number] :thickness (1) Thickness of the line.
+  # @return [Gosu::Image]
+  def rect(x1, y1, x2, y2, options = {})
+  end
+  alias_method :box, :rect
+
+  # Set the colour of an individual pixel.
+  #
+  # @param [Number] x
+  # @param [Number] y
+  # @option (see #fill)
+  # @option options [Boolean] :alpha_blend (false) Alpha-blend instead of overwrite.
+  # @option options [Gosu::Image] :texture Texture to use instead of a flat colour.
+  # @option options [Symbol] :mode (:copy) Drawing mode to use.
+  # @return [Gosu::Image]
+  def set_pixel(x, y, options = {})
+  end
+  alias_method :pixel, :set_pixel
+
+  # Copy an image into another image.
+  #
+  # @param [Number] x Horizontal position to splice at.
+  # @param [Number] y Vertical position to splice at.
+  # @param [Gosu::Image] source Image to copy from.
+  # @option options [Gosu::Color, Array<Float>, Symbol] :chroma_key Colour to treat as transparent (only other colour pixels will be spliced).
+  # @option options [Gosu::Color, Array<Float>, Symbol] :chroma_key_not Colour to copy (other colours won't be spliced).
+  # @option options [Array<Float>] :crop ([0, 0, source.width - 1, source.height - 1]) Area of the source image to splice.
+  # @return [Gosu::Image]
+  def splice(x, y, source, options = {})
+  end
+  alias_method :composite, :splice
+
+  # Generate binary data from the image.
+  #
+  # @note This method is usually overridden by the default Gosu::Image#to_blob.
+  # @note This method causes a segmentation fault in Windows.
+  # @return [String] Raw binary data (blob) in RGBA byte order.
+  def to_blob
+  end
+end

data/lib/texplay/live.rb

@@ -0,0 +1,84 @@
+direc = File.dirname(__FILE__)
+
+require "#{direc}/../texplay"
+require 'pry'
+
+WIDTH = 640
+HEIGHT = 480
+
+class Gosu::Image
+  attr_accessor :x, :y
+
+  alias_method :orig_init, :initialize
+  def initialize(*args)
+    @x = WIDTH / 2
+    @y = HEIGHT / 2
+    orig_init(*args)
+  end
+end
+
+class WinClass < Gosu::Window
+
+  class View
+    attr_accessor :zoom, :rotate
+
+    def initialize
+      @zoom = 1
+      @rotate = 0
+    end
+
+    def reset
+      @zoom = 1
+      @rotate = 0
+    end
+  end
+  
+  attr_reader :images, :view
+  
+  def initialize
+    super(WIDTH, HEIGHT, false)
+    Gosu.enable_undocumented_retrofication
+
+    @images = []
+    @view = View.new
+    @pry_instance = Pry.new :prompt => [Proc.new { "(live)> " }, Proc.new { "(live)* " }]
+    
+    @img = TexPlay.create_image(self, 200, 200)
+    @img.rect 0, 0, @img.width - 1, @img.height - 1
+    
+    images << @img
+    @binding = binding
+  end
+
+  def create_image(width, height, options={})
+    TexPlay.create_image(self, width, height, options)
+  end
+
+  def load_image(file)
+    Gosu::Image.new(self, file)
+  end
+
+  def show_image(image)
+    images << image
+  end
+
+  def hide_image(image)
+    images.delete(image)
+  end
+  
+  def draw
+    images.uniq!
+    images.each do |v|
+      v.draw_rot(v.x, v.y, 1, view.rotate, 0.5, 0.5, view.zoom, view.zoom)
+    end
+  end
+
+  def update
+    @pry_instance.rep(@binding)
+  end
+end
+
+w = WinClass.new
+
+w.show
+

data/lib/texplay/version.rb

@@ -0,0 +1,3 @@
+module TexPlay
+  VERSION = "0.4.3"
+end

data/live/live.rb

@@ -0,0 +1,85 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/texplay"
+require 'pry'
+
+WIDTH = 640
+HEIGHT = 480
+
+class Gosu::Image
+  attr_accessor :x, :y
+
+  alias_method :orig_init, :initialize
+  def initialize(*args)
+    @x = WIDTH / 2
+    @y = HEIGHT / 2
+    orig_init(*args)
+  end
+end
+
+class WinClass < Gosu::Window
+
+  class View
+    attr_accessor :zoom, :rotate
+
+    def initialize
+      @zoom = 1
+      @rotate = 0
+    end
+
+    def reset
+      @zoom = 1
+      @rotate = 0
+    end
+  end
+  
+  attr_reader :images, :view
+  
+  def initialize
+    super(WIDTH, HEIGHT, false)
+    Gosu.enable_undocumented_retrofication
+
+    @images = []
+    @view = View.new
+    @pry_instance = Pry.new :prompt => [Proc.new { "(live)> " }, Proc.new { "(live)* " }]
+    
+    @img = TexPlay.create_image(self, 200, 200)
+    @img.rect 0, 0, @img.width - 1, @img.height - 1
+    
+    images << @img
+    @binding = binding
+  end
+
+  def create_image(width, height, options={})
+    TexPlay.create_image(self, width, height, options)
+  end
+
+  def load_image(file)
+    Gosu::Image.new(self, file)
+  end
+
+  def show_image(image)
+    images << image
+  end
+
+  def hide_image(image)
+    images.delete(image)
+  end
+  
+  def draw
+    images.uniq!
+    images.each do |v|
+      v.draw_rot(v.x, v.y, 1, view.rotate, 0.5, 0.5, view.zoom, view.zoom)
+    end
+  end
+
+  def update
+    @pry_instance.rep(@binding)
+  end
+end
+
+w = WinClass.new
+
+w.show
+

data/test/image_spec.rb

@@ -0,0 +1,45 @@
+direc = File.dirname(__FILE__)
+
+require "#{direc}/../lib/texplay"
+
+class Module
+  public :remove_const
+end
+
+describe Gosu::Image do
+  before do
+    @window = Gosu::Window.new(640, 480, false)
+    NormalImageSize = [Gosu::MAX_TEXTURE_SIZE - 2, Gosu::MAX_TEXTURE_SIZE - 2]
+    TooLargeImageSize = [2000, 2000]
+  end
+
+  after do
+    Object.remove_const(:NormalImageSize)
+    Object.remove_const(:TooLargeImageSize)
+  end
+  
+  describe "Gosu::Image#new (patched by TexPlay)" do
+    describe "caching option" do
+      it "should not cache image if :caching => false" do
+        source_image = TexPlay.create_image(@window, *NormalImageSize)
+        source_image.quad_cached?.should == false
+
+        image = Gosu::Image.new(@window, source_image, :caching => false)
+        image.width.should == NormalImageSize[0]
+        image.height.should == NormalImageSize[1]
+
+        image.quad_cached?.should == false
+      end
+
+      it "should cache the image if :caching => true" do
+        source_image = TexPlay.create_image(@window, *NormalImageSize)
+
+        image = Gosu::Image.new(@window, source_image, :caching => true)
+        image.width.should == NormalImageSize[0]
+        image.height.should == NormalImageSize[1]
+
+        image.quad_cached?.should == true
+      end
+    end
+  end
+end

data/test/texplay_spec.rb

@@ -0,0 +1,144 @@
+$LOAD_PATH.unshift File.join(File.expand_path(__FILE__), '..', 'lib','texplay')
+direc = File.dirname(__FILE__)
+
+require "#{direc}/../lib/texplay"
+
+describe TexPlay do
+  described_class = TexPlay
+  
+  before do
+    @window = Gosu::Window.new(640, 480, false)
+  end
+
+  describe "#create_image" do
+    it "should create a blank image of the correct size" do
+      width, height = 30, 10
+      image = described_class.create_image(@window, width, height)
+
+      image.width.should == width
+      image.height.should == height
+
+      width.times do |x|
+        height.times do |y|
+          image.get_pixel(x, y).should == [0.0, 0.0, 0.0, 0.0]
+        end
+      end
+    end
+
+    it "should create a coloured image of the correct size" do
+      width, height = 10, 30
+      color = [1.0, 1.0, 0.0, 1.0]
+      image = described_class.create_image(@window, width, height, :color => color)
+
+      image.width.should == width
+      image.height.should == height
+
+      width.times do |x|
+        height.times do |y|
+          image.get_pixel(x, y).should == color
+        end
+      end
+    end
+
+    it "should raise an error if an image dimension is 0 or less" do
+      lambda { described_class.create_image(@window, 0, 0)}.should raise_error(ArgumentError)
+    end
+
+    # TODO: Should probably be an ArgumentError.
+    it "should raise an ArgumentError if the image would be too large" do
+      too_big = TexPlay::TP_MAX_QUAD_SIZE + 1
+      [[too_big, 5], [10, too_big], [too_big, too_big]].each do |width, height|
+        puts "WIDTH: #{width.inspect}, HEIGHT: #{height.inspect}"
+        lambda {
+          described_class.create_image(@window, width, height)
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#clear" do
+    it "should clear an image to the correct color" do
+      img = described_class.create_image(@window, 10, 10)
+      img.clear :color => :red
+      (0...img.width).each do |x|
+        (0...img.height).each do |y|
+          img.get_pixel(x,y).should == [1,0,0,1]
+        end
+      end
+    end
+  end
+
+  describe "#from_blob" do
+    # it "should create an image with the requested pixel data and size" do
+    #   # 4 x 3, with columns of red, blue, green, transparent.
+    #   gosu_colors = [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255], [0, 0, 0, 0]]
+    #   texplay_colors = gosu_colors.map {|a| a.map {|c| c / 255.0 } }
+    #   width, height = gosu_colors.size, 3
+      
+    #   image = described_class.from_blob(@window, (gosu_colors * height).flatten.pack('C*'), width, height)
+
+    #   image.width.should == width
+    #   image.height.should == height
+
+    #   texplay_colors.each_with_index do |color, x|
+    #     3.times do |y|
+    #       image.get_pixel(x, y).should == color
+    #     end
+    #   end
+    # end
+
+    it "should raise an error if the image size is not correct for the blob data" do
+      lambda { described_class.from_blob(@window, [1, 1, 1, 1].pack("C*"), 2, 1) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if an image dimension is 0 or less" do
+      lambda { described_class.from_blob(@window, '', 0, 0) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "alpha_blend" do
+    it "should alpha blend using source alpha and not fixing alpha" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 1]
+      img1.clear :color => [0, 0, 1, 0.5], :alpha_blend => :source
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.75]
+    end
+
+    it "hash params true and :source should be equivalent" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 1]
+      img2 = img1.dup
+      img1.clear :color => [0, 0, 1, 0.5], :alpha_blend => :source
+      img2.clear :color => [0, 0, 1, 0.5], :alpha_blend => true
+      
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.75]
+      img2.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.75]
+    end
+
+    it "false or nil should prevent alpha blending" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 1]
+      img2 = img1.dup
+      img1.clear :color => [0, 0, 1, 0.5], :alpha_blend => false
+      img2.clear :color => [0, 0, 1, 0.5], :alpha_blend => nil
+      
+      img1.get_pixel(5, 5).should == [0, 0, 1, 0.5]
+      img2.get_pixel(5, 5).should == [0, 0, 1, 0.5]
+    end
+
+    it "should alpha blend using dest alpha and not fixing alpha" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 0.5]
+      img1.clear :color => [0, 0, 1, 1], :alpha_blend => :dest
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.75]
+    end
+
+    it "should alpha blend using source alpha and fixing alpha" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 1]
+      img1.clear :color => [0, 0, 1, 0.5], :alpha_blend => :source_with_fixed_alpha
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 1]
+    end
+
+    it "should alpha blend using dest alpha and fixing alpha" do
+      img1 = described_class.create_image(@window, 10, 10).clear :color => [1, 0, 0, 0.5]
+      img1.clear :color => [0, 0, 1, 1], :alpha_blend => :dest_with_fixed_alpha
+      img1.get_pixel(5, 5).should == [0.5, 0, 0.5, 0.5]
+    end
+  end
+end