lash-sprites 0.3.1

data/lib/lash-sprites/packer/ratio.rb

@@ -0,0 +1,94 @@
+require 'ruby_sprites/image'
+require 'ruby_sprites/block'
+
+module RubySprites
+  module Packer
+    module Ratio
+
+      def self.pack(images, options = {})
+        width = 0
+        height = 0
+        
+        images.sort! do |a, b|
+          ra = 1.0 * a.width / a.height
+          rb = 1.0 * b.width / b.height
+          ra = 1.0 / ra if ra < 1
+          rb = 1.0 / rb if rb < 1
+          ra <=> rb
+        end
+
+        blocks = []
+
+        images.each do |img|
+          next unless img.exists?
+          smallest = nil
+          exact = nil
+          blocks.each do |block|
+            next unless block.fits?(img)
+            
+            exact = block if (img.width == block.width || img.height == block.height) && (exact.nil? || block.area < exact.area)
+            smallest = block if smallest.nil? || block.area < smallest.area
+            
+            break if smallest.area == img.area
+          end
+
+          if smallest
+            if exact
+              img.x = exact.x
+              img.y = exact.y
+              blocks.concat(blocks.delete(exact).split(img))
+            else
+              img.x = smallest.x
+              img.y = smallest.y
+              blocks.concat(blocks.delete(smallest).split(img))
+            end
+          else
+            if width == 0 && height == 0
+              b = Block.new(0, 0, img.width, img.height)
+              width = img.width
+              height = img.height
+              blocks.concat(b.split(img))
+            else
+              if img.height > height
+                new_area_right = width * (img.height - height)
+              else
+                new_area_right = img.width * (height - img.height)
+              end
+
+              if img.width > width
+                new_area_below = height * (img.width - width)
+              else
+                new_area_below = img.height * (width - img.width)
+              end
+
+              if new_area_below > new_area_right
+                if img.height > height
+                  blocks.push(Block.new(0, height, width, img.height - height))
+                  height = img.height
+                elsif img.height < height
+                  blocks.push(Block.new(width, img.height, img.width, height - img.height))
+                end
+                img.x = width
+                img.y = 0
+                width += img.width
+              else
+                if img.width > width
+                  blocks.push(Block.new(width, 0, img.width - width, height))
+                  width = img.width
+                elsif img.width < width
+                  blocks.push(Block.new(img.width, height, width - img.width, img.height))
+                end
+                img.x = 0
+                img.y = height
+                height += img.height
+              end
+            end
+          end
+        end
+
+        return {:width => width, :height => height}
+      end
+
+    end
+  end
+end

data/lib/lash-sprites/packer/vertical_smart.rb

@@ -0,0 +1,72 @@
+require 'ruby_sprites/image'
+require 'ruby_sprites/block'
+
+module RubySprites
+  module Packer
+    module VerticalSmart
+
+      def self.pack(images, options = {})
+        width = 0
+        height = 0
+        
+        images.sort! do |a, b|
+          if a.width == b.width
+            b.height <=> a.height
+          else
+            b.width <=> a.width
+          end
+        end
+
+        blocks = []
+
+        images.each do |img|
+          next unless img.exists?
+          smallest = nil
+          exact = nil
+          blocks.each do |block|
+            next unless block.fits?(img)
+            
+            exact = block if (img.width == block.width || img.height == block.height) && (exact.nil? || block.area < exact.area)
+            smallest = block if smallest.nil? || block.area < smallest.area
+            
+            break if smallest.area == img.area
+          end
+
+          if smallest
+            if exact
+              blocks.concat(split_block(blocks.delete(exact),img))
+            else
+              blocks.concat(split_block(blocks.delete(smallest),img))
+            end
+          else
+            if width == 0 && height == 0
+              b = Block.new(0, 0, img.width, img.height)
+              width = img.width
+              height = img.height
+            else
+              b = Block.new(0, height, width, img.height)
+              height += img.height
+            end
+            blocks.concat(split_block(b,img))
+          end
+        end
+
+        return {:width => width, :height => height}
+      end
+
+      def self.split_block(block, img)
+        blocks = []
+        img.x = block.x
+        img.y = block.y
+        if (block.width - img.width) * img.height > (block.height - img.height) * img.width
+          blocks.push Block.new(block.x + img.width, block.y, block.width - img.width, block.height) if block.width != img.width
+          blocks.push Block.new(block.x, block.y + img.height, img.width, block.height - img.height) if block.height != img.height
+        else
+          blocks.push Block.new(block.x + img.width, block.y, block.width - img.width, img.height) if block.width != img.width
+          blocks.push Block.new(block.x, block.y + img.height, block.width, block.height - img.height) if block.height != img.height
+        end
+        return blocks
+      end
+    end
+  end
+end

data/lib/lash-sprites/packer/vertical_split.rb

@@ -0,0 +1,164 @@
+require 'ruby_sprites/image'
+require 'ruby_sprites/block'
+
+module RubySprites
+  module Packer
+    module VerticalSplit
+
+      def self.pack(images, options = {})
+        width = 0
+        height = 0
+       
+        images = images.dup
+
+        images.sort! do |a, b|
+          a.width <=> b.width
+        end
+
+        # Grab the widest image to use as a static width
+        i = images.pop
+        width = i.width
+        height = i.height
+        i.x = 0
+        i.y = 0
+
+        images.sort! do |a, b|
+          a.area <=> b.area
+        end
+
+        block_heap = Heap.new {|a,b| b.area <=> a.area}
+
+        while !images.empty?
+          # This actually runs each loop, but we have the if here just in case
+          if block_heap.empty?
+            # There aren't any blocks to put anything in, so lets make some
+            img = images.pop
+            if width == 0 && height == 0
+              img.x = 0
+              img.y = 0
+              width = img.width
+              height = img.height
+            else
+              if img.width > width
+                block_heap.insert(Block.new(width, 0, img.width - width, height))
+                width = img.width
+              elsif img.width < width
+                block_heap.insert(Block.new(img.width, height, width - img.width, img.height))
+              end
+              img.x = 0
+              img.y = height
+              height += img.height
+            end
+          else
+            while !block_heap.empty? && !images.empty?
+              # We are looping through the blocks we have from smallest to biggest, then images smallest to biggest.
+              # We find the largest image that can fit in the current block, then put it there.  If no images fit,
+              # the block is thrown out.
+              block = block_heap.remove
+              cur_img = nil
+              cur_exact = nil
+              images.each_index do |i|
+                cur_img = i if block.fits?(images[i])
+                cur_exact = i if block.fits?(images[i]) && (block.width == images[i].width || block.height == images[i].height)
+              end
+              if !cur_exact.nil?
+                # We prefer when one of the dimensions matches
+                img = images.delete_at(cur_exact)
+                img.x = block.x
+                img.y = block.y
+                split_block(block, img).each do |b|
+                  block_heap.insert(b)
+                end
+              elsif !cur_img.nil?
+                # Best we can find
+                img = images.delete_at(cur_img)
+                img.x = block.x
+                img.y = block.y
+                split_block(block, img).each do |b|
+                  block_heap.insert(b)
+                end
+              else
+                # Nothing will fit in this block, we are throwing it out
+              end
+            end
+          end
+        end
+        
+        return {:width => width, :height => height}
+      end
+
+      def self.split_block(block, img)
+        blocks = []
+        img.x = block.x
+        img.y = block.y
+        if (block.width - img.width) * img.height > (block.height - img.height) * img.width
+          blocks.push Block.new(block.x + img.width, block.y, block.width - img.width, block.height) if block.width != img.width
+          blocks.push Block.new(block.x, block.y + img.height, img.width, block.height - img.height) if block.height != img.height
+        else
+          blocks.push Block.new(block.x + img.width, block.y, block.width - img.width, img.height) if block.width != img.width
+          blocks.push Block.new(block.x, block.y + img.height, block.width, block.height - img.height) if block.height != img.height
+        end
+        return blocks
+      end
+
+      protected
+
+      class Heap
+        def initialize(&comparer)
+          @comparer = comparer
+          @heap = [0]
+        end
+
+        def insert(el)
+          pos = @heap.length
+          @heap.push(el)
+          new_pos = pos
+          while new_pos != 1 &&  @comparer.call(el, @heap[new_pos / 2]) < 0
+            new_pos /= 2
+          end
+
+          while(pos > new_pos)
+            @heap[pos] = @heap[pos / 2]
+            pos /= 2
+          end
+          @heap[pos] = el
+        end
+
+        def remove
+          return nil if @heap.length == 1
+          el = @heap[1]
+          shifter = @heap.pop
+          if @heap.length != 1
+            pos = 1
+            while(!@heap[pos * 2].nil?)
+              lesser_pos = pos * 2
+              lesser_pos += 1 if !@heap[pos * 2 + 1].nil? && @comparer.call(@heap[pos * 2 + 1], @heap[pos * 2]) < 0
+              if(@comparer.call(@heap[lesser_pos], shifter) < 0)
+                @heap[pos] = @heap[lesser_pos]
+                pos = lesser_pos
+              else
+                break
+              end
+            end
+
+            @heap[pos] = shifter
+          end
+          return el
+        end
+
+        def peek
+          return nil if @heap.length == 1
+          return @heap[1]
+        end
+
+        def empty?
+          return @heap.length == 1
+        end
+
+        def inspect
+          return @heap.to_s
+        end
+      end
+    end
+  end
+end

data/lib/lash-sprites/packer/vertical_stack.rb

@@ -0,0 +1,23 @@
+require 'ruby_sprites/image'
+
+
+module RubySprites
+  module Packer
+    module VerticalStack
+
+      def self.pack(images, options = {})
+        width = 0
+        height = 0
+        images.each do |img|
+          next unless img.exists?
+          img.x = 0
+          img.y = height
+          width = img.width if img.width > width
+          height += img.height
+        end
+        return {:width => width, :height => height}
+      end
+
+    end
+  end
+end

data/lib/lash-sprites/sprite.rb

@@ -0,0 +1,272 @@
+# Author:: Cullen Walsh
+# Copyright:: Copyright (c) 2009 Cullen Walsh
+# License:: Lesser General Public License v3
+
+require 'ruby_sprites/image'
+require 'ruby_sprites/block'
+
+module RubySprites
+  
+  # This class is main image sprite creator.  It allows for reading existing
+  # sprites, adding images to sprites, and repacking sprites on updates
+  class Sprite
+    
+    # A hash of the default options a sprite uses.  These should be
+    # sufficient for most usage.
+    @@DEFAULT_OPTIONS = {
+      :graphics_manager => nil, # The image engine to use, may be :rmagick or :gd2
+      :pack_type => 'vertical_split', # Which algorithm should be used to pack images
+      :force_update => false, # Should the sprite image be forced to update, even if it appears up to date?
+      :write_files => true, # Decides whether the script should actually write the sprite and image files, used mainly for testing.
+      :repeat => false # Whether the sprite repeats horizontally or vertically
+    }
+
+    # Lets one programatically override the default option values if you are
+    # generating multiple sprites
+    def self.set_default(key, value)
+      @@DEFAULT_OPTIONS[key.to_sym] = value
+    end
+
+    attr_reader :filename, :file_root, :image_file, :mtime, :width, :height, :options, :images
+
+    # Creates a sprite object.  Takes an file_root, absolute or relative, a
+    # sprite filename relative to the file root, and an options hash.
+    def initialize(filename, file_root, options = {})
+      @options = @@DEFAULT_OPTIONS.merge(options)
+
+      @file_root = File.expand_path(file_root)
+      @file_root += '/' unless @file_root[-1, 1] == '/'
+      @filename = filename
+      @image_file = File.expand_path(@file_root + @filename)
+      @sprite_file = "#{@image_file}.sprite"
+
+      @width = 0;
+      @height = 0
+      @blocks = []
+      @image_queue = []
+      @images = {}
+
+      if File.exists?(@image_file) && File.exists?(@sprite_file)
+        @mtime = File.mtime(@image_file)
+        read_file
+      end
+    end
+
+    def set_option(key, val)
+      @options[key.to_sym] = val
+    end
+
+    # Destroys the sprite, deleting its related files and freeing up memory
+    def destroy!
+      File.unlink @image_file if File.exists?(@image_file)
+      File.unlink @sprite_file if File.exists?(@sprite_file)
+      initialize(@filename, @file_root, @options)
+    end
+
+    # Determines if the image in the relative path exists within the sprite
+    # and has been updated since hte sprite was generated.
+    def image_current?(imagepath)
+      img = @images[imagepath]
+      return !img.nil? && img.exists? && !@mtime.nil? && img.mtime <= @mtime
+    end
+
+    # Returns the x position, y position, width, and height of the image if
+    # it exists in the sprite.
+    def image_info(imagepath)
+      return nil if @images[imagepath].nil?
+      return {:x => @images[imagepath].x,
+              :y => @images[imagepath].y,
+              :width => @images[imagepath].width,
+              :height => @images[imagepath].height,
+              :mtime => @images[imagepath].mtime,
+              :path => @images[imagepath].path}
+    end
+
+    # Adds the image in the relative path to the sprite.
+    def add_image(img_path)
+      @image_queue.push Image.new(img_path, self, 0, 0) if @images[img_path].nil?
+    end
+
+    # Adds the images in the array of relative paths to the sprite.
+    def add_images(img_paths)
+      img_paths.each do |path|
+        add_image(path)
+      end
+    end
+
+    # Updates the sprite files if it detects changes to the sprite or the
+    # force option is set.
+    def update
+      update = @options[:force_update] || !@image_queue.empty? || @mtime.nil?
+      if update
+        @images.each do |id, img|
+          if @mtime.nil? || img.mtime.nil? || img.mtime >= @mtime
+            update = true
+            break
+          end
+        end
+      end
+      if update
+        pack
+        if @options[:write_files]
+          write_image unless @height == 0 || @width == 0
+          write_sprite_file
+        end
+        @mtime = Time.now
+      end
+    end
+
+    @@managers = nil
+
+    def self.graphics_managers
+      
+      if @@managers.nil?
+        @@managers = {}
+        
+        dir = File.dirname(__FILE__)
+
+        Dir.foreach("#{dir}/graphics_manager") do |file|
+          next unless file.match(/\.rb$/)
+          begin
+            require("#{dir}/graphics_manager/#{file}")
+            class_name = file.gsub('.rb', '').capitalize.gsub(/_([a-z]+)/) {|x| $1.capitalize}
+            @@managers[file.gsub('.rb', '').to_sym] = GraphicsManager.const_get(class_name) if GraphicsManager.const_get(class_name).availible?
+          rescue Exception => a
+            puts a
+          end
+        end
+      end
+
+      return @@managers
+    end
+
+    # Returns a Graphics manager based on the sprite options that will
+    # be used for this sprite.
+    def graphics_manager
+      if @graphics_manager.nil?
+        Sprite.graphics_managers
+        if @options[:graphics_manager].nil?
+          @graphics_manager = @@managers.values[0].new(self)
+        elsif @@managers[@options[:graphics_manager].to_sym].nil?
+          throw "Invalid Image Manager"
+        else
+          @graphics_manager = @@managers[@options[:graphics_manager].to_sym].new(self)
+        end
+      end
+      return @graphics_manager
+    end
+
+    protected
+
+    # Writes the sprite image
+    def write_image
+      graphics_manager.combine(@images, @width, @height)
+    end
+
+    # Writes the sprite data file
+    def write_sprite_file
+      lines = []
+      lines.push "#{@width} x #{@height}"
+      lines.push "Repeat #{@options[:repeat]}" if @options[:repeat]
+      @blocks.each do |block|
+        lines.push "B #{block.x} #{block.y} #{block.width} #{block.height}"
+      end
+      @images.each do |img_path, img|
+        lines.push "I #{img_path} #{img.x} #{img.y} #{img.width} #{img.height}"
+      end
+      fp = File.open(@sprite_file, 'w')
+      fp.write(lines.join("\n"))
+      fp.close
+    end
+
+    # Reads a sprite file and populates the images for this sprite
+    def read_file
+      return unless File.exists? @sprite_file
+      lines = File.readlines(@sprite_file)
+      return if lines.empty?
+      dims = lines.delete_at(0).chomp.split(' ')
+      @width = dims[0].to_i
+      @height = dims[2].to_i
+
+      # This is to handle repeating sprites
+      repeat = false
+      repeat = lines.delete_at(0).match(/Repeat (\w+)/)[1].to_sym if lines[0] =~ /Repeat \w+/
+      # We want to make sure the repeating type matches
+      return unless repeat == @options[:repeat]
+      @options[:repeat] = repeat
+
+      lines.each do |line|
+        line_parts = line.chomp.split(' ')
+        if line_parts[0] == 'B'
+          @blocks.push Block.new(line_parts[1].to_i, line_parts[2].to_i, line_parts[3].to_i, line_parts[4].to_i)
+        elsif line_parts[0] == 'I'
+          img = Image.new(line_parts[1], self, line_parts[2].to_i, line_parts[3].to_i, line_parts[4].to_i, line_parts[5].to_i)
+          @images[img.path] = img
+        end
+      end
+    end
+
+    # Positions the images in the sprite
+    def pack
+      @width = 0
+      @height = 0
+      
+      @image_queue.each do |img|
+        @images[img.path] = img
+      end
+      @image_queue = []
+      
+      return if @images.empty?
+      
+      class_name = @options[:pack_type].to_s.capitalize.gsub(/_([a-z]+)/) {|x| $1.capitalize}
+
+      if @options[:repeat]
+        if @options[:repeat] == :vertical
+          require "ruby_sprites/packer/horizontal_stack"
+          dims = Packer::HorizontalStack.pack(@images.values)
+	  dims[:height] = 1
+        elsif @options[:repeat] == :horizontal
+          require "ruby_sprites/packer/vertical_stack"
+          dims = Packer::VerticalStack.pack(@images.values)
+	  dims[:width] = 1
+        else
+          throw Exception.new('Invalid repeat type')
+        end
+      else
+        begin
+          dims = Packer.const_get(class_name.to_sym).pack(@images.values)
+        rescue NameError
+          require "ruby_sprites/packer/#{@options[:pack_type].to_s}"
+          dims = Packer.const_get(class_name.to_sym).pack(@images.values)
+        rescue LoadError
+          throw Exception.new('pack_type is invalid')
+        end
+      end
+
+      @width = dims[:width]
+      @height = dims[:height]
+
+    end
+
+    # Splits a block in multiple parts if needed to accommodate an image
+    def split_block(img, block)
+      if block.nil?
+        if img.width > @width
+          @blocks.push Block.new(@width, 0, img.width - @width, @height) if @height > 0
+          @width = img.width
+        end
+
+        img.x = 0
+        img.y = @height
+        @images[img.path] = img
+        @blocks.concat Block.new(0, @height, @width, img.height).split(img)
+        @height += img.height
+      else
+        img.x = block.x
+        img.y = block.y
+        @images[img.path] = img
+        @blocks.concat @blocks.delete(block).split(img)
+      end
+    end
+  end
+end

