spritesheet-creator/dist/packer.js

Spritesheet Creator

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = pack;

var _binpacking = _interopRequireDefault(require("binpacking"));

var AlgorithmFuncs = {
  'binpacking': binpackingStrict,
  'growing-binpacking': growingBinpacking,
  'horizontal': horizontal,
  'vertical': vertical
};

function pack(_ref) {
  var algorithm = _ref.algorithm,
      files = _ref.files,
      options = _ref.options;

  if (!AlgorithmFuncs[algorithm]) {
    throw new Error("packing algorithm '".concat(algorithm, "' not supported, supported algorithms: ").concat(Object.keys(AlgorithmFuncs).join(',')));
  }

  AlgorithmFuncs[algorithm](files, options);
}

function prepareData(files) {
  return files.map(function (file) {
    return {
      w: file.padded.width,
      h: file.padded.height
    };
  });
}

function injectData(data, files) {
  var idx = 0;
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var item = _step.value;

      if (!item.fit) {
        throw new Error("".concat(files[idx].name, " doesn't fit to texture"));
      }

      files[idx].padded.x = item.fit.x;
      files[idx].padded.y = item.fit.y;
      idx++;
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator["return"] != null) {
        _iterator["return"]();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
}

function growingBinpacking(files, options) {
  var packer = new _binpacking["default"].GrowingPacker();
  var data = prepareData(files);
  packer.fit(data);
  injectData(data, files);
  options.width = packer.root.w;
  options.height = packer.root.h;
}

function binpackingStrict(files, options) {
  if (!options.width || !options.height) {
    throw new Error("must specify texture size for binpacking");
  }

  var packer = new _binpacking["default"].Packer(options.width, options.height);
  var data = prepareData(files);
  packer.fit(data);
  injectData(data, files);
  options.width = packer.root.w;
  options.height = packer.root.h;
}

function vertical(files, options) {
  var y = 0;
  var maxWidth = 0;
  var _iteratorNormalCompletion2 = true;
  var _didIteratorError2 = false;
  var _iteratorError2 = undefined;

  try {
    for (var _iterator2 = files[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
      var item = _step2.value;
      item.padded.x = 0;
      item.padded.y = y;
      maxWidth = Math.max(maxWidth, item.padded.width);
      y += item.padded.height;
    }
  } catch (err) {
    _didIteratorError2 = true;
    _iteratorError2 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
        _iterator2["return"]();
      }
    } finally {
      if (_didIteratorError2) {
        throw _iteratorError2;
      }
    }
  }

  options.width = maxWidth;
  options.height = y;
}

function horizontal(files, options) {
  var x = 0;
  var maxHeight = 0;
  var _iteratorNormalCompletion3 = true;
  var _didIteratorError3 = false;
  var _iteratorError3 = undefined;

  try {
    for (var _iterator3 = files[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
      var item = _step3.value;
      item.padded.x = x;
      item.padded.y = 0;
      maxHeight = Math.max(maxHeight, item.padded.height);
      x += item.padded.width;
    }
  } catch (err) {
    _didIteratorError3 = true;
    _iteratorError3 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
        _iterator3["return"]();
      }
    } finally {
      if (_didIteratorError3) {
        throw _iteratorError3;
      }
    }
  }

  options.width = x;
  options.height = maxHeight;
}