spritz 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.png

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org/'
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2015 Alexander Staubo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# Spritz
+
+Spritz is a tool for working with raw 2D assets to generate packed ones.
+
+Spritz can take a bunch of images and create tiled atlas texture bitmaps (also known as sprite sheets) for drawing many sprites from a single, packed bitmap image.
+
+## Features
+
+* Easily integrates into makefiles.
+* Writes easily readable JSON.
+* Supports all image formats supported by ImageMagick (ie., a lot).
+* Supports outputting to PNG and iOS `pvrtc` (includ gzipped) formats.
+* Can generates setup code for Moai.
+
+## Installation
+
+    gem install spritz
+
+## Installation from source
+
+    rake install
+
+## Dependencies
+
+* Ruby 1.8.7 or later.
+* ImageMagick 6.x.
+* `textiletool` from iOS SDK, if you want to generate `pvrtc` textures.
+
+## Usage
+
+This will generate a `dungeon` package:
+
+    spritz pack sheets/dungeon dungeon/*.png
+
+The command will generate:
+
+* `sheets/dungeon.0.png`, `sheets/dungeon.1.png` etc. — the texture bitmaps.
+* `sheets/dungeon.json.gz` — a gzipped JSON file describing the necessary vertex and texture coordinates for each image, ready to be used with drawing functions.
+
+For more options:
+
+    spritz pack --help
+
+## Plugins
+
+### Moai
+
+To generate a quad deck for [Moai](http://getmoai.com), use the option:
+
+    --moai:quad-decks myfile.lua
+
+## Tips
+
+For texture-mapping applications, you will want to specify `--padding 1` in order to ensure that texture coordinates round evenly to pixel coordinates.
+
+The default texture size is 2048x2048, which corresponds to the largest texture size allowed on the current generation of iOS devices.
+
+If an image does not fit within a single texture, it will be split across multiple textures. In other words, there is no upper limit on the dimensions of any image.
+
+## Package format
+
+The format of the package JSON file is:
+
+* `version`: File format version. Currently 1.
+* `textures`: A hash of textures, indexed by a numeric key.
+* `images`: A hash of image slices for each file. (An image will have multiple slices if its dimensions exceed the maximum texture dimensions.)
+
+Each texture hash has the following format:
+
+* `file`: File name, relative to the JSON file.
+* `format`: The format, eg. `png`.
+
+Each image hash has the following format:
+
+* `i`: The index of the texture, which can be looked up in the `textures` key.
+* `v`: The vertex coordinates for this slice.
+* `t`: The texture coordinates for this slice.
+* `w`: The width of the slice.
+* `h`: The haight of the slice.
+* `r`: Will be `true` if rotated -90 degrees.
+
+## Credits
+
+The "MaxRects" algorithm was ported from C++ code originally by Jukka Jylänki.
+
+## License
+
+See accompanying `LICENSE` file.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/TODO.md

@@ -0,0 +1,2 @@
+* Generate collision outlines
+* Optimize per-texture for bitmap format and compression: RGBA 4444, RGBA 5551 etc.

data/bin/spritz

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError => e
+  abort "Rubygems must be installed."
+end
+
+require 'spritz'
+
+Spritz::CLI.new.run!

data/lib/spritz.rb

@@ -0,0 +1,13 @@
+require 'tempfile'
+require 'rmagick'
+require 'optparse'
+require 'yajl/json_gem'
+require 'zlib'
+
+require 'spritz/plugins/moai_plugin'
+require 'spritz/version'
+require 'spritz/logger'
+require 'spritz/rect'
+require 'spritz/max_rects_packer'
+require 'spritz/package'
+require 'spritz/cli'

data/lib/spritz/cli.rb

@@ -0,0 +1,108 @@
+module Spritz
+
+  class CLI
+
+    def run!(args = ARGV)
+      args.options do |opts|
+        opts.banner = %{
+  Usage:
+    #{File.basename($0)} pack [OPTIONS] PACKAGE FILE ...
+    #{File.basename($0)} pack -h | --help
+
+  }
+        opts.on("-h", "--help", "Show this help message.") do
+          puts opts
+          exit
+        end
+        opts.on("-v", "--version", "Show version.") do
+          puts Spritz::VERSION
+          exit
+        end
+        opts.order! { |x| opts.terminate(x) }
+        if args.empty?
+          abort "Nothing to do. Run with -h for help."
+        end
+      end
+
+      command = args.shift
+      case command
+        when 'pack'
+          pack_command(args)
+        else
+          abort "Unknown command '#{command}'. Run with -h for help."
+      end
+    end
+
+    def pack_command(args)
+      texture_width = nil
+      texture_height = nil
+      padding = 0
+      format = nil
+      quiet = false
+      steps = []
+
+      args.options do |opts|
+        opts.banner = "Usage: #{File.basename($0)} pack [OPTIONS] PACKAGE FILE ...\n\n"
+        opts.on("-h", "--help", "Show this help message.") do
+          puts opts
+          exit
+        end
+        opts.on("-q", "--[no-]quiet", "Don't output anything.") do |v|
+          quiet = !!v
+        end
+        opts.on("-s", "--size WIDTHxHEIGHT", String,
+          "Maximum texture size (defaults to 2048x2048)") do |v|
+          if v =~ /(\d+)x(\d+)/i
+            texture_width, texture_height = $1.to_i, $2.to_i
+          else
+            abort "Expected WIDTHxHEIGHT, got #{v.inspect}"
+          end
+        end
+        opts.on("--padding PIXELS", Integer,
+          "Padding between packed images (defaults to 0)") do |v|
+          padding = v
+        end
+        opts.on("-f FORMAT", "--format FORMAT", String,
+          "Bitmap format for textures. Defaults to 'png', may be set to 'pvrtc'",
+          "(requires textiletool from iOS SDK) or 'pvrtc-gz' (same as pvrtc,",
+          "but gzip-compressed).") do |v|
+          unless %w(png pvrtc pvrtc-gz).include?(v.downcase)
+            abort "Unexpected format #{v.inspect}"
+          end
+          format = v.to_sym
+        end
+
+        Plugins::MoaiPlugin.add_options(opts, steps)
+
+        opts.order! { |x| opts.terminate(x) }
+        if args.empty?
+          abort "Nothing to do. Run with -h for help."
+        end
+      end
+
+      package_name = args.shift
+      abort "Package name not specified." unless package_name
+
+      Logger.instance.device = $stdout unless quiet
+
+      package = Spritz::Package.new(
+        :name => package_name,
+        :width => texture_width,
+        :height => texture_height,
+        :padding => padding,
+        :format => format)
+      args.each do |file_glob|
+        Dir.glob(file_glob).each do |file_name|
+          package.add_file(file_name)
+        end
+      end
+      package.write
+
+      steps.each do |step|
+        step.call(package)
+      end
+    end
+
+  end
+
+end

data/lib/spritz/logger.rb

@@ -0,0 +1,54 @@
+require 'singleton'
+
+module Spritz
+
+  class Logger
+
+    include Singleton
+
+    attr_accessor :device
+
+    def self.log_write(*args, &block)
+      instance.log_write(*args, &block)
+    end
+
+    def self.log_action(*args)
+      instance.log_action(*args)
+    end
+
+    def self.log(*args)
+      instance.log(*args)
+    end
+
+    def log_write(path, &block)
+      if File.exist?(path)
+        log_action "Overwrite", path
+      else
+        log_action "Create", path
+      end
+      yield path
+    end
+
+    def log_action(what, *rest)
+      case what
+        when 'Render'
+          color = '33'
+        when 'Overwrite'
+          color = '31'
+        when 'Create'
+          color = '32'
+        else
+          color = '36'
+      end
+      log("\e[#{color};1m%12s\e[0m %s\n" % [what, rest.join(' ')])
+    end
+
+    def log(line)
+      if @device
+        @device.write(line)
+      end
+    end
+
+  end
+
+end

data/lib/spritz/max_rects_packer.rb

@@ -0,0 +1,266 @@
+module Spritz
+
+  # Adapted from C++ version originally by Jukka Jylänki.
+  class MaxRectsPacker
+
+    def initialize(width, height)
+      @width = width
+      @height = height
+      @free_rects = [Rect.new(nil, 0, 0, @width, @height)]
+      @used_rects = []
+    end
+
+    def insert(value, width, height)
+      best_score1 = 2 ** 32
+      best_score2 = 2 ** 32
+      best_rect = nil
+
+      [:bottom_left, :best_short_side_fit, :best_long_side_fit, :best_area_fit,
+        :contact_point_rule].each do |method|
+        new_rect, score1, score2 = self.send("find_position_for_#{method}",
+          width, height, 2 ** 32, 2 ** 32)
+        if new_rect
+          score1 = -score1 if method == :contact_point_rule
+          if new_rect and score1 < best_score1 or (score1 == best_score1 and score2 < best_score2)
+            best_score1 = score1
+            best_score2 = score2
+            best_rect = new_rect
+          end
+        end
+      end
+
+      if best_rect
+        @free_rects.dup.each do |free|
+          if split_free_node(free, best_rect)
+            @free_rects.delete(free)
+          end
+        end
+
+        @free_rects.dup.each_with_index do |free, i|
+          (@free_rects[(i + 1)..-1] || []).each do |free2|
+            @free_rects.delete(free) if free.contained_in?(free2)
+            @free_rects.delete(free2) if free2.contained_in?(free)
+          end
+        end
+
+        best_rect.value = value
+        @used_rects.push(best_rect)
+        true
+      else
+        false
+      end
+    end
+
+    def coverage_ratio
+      return @used_rects.inject(0) { |sum, rect| sum + rect.width * rect.height } /
+        (@width * @height).to_f
+    end
+
+    def rects
+      @used_rects
+    end
+
+    attr_reader :width
+    attr_reader :height
+
+    private
+
+      def find_position_for_bottom_left(width, height, best_y, best_x)
+        best_rect = nil
+        best_y = 2 ** 32
+        @free_rects.each do |free|
+          if free.width >= width and free.height >= height
+            top_side_y = free.y + height
+            if top_side_y < best_y or (top_side_y == best_y and free.x < best_x)
+              best_rect = Rect.new(nil, free.x, free.y, width, height)
+              best_y = top_side_y
+              best_x = free.x
+            end
+          end
+          if free.width >= height and free.height >= width
+            top_side_y = free.y + width
+            if top_side_y < best_y or (top_side_y == best_y and free.x < best_x)
+              best_rect = Rect.new(nil, free.x, free.y, height, width, true)
+              best_y = top_side_y
+              best_x = free.x
+            end
+          end
+        end
+        return best_rect, best_y, best_x
+      end
+
+      def find_position_for_best_short_side_fit(width, height,
+        best_short_side_fit, best_long_side_fit)
+        best_rect = nil
+        best_short_side_fit = 2 ** 32
+        @free_rects.each do |free|
+          if free.width >= width and free.height >= height
+            leftover_horiz = (free.width - width).abs
+            leftover_vert = (free.height - height).abs
+            short_side_fit = [leftover_horiz, leftover_vert].min
+            long_side_fit = [leftover_horiz, leftover_vert].max
+            if short_side_fit < best_short_side_fit or
+              (short_side_fit == best_short_side_fit and long_side_fit < best_long_side_fit)
+              best_rect = Rect.new(nil, free.x, free.y, width, height)
+              best_short_side_fit = short_side_fit
+              best_long_side_fit = long_side_fit
+            end
+          end
+          if free.width >= height and free.height >= width
+            flipped_leftover_horiz = (free.width - height).abs
+            flipped_leftover_vert = (free.height - width).abs
+            flipped_short_side_fit = [flipped_leftover_horiz, flipped_leftover_vert].min
+            flipped_long_side_fit = [flipped_leftover_horiz, flipped_leftover_vert].max
+            if flipped_short_side_fit < best_short_side_fit or
+              (flipped_short_side_fit == best_short_side_fit and flipped_long_side_fit < best_long_side_fit)
+              best_rect = Rect.new(nil, free.x, free.y, height, width, true)
+              best_short_side_fit = flipped_short_side_fit
+              best_long_side_fit = flipped_long_side_fit
+            end
+          end
+        end
+        return best_rect, best_short_side_fit, best_long_side_fit
+      end
+
+      def find_position_for_best_long_side_fit(width, height,
+        best_short_side_fit, best_long_side_fit)
+        best_rect = nil
+        best_long_side_fit = 2 ** 32
+        @free_rects.each do |free|
+          if free.width >= width and free.height >= height
+            leftover_horiz = (free.width - width).abs
+            leftover_vert = (free.height - height).abs
+            short_side_fit = [leftover_horiz, leftover_vert].min
+            long_side_fit = [leftover_horiz, leftover_vert].max
+            if long_side_fit < best_long_side_fit or
+              (long_side_fit == best_long_side_fit and short_side_fit < best_short_side_fit)
+              best_rect = Rect.new(nil, free.x, free.y, width, height)
+              best_short_side_fit = short_side_fit
+              best_long_side_fit = long_side_fit
+            end
+          end
+          if free.width >= height and free.height >= width
+            leftover_horiz = (free.width - height).abs
+            leftover_vert = (free.height - width).abs
+            short_side_fit = [leftover_horiz, leftover_vert].min
+            long_side_fit = [leftover_horiz, leftover_vert].max
+            if long_side_fit < best_long_side_fit or
+              (long_side_fit == best_long_side_fit and short_side_fit < best_short_side_fit)
+              best_rect = Rect.new(nil, free.x, free.y, height, width, true)
+              best_short_side_fit = short_side_fit
+              best_long_side_fit = long_side_fit
+            end
+          end
+        end
+        return best_rect, best_short_side_fit, best_long_side_fit
+      end
+
+      def find_position_for_best_area_fit(width, height,
+        best_area_fit, best_short_side_fit)
+        best_rect = nil
+        best_area_fit = 2 ** 32
+        @free_rects.each do |free|
+          area_fit = free.width * free.height - width * height
+          if free.width >= width and free.height >= height
+            leftover_horiz = (free.width - width).abs
+            leftover_vert = (free.height - height).abs
+            short_side_fit = [leftover_horiz, leftover_vert].min
+            if area_fit < best_area_fit or
+              (area_fit == best_area_fit and short_side_fit < best_short_side_fit)
+              best_rect = Rect.new(nil, free.x, free.y, width, height)
+              best_short_side_fit = short_side_fit
+              best_area_fit = area_fit
+            end
+          end
+          if free.width >= height and free.height >= width
+            leftover_horiz = (free.width - height).abs
+            leftover_vert = (free.height - width).abs
+            short_side_fit = [leftover_horiz, leftover_vert].min
+            if area_fit < best_area_fit or
+              (area_fit == best_area_fit and short_side_fit < best_short_side_fit)
+              best_rect = Rect.new(nil, free.x, free.y, height, width, true)
+              best_short_side_fit = short_side_fit
+              best_area_fit = area_fit
+            end
+          end
+        end
+        return best_rect, best_area_fit, best_short_side_fit
+      end
+
+      def common_interval_length(a, b)
+        if a.end < b.begin or b.end < a.begin
+          0
+        else
+          [a.end, b.end].min - [a.begin, b.begin].max
+        end
+      end
+
+      def contact_point_score_node(x, y, width, height)
+        score = 0
+        score += height if x == 0 or x + width == @width
+        score += width if y == 0 or y + height == @height
+        @used_rects.each do |rect|
+          if rect.x == x + width or rect.x + rect.width == x
+            score += common_interval_length(
+              rect.y..(rect.y + rect.height),
+              y..(y + height))
+          end
+          if rect.y == y + height or rect.y + rect.height == y
+            score += common_interval_length(
+              rect.x..(rect.x + rect.width),
+              x..(x + width))
+          end
+        end
+        score
+      end
+
+      def find_position_for_contact_point_rule(width, height, best_contact_score, _)
+        best_rect = nil
+        best_contact_score = -1
+        @free_rects.each do |free|
+          if free.width >= width and free.height >= height
+            score = contact_point_score_node(free.x, free.y, width, height)
+            if score > best_contact_score
+              best_rect = Rect.new(nil, free.x, free.y, width, height)
+              best_contact_score = score
+            end
+          end
+          if free.width >= height and free.height >= width
+            score = contact_point_score_node(free.x, free.y, width, height)
+            if score > best_contact_score
+              best_rect = Rect.new(nil, free.x, free.y, height, width, true)
+              best_contact_score = score
+            end
+          end
+        end
+        return best_rect, best_contact_score, 0
+      end
+
+      def split_free_node(free, used)
+        if used.intersects?(free)
+          false
+        else
+          if used.x < free.x + free.width and used.x + used.width > free.x
+            if used.y > free.y and used.y < free.y + free.height
+              @free_rects.push(Rect.new(nil, free.x, free.y, free.width, used.y - free.y))
+            end
+            if used.y + used.height < free.y + free.height
+              @free_rects.push(Rect.new(nil, free.x, used.y + used.height,
+                free.width, free.y + free.height - (used.y + used.height)))
+            end
+          end
+          if used.y < free.y + free.height and used.y + used.height > free.y
+            if used.x > free.x and used.x < free.x + free.width
+              @free_rects.push(Rect.new(nil, free.x, free.y, used.x - free.x, free.height))
+            end
+            if used.x + used.width < free.x + free.width
+              @free_rects.push(Rect.new(nil, used.x + used.width, free.y,
+                free.x + free.width - (used.x + used.width), free.height))
+            end
+          end
+          true
+        end
+      end
+
+  end
+end

data/lib/spritz/package.rb

@@ -0,0 +1,249 @@
+module Spritz
+
+  class Package
+
+    class Slice
+
+      attr_reader :file_name, :x, :y, :width, :height, :padding
+
+      def initialize(file_name, x, y, width, height, padding)
+        @file_name, @x, @y, @width, @height, @padding =
+          file_name, x, y, width, height, padding
+      end
+
+      def image
+        image = Magick::Image.from_blob(File.read(@file_name)).first
+        image.crop!(@x, @y, @width, @height)
+        image
+      end
+
+    end
+
+    attr_reader :name
+    attr_reader :texture_width, :texture_height
+    attr_reader :format
+    attr_reader :padding
+    attr_reader :sheets
+
+    def initialize(options = {})
+      @name = options[:name]
+      @texture_width = options[:width] || 2048
+      @texture_height = options[:height] || 2048
+      @format = options[:format] || :png
+      @padding = options[:padding]
+      @sheets = []
+      @rendered_images = {}
+    end
+
+    def add_file(file_name)
+      Logger.log_action "Add", file_name
+
+      image = Magick::Image.ping(file_name).first
+      t_width = @texture_width - @padding * 2
+      t_height = @texture_height - @padding * 2
+      (0..(image.columns / t_width.to_f).floor).to_a.each do |tile_x|
+        (0..(image.rows / t_height.to_f).floor).to_a.each do |tile_y|
+          if image.columns - tile_x * t_width + @padding > 0 and
+            image.rows - tile_y * t_height + @padding > 0
+            add_slice(
+              Slice.new(file_name,
+                tile_x * t_width,
+                tile_y * t_height,
+                [image.columns - tile_x * t_width + @padding, t_width].min,
+                [image.rows - tile_y * t_height + @padding, t_height].min,
+                @padding))
+          end
+        end
+      end
+    end
+
+    def add_slice(slice)
+      inserted = false
+      @sheets.each do |sheet|
+        if sheet.insert(slice, slice.width, slice.height)
+          inserted = true
+          break
+        end
+      end
+      unless inserted
+        sheet = new_sheet!
+        unless sheet.insert(slice, slice.width, slice.height)
+          raise "Unexpectedly unable to add image to any sheet: #{slice.file_name}"
+        end
+      end
+    end
+
+    def render
+      @sheets.each_with_index do |sheet, index|
+        Logger.log_action "Render", "Sheet ##{index}"
+        @rendered_images[index] ||= render_sheet(sheet)
+      end
+      @rendered_images
+    end
+
+    def write
+      render
+
+      @rendered_images.each_pair do |index, image|
+        base_name = "#{@name}.#{index}"
+        case @format
+          when :png
+            Logger.log_write(file_name_for_format(base_name, @format)) do |path|
+              File.open(path, 'w:binary') do |file|
+                file.write as_png(image)
+              end
+            end
+          when :pvrtc, :'pvrtc-gz'
+            Logger.log_write(file_name_for_format(base_name, @format)) do |path|
+              Tempfile.open('spritz') do |tempfile|
+                tempfile.write as_png(image)
+                tempfile.close
+
+                texturetool_flags = '--alpha-is-opacity --bits-per-pixel-4'
+
+                system("texturetool -f raw -e PVRTC #{texturetool_flags} " <<
+                  "-o #{file_name_for_format base_name, :pvrtc} #{tempfile.path}")
+                unless $?.exited? and $?.exitstatus == 0
+                  raise "Failed to run texturetool. Is it installed?"
+                end
+
+                if @format == :'pvrtc-gz'
+                  system("gzip -c #{file_name_for_format base_name, :pvrtc} >#{path}")
+                  unless $?.exited? and $?.exitstatus == 0
+                    raise "Failed to run gzip. Is it installed?"
+                  end
+                end
+              end
+            end
+        end
+        image.destroy!
+      end
+
+      rects_by_slice = {}
+      @sheets.each_with_index do |sheet, index|
+        sheet.rects.each do |rect|
+          (rects_by_slice[rect.value.file_name] ||= []).push([index, rect])
+        end
+      end
+
+      frames = {}
+      rects_by_slice.each do |file_name, rects|
+        key = file_name.gsub(/\.\w+$/, '')
+        frames[key] = rects.map { |(sheet_index, rect)|
+          {
+            :i => sheet_index,
+            :w => rect.width,
+            :h => rect.height,
+            :r => rect.rotated?,
+            :v => vertex_coords_for(rect),
+            :t => texture_coords_for(rect)
+          }
+        }
+      end
+      structure = {
+        :version => 1,
+        :textures => Hash[*(0...@sheets.length).to_a.map { |i|
+          [i, {
+            :format => @format,
+            :file => "#{File.basename(@name)}.#{i}.#{@format}"
+          }]
+        }.flatten],
+        :texture_width => @texture_width,
+        :texture_height => @texture_height,
+        :padding => @padding,
+        :frames => frames
+      }
+
+      Logger.log_write("#{@name}.json.gz") do |path|
+        Zlib::GzipWriter.open(path) do |file|
+          file.write JSON.pretty_generate(structure)
+        end
+      end
+    end
+
+    def file_name_for_format(base, format)
+      case format
+        when :png, :pvrtc
+          return "#{base}.#{format}"
+        when :'pvrtc-gz'
+          return "#{base}.pvr.gz"
+      end
+    end
+
+    private
+
+      def as_png(image)
+        image.to_blob {
+          self.format = 'png'
+          self.compression = Magick::ZipCompression
+          self.depth = 16
+          self.quality = 100
+        }
+      end
+
+      def vertex_coords_for(rect)
+        x1 = 0
+        y1 = 0
+        x2 = rect.width
+        y2 = rect.height
+        return [
+          [x1, y1],
+          [x2, x1],
+          [y1, y2],
+          [x2, y2]
+        ]
+      end
+
+      def texture_coords_for(rect)
+        if @padding > 0
+          tx1 = ((2 * rect.x) + 1) / (2 * @texture_width.to_f)
+          ty1 = ((2 * rect.y) + 1) / (2 * @texture_height.to_f)
+          if rect.rotated?
+            tx2 = (((2 * rect.x) + 1) + (rect.height * 2) - 2) / (2 * @texture_width.to_f)
+            ty2 = (((2 * rect.y) + 1) + (rect.width * 2) - 2) / (2 * @texture_height.to_f)
+          else
+            tx2 = (((2 * rect.x) + 1) + (rect.width * 2) - 2) / (2 * @texture_width.to_f)
+            ty2 = (((2 * rect.y) + 1) + (rect.height * 2) - 2) / (2 * @texture_height.to_f)
+          end
+        else
+          tx1 = rect.x / @texture_width.to_f
+          ty1 = rect.y / @texture_height.to_f
+          if rect.rotated?
+            tx2 = (rect.x + rect.height) / @texture_height.to_f
+            ty2 = (rect.y + rect.width) / @texture_width.to_f
+          else
+            tx2 = (rect.x + rect.width) / @texture_width.to_f
+            ty2 = (rect.y + rect.height) / @texture_height.to_f
+          end
+        end
+        return [
+          [tx1, ty1],
+          [tx2, ty1],
+          [tx2, ty2],
+          [tx1, ty2]
+        ]
+      end
+
+      def render_sheet(sheet)
+        image = Magick::Image.new(@texture_width, @texture_height) do |i|
+          i.background_color = 'transparent'
+        end
+        sheet.rects.each do |rect|
+          slice = rect.value
+          frame = slice.image
+          frame.rotate!(-90) if rect.rotated?
+          image.composite!(frame, Magick::NorthWestGravity,
+            @padding + rect.x, @padding + rect.y, Magick::ReplaceCompositeOp)
+        end
+        image
+      end
+
+      def new_sheet!
+        sheet = MaxRectsPacker.new(@texture_width - @padding, @texture_height - @padding)
+        @sheets.push(sheet)
+        sheet
+      end
+
+  end
+
+end

data/lib/spritz/plugins/moai_plugin.rb

@@ -0,0 +1,93 @@
+module Spritz
+  module Plugins
+
+    class MoaiPlugin
+
+      def self.add_options(opts, steps)
+        opts.on("--moai:quad-decks PATH", String,
+          "Generate code to create quads and decks. One MOAIGfxQuadDeck2D is " \
+          "created for each base name, with suffix number being the index.") do |v|
+          steps.push(MoaiQuadDeckStep.new(v))
+        end
+      end
+
+      class MoaiQuadDeckStep
+
+        def initialize(path)
+          @path = path
+          @path = "#{@path}.lua" unless path =~ /\.lua$/
+        end
+
+        def call(package)
+          grouped, indexes = {}, {}
+
+          package.sheets.each_with_index do |sheet, index|
+            sheet.rects.each do |rect|
+              if rect.value.file_name =~ /^(.+)\d+.*/
+                key = $1.gsub(/\//, '_').gsub(/[_\.\-]+$/, '')
+                if indexes.include?(key) and indexes[key] != index
+                  abort "Image #{rect.value.file_name} straddles multiple textures. Not supported yet, sorry."
+                end
+                (grouped[key] ||= []).push(rect)
+                indexes[key] = index
+              end
+            end
+          end
+
+          script = []
+          script << "-- Generated by Spritz (https://github.com/atombender/spritz)"
+          if grouped.any?
+            script << ''
+            package.sheets.each_with_index do |sheet, index|
+              texture_variable = "texture#{index}"
+              base_name = "#{package.name}.#{index}"
+              script << %{local #{texture_variable} = MOAITexture.new()}
+              script << %{#{texture_variable}:load('#{package.file_name_for_format(base_name, package.format)}')}
+              script << %{#{texture_variable}:setFilter(MOAITexture.GL_LINEAR, MOAITexture.GL_LINEAR)}
+            end
+            grouped.each do |key, rects|
+              index = indexes[key]
+              sheet = package.sheets[index]
+              quad_variable = "#{key}_quad"
+
+              script << %{#{quad_variable} = MOAIGfxQuadDeck2D.new()}
+              script << %{#{quad_variable}:setTexture(texture#{index})}
+              script << %{#{quad_variable}:reserve(#{rects.length})}
+              rects.each_with_index do |rect, i|
+                box = [-rect.width / 2.0, -rect.height / 2.0, rect.width / 2.0, rect.height / 2.0]
+
+                quad = [
+                  rect.x / sheet.width.to_f,
+                  rect.y / sheet.height.to_f,
+
+                  (rect.x + rect.width) / sheet.width.to_f,
+                  rect.y / sheet.height.to_f,
+
+                  (rect.x + rect.width) / sheet.width.to_f,
+                  (rect.y + rect.height) / sheet.height.to_f,
+
+                  rect.x / sheet.width.to_f,
+                  (rect.y + rect.height) / sheet.height.to_f,
+                ]
+
+                script << %{#{quad_variable}:setRect(#{i + 1}, #{box.join(', ')})}
+                script << %{#{quad_variable}:setUVQuad(#{i + 1}, #{quad.join(', ')})}
+              end
+            end
+          else
+            script << "-- No images"
+          end
+
+          Logger.log_write(@path) do |path|
+            File.open(path, 'w') do |f|
+              f.write script.join("\n")
+              f.write "\n"
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spritz/rect.rb

@@ -0,0 +1,36 @@
+module Spritz
+
+  class Rect
+
+    attr_accessor :x, :y, :width, :height, :value
+
+    def initialize(value, x, y, width, height, rotated = false)
+      @value, @x, @y, @width, @height, @rotated = value, x, y, width, height, rotated
+    end
+
+    def rotated?
+      @rotated
+    end
+
+    def intersects?(other)
+      return @x >= other.x + other.width || @x + @width <= other.x ||
+        @y >= other.y + other.height || @y + @height <= other.y
+    end
+
+    def contained_in?(other)
+      return @x >= other.x && @y >= other.y &&
+        @x + @width <= other.x + other.width &&
+        @y + @height <= other.y + other.height
+    end
+
+    def x2
+      @x + @width
+    end
+
+    def y2
+      @y + @height
+    end
+
+  end
+
+end

data/lib/spritz/version.rb

@@ -0,0 +1,3 @@
+module Spritz
+  VERSION = "0.0.2"
+end

data/spritz.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/spritz/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Alexander Staubo"]
+  gem.email         = ["alex@purefiction.net"]
+  gem.description   = gem.summary =
+    %q{Tool for packing images into compact "sprite sheets" and otherwise managing 2D engine assets}
+  gem.homepage      = 'https://github.com/alexstaubo/spritz'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "spritz"
+  gem.require_paths = ["lib"]
+  gem.version       = Spritz::VERSION
+
+  gem.add_runtime_dependency 'rmagick', ['= 2.13.4']
+  gem.add_runtime_dependency 'yajl-ruby', ['~> 1.1']
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: spritz
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Staubo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.13.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.13.4
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tool for packing images into compact "sprite sheets" and otherwise managing
+  2D engine assets
+email:
+- alex@purefiction.net
+executables:
+- spritz
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- TODO.md
+- bin/spritz
+- lib/spritz.rb
+- lib/spritz/cli.rb
+- lib/spritz/logger.rb
+- lib/spritz/max_rects_packer.rb
+- lib/spritz/package.rb
+- lib/spritz/plugins/moai_plugin.rb
+- lib/spritz/rect.rb
+- lib/spritz/version.rb
+- spritz.gemspec
+homepage: https://github.com/alexstaubo/spritz
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: Tool for packing images into compact "sprite sheets" and otherwise managing
+  2D engine assets
+test_files: []
+has_rdoc: