spritesheet-creator/dist/data_output_plugins/godot3.js

Spritesheet Creator

"use strict";

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

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

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _fsExtra = _interopRequireDefault(require("fs-extra"));

var _path = _interopRequireDefault(require("path"));

var _mustache = _interopRequireDefault(require("mustache"));

function buildGodotResourcePath(projectRoot, relativePath) {
  var split = relativePath.split(_path["default"].sep);

  if (split[0].match(/^\./)) {
    throw new Error('texture output path is outside project dir');
  }

  return "res://".concat(split.join('/'));
}

function smartCreateTResName(pattern, filename) {
  var parsed = _path["default"].parse(filename); // find the non-wildcarded part of the pattern


  var patternPrefix = pattern.split('*')[0];

  var relPath = _path["default"].relative(patternPrefix, parsed.dir);

  return {
    relPath: relPath,
    base: parsed.name
  };
}

function generateGodot3TextureData(_ref) {
  var projectRoot, files, outputDataPath, outputTexturePath, log, stat, template, godotTexturePath, wroteFiles, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, file, tresContent, _smartCreateTResName, relPath, base, dirPath;

  return _regenerator["default"].async(function generateGodot3TextureData$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          projectRoot = _ref.projectRoot, files = _ref.files, outputDataPath = _ref.outputDataPath, outputTexturePath = _ref.outputTexturePath, log = _ref.log;

          if (projectRoot) {
            _context.next = 3;
            break;
          }

          throw new Error('projectRoot is required');

        case 3:
          log.info("exporting godot3 data files to ".concat(outputDataPath));

          if (!_fsExtra["default"].existsSync(outputDataPath)) {
            _fsExtra["default"].mkdirpSync(outputDataPath);
          }

          stat = _fsExtra["default"].statSync(outputDataPath);

          if (!(!stat || !stat.isDirectory())) {
            _context.next = 8;
            break;
          }

          throw new Error("output data path must be directory");

        case 8:
          template = _fsExtra["default"].readFileSync(_path["default"].join(__dirname, '../../templates/godot3.template'), 'utf-8');
          godotTexturePath = buildGodotResourcePath(projectRoot, _path["default"].relative(projectRoot, outputTexturePath));
          wroteFiles = 0;
          _iteratorNormalCompletion = true;
          _didIteratorError = false;
          _iteratorError = undefined;
          _context.prev = 14;

          for (_iterator = files[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            file = _step.value;
            tresContent = _mustache["default"].render(template, {
              godotTexturePath: godotTexturePath,
              x: file.real.x,
              y: file.real.y,
              width: file.real.width,
              height: file.real.height,
              margin: {
                x: file.margin.left,
                y: file.margin.up,
                width: file.margin.left + file.margin.right,
                height: file.margin.up + file.margin.down
              }
            });
            _smartCreateTResName = smartCreateTResName(file.pattern, file.name), relPath = _smartCreateTResName.relPath, base = _smartCreateTResName.base;
            dirPath = _path["default"].join(outputDataPath, relPath);

            _fsExtra["default"].mkdirpSync(dirPath);

            _fsExtra["default"].writeFileSync(_path["default"].join(dirPath, base) + '.tres', tresContent);

            wroteFiles++;
          }

          _context.next = 22;
          break;

        case 18:
          _context.prev = 18;
          _context.t0 = _context["catch"](14);
          _didIteratorError = true;
          _iteratorError = _context.t0;

        case 22:
          _context.prev = 22;
          _context.prev = 23;

          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
            _iterator["return"]();
          }

        case 25:
          _context.prev = 25;

          if (!_didIteratorError) {
            _context.next = 28;
            break;
          }

          throw _iteratorError;

        case 28:
          return _context.finish(25);

        case 29:
          return _context.finish(22);

        case 30:
          log.info("wrote ".concat(wroteFiles, " files"));

        case 31:
        case "end":
          return _context.stop();
      }
    }
  }, null, null, [[14, 18, 22, 30], [23,, 25, 29]]);
}