data/lib/lash-sprites/version.rb

@@ -0,0 +1,5 @@
+module Lash
+  module Sprites
+    VERSION = "0.3.1"
+  end
+end

data/test/b_graphics.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/ruby
+
+test_dir = File.dirname(__FILE__)
+
+$:.unshift File.join(test_dir, '../lib')
+
+require 'ruby_sprites/sprite'
+require 'benchmark'
+
+n = 10
+puts "#{n} Iterations"
+
+Benchmark.bmbm(10) do |r|
+  RubySprites::Sprite.graphics_managers.each do |key, val|
+    r.report("#{val.const_get(:DESCRIPTION)}:") {
+      for i in 1..n
+        sprite = RubySprites::Sprite.new('sprite.png', test_dir, {:graphics_manager => key, :force_update => true})
+        (1..60).each do |x|
+          sprite.add_image("imgs/#{x}.png")
+        end
+        sprite.update
+      end
+    }
+  end
+  r.report("No force:") {
+    for i in 1..n;
+      sprite = RubySprites::Sprite.new('sprite.png', test_dir, {:force_update => false})
+      (1..60).each do |x|
+        sprite.add_image("imgs/#{x}.png")
+      end
+      sprite.update
+    end
+  }
+end
+
+File.unlink(File.join(test_dir, 'sprite.png')) if File.exists? File.join(test_dir, 'sprite.png')
+File.unlink(File.join(test_dir, 'sprite.png.sprite')) if File.exists? File.join(test_dir, 'sprite.png.sprite')