opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/libs/potpack.module.js

@@ -0,0 +1,171 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.potpackModule = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.potpack = potpack;
+
+  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+  /**
+   * potpack - by [@mourner](https://github.com/mourner)
+   * 
+   * A tiny JavaScript function for packing 2D rectangles into a near-square container, 
+   * which is useful for generating CSS sprites and WebGL textures. Similar to 
+   * [shelf-pack](https://github.com/mapbox/shelf-pack), but static (you can't add items 
+   * once a layout is generated), and aims for maximal space utilization.
+   *
+   * A variation of algorithms used in [rectpack2D](https://github.com/TeamHypersomnia/rectpack2D)
+   * and [bin-pack](https://github.com/bryanburgers/bin-pack), which are in turn based 
+   * on [this article by Blackpawn](http://blackpawn.com/texts/lightmaps/default.html).
+   * 
+   * @license
+   * ISC License
+   * 
+   * Copyright (c) 2018, Mapbox
+   * 
+   * Permission to use, copy, modify, and/or distribute this software for any purpose
+   * with or without fee is hereby granted, provided that the above copyright notice
+   * and this permission notice appear in all copies.
+   * 
+   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+   * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+   * FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+   * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+   * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+   * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+   * THIS SOFTWARE.
+   */
+  function potpack(boxes) {
+    // calculate total box area and maximum box width
+    var area = 0;
+    var maxWidth = 0;
+
+    var _iterator = _createForOfIteratorHelper(boxes),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var box = _step.value;
+        area += box.w * box.h;
+        maxWidth = Math.max(maxWidth, box.w);
+      } // sort the boxes for insertion by height, descending
+
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    boxes.sort(function (a, b) {
+      return b.h - a.h;
+    }); // aim for a squarish resulting container,
+    // slightly adjusted for sub-100% space utilization
+
+    var startWidth = Math.max(Math.ceil(Math.sqrt(area / 0.95)), maxWidth); // start with a single empty space, unbounded at the bottom
+
+    var spaces = [{
+      x: 0,
+      y: 0,
+      w: startWidth,
+      h: Infinity
+    }];
+    var width = 0;
+    var height = 0;
+
+    var _iterator2 = _createForOfIteratorHelper(boxes),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _box = _step2.value;
+
+        // look through spaces backwards so that we check smaller spaces first
+        for (var i = spaces.length - 1; i >= 0; i--) {
+          var space = spaces[i]; // look for empty spaces that can accommodate the current box
+
+          if (_box.w > space.w || _box.h > space.h) continue; // found the space; add the box to its top-left corner
+          // |-------|-------|
+          // |  box  |       |
+          // |_______|       |
+          // |         space |
+          // |_______________|
+
+          _box.x = space.x;
+          _box.y = space.y;
+          height = Math.max(height, _box.y + _box.h);
+          width = Math.max(width, _box.x + _box.w);
+
+          if (_box.w === space.w && _box.h === space.h) {
+            // space matches the box exactly; remove it
+            var last = spaces.pop();
+            if (i < spaces.length) spaces[i] = last;
+          } else if (_box.h === space.h) {
+            // space matches the box height; update it accordingly
+            // |-------|---------------|
+            // |  box  | updated space |
+            // |_______|_______________|
+            space.x += _box.w;
+            space.w -= _box.w;
+          } else if (_box.w === space.w) {
+            // space matches the box width; update it accordingly
+            // |---------------|
+            // |      box      |
+            // |_______________|
+            // | updated space |
+            // |_______________|
+            space.y += _box.h;
+            space.h -= _box.h;
+          } else {
+            // otherwise the box splits the space into two spaces
+            // |-------|-----------|
+            // |  box  | new space |
+            // |_______|___________|
+            // | updated space     |
+            // |___________________|
+            spaces.push({
+              x: space.x + _box.w,
+              y: space.y,
+              w: space.w - _box.w,
+              h: _box.h
+            });
+            space.y += _box.h;
+            space.h -= _box.h;
+          }
+
+          break;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    return {
+      w: width,
+      // container width
+      h: height,
+      // container height
+      fill: area / (width * height) || 0 // space utilization
+
+    };
+  }
+});