opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/utils/GeometryCompressionUtils.js

@@ -0,0 +1,468 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./PackedPhongMaterial.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./PackedPhongMaterial.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.PackedPhongMaterial);
+    global.GeometryCompressionUtils = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _PackedPhongMaterial) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.compressNormals = compressNormals;
+  _exports.compressPositions = compressPositions;
+  _exports.compressUvs = compressUvs;
+
+  /**
+   * Octahedron and Quantization encodings based on work by:
+   *
+   * @link https://github.com/tsherif/mesh-quantization-example
+   *
+   */
+
+  /**
+   * Make the input mesh.geometry's normal attribute encoded and compressed by 3 different methods.
+   * Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the normal data.
+   *
+   * @param {THREE.Mesh} mesh
+   * @param {String} encodeMethod		"DEFAULT" || "OCT1Byte" || "OCT2Byte" || "ANGLES"
+   *
+   */
+  function compressNormals(mesh, encodeMethod) {
+    if (!mesh.geometry) {
+      console.error('Mesh must contain geometry. ');
+    }
+
+    var normal = mesh.geometry.attributes.normal;
+
+    if (!normal) {
+      console.error('Geometry must contain normal attribute. ');
+    }
+
+    if (normal.isPacked) return;
+
+    if (normal.itemSize != 3) {
+      console.error('normal.itemSize is not 3, which cannot be encoded. ');
+    }
+
+    var array = normal.array;
+    var count = normal.count;
+    var result;
+
+    if (encodeMethod == 'DEFAULT') {
+      // TODO: Add 1 byte to the result, making the encoded length to be 4 bytes.
+      result = new Uint8Array(count * 3);
+
+      for (var idx = 0; idx < array.length; idx += 3) {
+        var encoded = defaultEncode(array[idx], array[idx + 1], array[idx + 2], 1);
+        result[idx + 0] = encoded[0];
+        result[idx + 1] = encoded[1];
+        result[idx + 2] = encoded[2];
+      }
+
+      mesh.geometry.setAttribute('normal', new _three.BufferAttribute(result, 3, true));
+      mesh.geometry.attributes.normal.bytes = result.length * 1;
+    } else if (encodeMethod == 'OCT1Byte') {
+      /**
+      * It is not recommended to use 1-byte octahedron normals encoding unless you want to extremely reduce the memory usage
+      * As it makes vertex data not aligned to a 4 byte boundary which may harm some WebGL implementations and sometimes the normal distortion is visible
+      * Please refer to @zeux 's comments in https://github.com/mrdoob/three.js/pull/18208
+      */
+      result = new Int8Array(count * 2);
+
+      for (var _idx = 0; _idx < array.length; _idx += 3) {
+        var _encoded = octEncodeBest(array[_idx], array[_idx + 1], array[_idx + 2], 1);
+
+        result[_idx / 3 * 2 + 0] = _encoded[0];
+        result[_idx / 3 * 2 + 1] = _encoded[1];
+      }
+
+      mesh.geometry.setAttribute('normal', new _three.BufferAttribute(result, 2, true));
+      mesh.geometry.attributes.normal.bytes = result.length * 1;
+    } else if (encodeMethod == 'OCT2Byte') {
+      result = new Int16Array(count * 2);
+
+      for (var _idx2 = 0; _idx2 < array.length; _idx2 += 3) {
+        var _encoded2 = octEncodeBest(array[_idx2], array[_idx2 + 1], array[_idx2 + 2], 2);
+
+        result[_idx2 / 3 * 2 + 0] = _encoded2[0];
+        result[_idx2 / 3 * 2 + 1] = _encoded2[1];
+      }
+
+      mesh.geometry.setAttribute('normal', new _three.BufferAttribute(result, 2, true));
+      mesh.geometry.attributes.normal.bytes = result.length * 2;
+    } else if (encodeMethod == 'ANGLES') {
+      result = new Uint16Array(count * 2);
+
+      for (var _idx3 = 0; _idx3 < array.length; _idx3 += 3) {
+        var _encoded3 = anglesEncode(array[_idx3], array[_idx3 + 1], array[_idx3 + 2]);
+
+        result[_idx3 / 3 * 2 + 0] = _encoded3[0];
+        result[_idx3 / 3 * 2 + 1] = _encoded3[1];
+      }
+
+      mesh.geometry.setAttribute('normal', new _three.BufferAttribute(result, 2, true));
+      mesh.geometry.attributes.normal.bytes = result.length * 2;
+    } else {
+      console.error('Unrecognized encoding method, should be `DEFAULT` or `ANGLES` or `OCT`. ');
+    }
+
+    mesh.geometry.attributes.normal.needsUpdate = true;
+    mesh.geometry.attributes.normal.isPacked = true;
+    mesh.geometry.attributes.normal.packingMethod = encodeMethod; // modify material
+
+    if (!(mesh.material instanceof _PackedPhongMaterial.PackedPhongMaterial)) {
+      mesh.material = new _PackedPhongMaterial.PackedPhongMaterial().copy(mesh.material);
+    }
+
+    if (encodeMethod == 'ANGLES') {
+      mesh.material.defines.USE_PACKED_NORMAL = 0;
+    }
+
+    if (encodeMethod == 'OCT1Byte') {
+      mesh.material.defines.USE_PACKED_NORMAL = 1;
+    }
+
+    if (encodeMethod == 'OCT2Byte') {
+      mesh.material.defines.USE_PACKED_NORMAL = 1;
+    }
+
+    if (encodeMethod == 'DEFAULT') {
+      mesh.material.defines.USE_PACKED_NORMAL = 2;
+    }
+  }
+  /**
+  	 * Make the input mesh.geometry's position attribute encoded and compressed.
+  	 * Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the position data.
+  	 *
+  	 * @param {THREE.Mesh} mesh
+  	 *
+  	 */
+
+
+  function compressPositions(mesh) {
+    if (!mesh.geometry) {
+      console.error('Mesh must contain geometry. ');
+    }
+
+    var position = mesh.geometry.attributes.position;
+
+    if (!position) {
+      console.error('Geometry must contain position attribute. ');
+    }
+
+    if (position.isPacked) return;
+
+    if (position.itemSize != 3) {
+      console.error('position.itemSize is not 3, which cannot be packed. ');
+    }
+
+    var array = position.array;
+    var encodingBytes = 2;
+    var result = quantizedEncode(array, encodingBytes);
+    var quantized = result.quantized;
+    var decodeMat = result.decodeMat; // IMPORTANT: calculate original geometry bounding info first, before updating packed positions
+
+    if (mesh.geometry.boundingBox == null) mesh.geometry.computeBoundingBox();
+    if (mesh.geometry.boundingSphere == null) mesh.geometry.computeBoundingSphere();
+    mesh.geometry.setAttribute('position', new _three.BufferAttribute(quantized, 3));
+    mesh.geometry.attributes.position.isPacked = true;
+    mesh.geometry.attributes.position.needsUpdate = true;
+    mesh.geometry.attributes.position.bytes = quantized.length * encodingBytes; // modify material
+
+    if (!(mesh.material instanceof _PackedPhongMaterial.PackedPhongMaterial)) {
+      mesh.material = new _PackedPhongMaterial.PackedPhongMaterial().copy(mesh.material);
+    }
+
+    mesh.material.defines.USE_PACKED_POSITION = 0;
+    mesh.material.uniforms.quantizeMatPos.value = decodeMat;
+    mesh.material.uniforms.quantizeMatPos.needsUpdate = true;
+  }
+  /**
+   * Make the input mesh.geometry's uv attribute encoded and compressed.
+   * Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the uv data.
+   *
+   * @param {THREE.Mesh} mesh
+   *
+   */
+
+
+  function compressUvs(mesh) {
+    if (!mesh.geometry) {
+      console.error('Mesh must contain geometry property. ');
+    }
+
+    var uvs = mesh.geometry.attributes.uv;
+
+    if (!uvs) {
+      console.error('Geometry must contain uv attribute. ');
+    }
+
+    if (uvs.isPacked) return;
+    var range = {
+      min: Infinity,
+      max: -Infinity
+    };
+    var array = uvs.array;
+
+    for (var i = 0; i < array.length; i++) {
+      range.min = Math.min(range.min, array[i]);
+      range.max = Math.max(range.max, array[i]);
+    }
+
+    var result;
+
+    if (range.min >= -1.0 && range.max <= 1.0) {
+      // use default encoding method
+      result = new Uint16Array(array.length);
+
+      for (var _i = 0; _i < array.length; _i += 2) {
+        var encoded = defaultEncode(array[_i], array[_i + 1], 0, 2);
+        result[_i] = encoded[0];
+        result[_i + 1] = encoded[1];
+      }
+
+      mesh.geometry.setAttribute('uv', new _three.BufferAttribute(result, 2, true));
+      mesh.geometry.attributes.uv.isPacked = true;
+      mesh.geometry.attributes.uv.needsUpdate = true;
+      mesh.geometry.attributes.uv.bytes = result.length * 2;
+
+      if (!(mesh.material instanceof _PackedPhongMaterial.PackedPhongMaterial)) {
+        mesh.material = new _PackedPhongMaterial.PackedPhongMaterial().copy(mesh.material);
+      }
+
+      mesh.material.defines.USE_PACKED_UV = 0;
+    } else {
+      // use quantized encoding method
+      result = quantizedEncodeUV(array, 2);
+      mesh.geometry.setAttribute('uv', new _three.BufferAttribute(result.quantized, 2));
+      mesh.geometry.attributes.uv.isPacked = true;
+      mesh.geometry.attributes.uv.needsUpdate = true;
+      mesh.geometry.attributes.uv.bytes = result.quantized.length * 2;
+
+      if (!(mesh.material instanceof _PackedPhongMaterial.PackedPhongMaterial)) {
+        mesh.material = new _PackedPhongMaterial.PackedPhongMaterial().copy(mesh.material);
+      }
+
+      mesh.material.defines.USE_PACKED_UV = 1;
+      mesh.material.uniforms.quantizeMatUV.value = result.decodeMat;
+      mesh.material.uniforms.quantizeMatUV.needsUpdate = true;
+    }
+  } // Encoding functions
+
+
+  function defaultEncode(x, y, z, bytes) {
+    if (bytes == 1) {
+      var tmpx = Math.round((x + 1) * 0.5 * 255);
+      var tmpy = Math.round((y + 1) * 0.5 * 255);
+      var tmpz = Math.round((z + 1) * 0.5 * 255);
+      return new Uint8Array([tmpx, tmpy, tmpz]);
+    } else if (bytes == 2) {
+      var _tmpx = Math.round((x + 1) * 0.5 * 65535);
+
+      var _tmpy = Math.round((y + 1) * 0.5 * 65535);
+
+      var _tmpz = Math.round((z + 1) * 0.5 * 65535);
+
+      return new Uint16Array([_tmpx, _tmpy, _tmpz]);
+    } else {
+      console.error('number of bytes must be 1 or 2');
+    }
+  } // for `Angles` encoding
+
+
+  function anglesEncode(x, y, z) {
+    var normal0 = parseInt(0.5 * (1.0 + Math.atan2(y, x) / Math.PI) * 65535);
+    var normal1 = parseInt(0.5 * (1.0 + z) * 65535);
+    return new Uint16Array([normal0, normal1]);
+  } // for `Octahedron` encoding
+
+
+  function octEncodeBest(x, y, z, bytes) {
+    var oct, dec, best, currentCos, bestCos; // Test various combinations of ceil and floor
+    // to minimize rounding errors
+
+    best = oct = octEncodeVec3(x, y, z, 'floor', 'floor');
+    dec = octDecodeVec2(oct);
+    bestCos = dot(x, y, z, dec);
+    oct = octEncodeVec3(x, y, z, 'ceil', 'floor');
+    dec = octDecodeVec2(oct);
+    currentCos = dot(x, y, z, dec);
+
+    if (currentCos > bestCos) {
+      best = oct;
+      bestCos = currentCos;
+    }
+
+    oct = octEncodeVec3(x, y, z, 'floor', 'ceil');
+    dec = octDecodeVec2(oct);
+    currentCos = dot(x, y, z, dec);
+
+    if (currentCos > bestCos) {
+      best = oct;
+      bestCos = currentCos;
+    }
+
+    oct = octEncodeVec3(x, y, z, 'ceil', 'ceil');
+    dec = octDecodeVec2(oct);
+    currentCos = dot(x, y, z, dec);
+
+    if (currentCos > bestCos) {
+      best = oct;
+    }
+
+    return best;
+
+    function octEncodeVec3(x0, y0, z0, xfunc, yfunc) {
+      var x = x0 / (Math.abs(x0) + Math.abs(y0) + Math.abs(z0));
+      var y = y0 / (Math.abs(x0) + Math.abs(y0) + Math.abs(z0));
+
+      if (z < 0) {
+        var tempx = (1 - Math.abs(y)) * (x >= 0 ? 1 : -1);
+        var tempy = (1 - Math.abs(x)) * (y >= 0 ? 1 : -1);
+        x = tempx;
+        y = tempy;
+        var diff = 1 - Math.abs(x) - Math.abs(y);
+
+        if (diff > 0) {
+          diff += 0.001;
+          x += x > 0 ? diff / 2 : -diff / 2;
+          y += y > 0 ? diff / 2 : -diff / 2;
+        }
+      }
+
+      if (bytes == 1) {
+        return new Int8Array([Math[xfunc](x * 127.5 + (x < 0 ? 1 : 0)), Math[yfunc](y * 127.5 + (y < 0 ? 1 : 0))]);
+      }
+
+      if (bytes == 2) {
+        return new Int16Array([Math[xfunc](x * 32767.5 + (x < 0 ? 1 : 0)), Math[yfunc](y * 32767.5 + (y < 0 ? 1 : 0))]);
+      }
+    }
+
+    function octDecodeVec2(oct) {
+      var x = oct[0];
+      var y = oct[1];
+
+      if (bytes == 1) {
+        x /= x < 0 ? 127 : 128;
+        y /= y < 0 ? 127 : 128;
+      } else if (bytes == 2) {
+        x /= x < 0 ? 32767 : 32768;
+        y /= y < 0 ? 32767 : 32768;
+      }
+
+      var z = 1 - Math.abs(x) - Math.abs(y);
+
+      if (z < 0) {
+        var tmpx = x;
+        x = (1 - Math.abs(y)) * (x >= 0 ? 1 : -1);
+        y = (1 - Math.abs(tmpx)) * (y >= 0 ? 1 : -1);
+      }
+
+      var length = Math.sqrt(x * x + y * y + z * z);
+      return [x / length, y / length, z / length];
+    }
+
+    function dot(x, y, z, vec3) {
+      return x * vec3[0] + y * vec3[1] + z * vec3[2];
+    }
+  }
+
+  function quantizedEncode(array, bytes) {
+    var quantized, segments;
+
+    if (bytes == 1) {
+      quantized = new Uint8Array(array.length);
+      segments = 255;
+    } else if (bytes == 2) {
+      quantized = new Uint16Array(array.length);
+      segments = 65535;
+    } else {
+      console.error('number of bytes error! ');
+    }
+
+    var decodeMat = new _three.Matrix4();
+    var min = new Float32Array(3);
+    var max = new Float32Array(3);
+    min[0] = min[1] = min[2] = Number.MAX_VALUE;
+    max[0] = max[1] = max[2] = -Number.MAX_VALUE;
+
+    for (var i = 0; i < array.length; i += 3) {
+      min[0] = Math.min(min[0], array[i + 0]);
+      min[1] = Math.min(min[1], array[i + 1]);
+      min[2] = Math.min(min[2], array[i + 2]);
+      max[0] = Math.max(max[0], array[i + 0]);
+      max[1] = Math.max(max[1], array[i + 1]);
+      max[2] = Math.max(max[2], array[i + 2]);
+    }
+
+    decodeMat.scale(new _three.Vector3((max[0] - min[0]) / segments, (max[1] - min[1]) / segments, (max[2] - min[2]) / segments));
+    decodeMat.elements[12] = min[0];
+    decodeMat.elements[13] = min[1];
+    decodeMat.elements[14] = min[2];
+    decodeMat.transpose();
+    var multiplier = new Float32Array([max[0] !== min[0] ? segments / (max[0] - min[0]) : 0, max[1] !== min[1] ? segments / (max[1] - min[1]) : 0, max[2] !== min[2] ? segments / (max[2] - min[2]) : 0]);
+
+    for (var _i2 = 0; _i2 < array.length; _i2 += 3) {
+      quantized[_i2 + 0] = Math.floor((array[_i2 + 0] - min[0]) * multiplier[0]);
+      quantized[_i2 + 1] = Math.floor((array[_i2 + 1] - min[1]) * multiplier[1]);
+      quantized[_i2 + 2] = Math.floor((array[_i2 + 2] - min[2]) * multiplier[2]);
+    }
+
+    return {
+      quantized: quantized,
+      decodeMat: decodeMat
+    };
+  }
+
+  function quantizedEncodeUV(array, bytes) {
+    var quantized, segments;
+
+    if (bytes == 1) {
+      quantized = new Uint8Array(array.length);
+      segments = 255;
+    } else if (bytes == 2) {
+      quantized = new Uint16Array(array.length);
+      segments = 65535;
+    } else {
+      console.error('number of bytes error! ');
+    }
+
+    var decodeMat = new _three.Matrix3();
+    var min = new Float32Array(2);
+    var max = new Float32Array(2);
+    min[0] = min[1] = Number.MAX_VALUE;
+    max[0] = max[1] = -Number.MAX_VALUE;
+
+    for (var i = 0; i < array.length; i += 2) {
+      min[0] = Math.min(min[0], array[i + 0]);
+      min[1] = Math.min(min[1], array[i + 1]);
+      max[0] = Math.max(max[0], array[i + 0]);
+      max[1] = Math.max(max[1], array[i + 1]);
+    }
+
+    decodeMat.scale((max[0] - min[0]) / segments, (max[1] - min[1]) / segments);
+    decodeMat.elements[6] = min[0];
+    decodeMat.elements[7] = min[1];
+    decodeMat.transpose();
+    var multiplier = new Float32Array([max[0] !== min[0] ? segments / (max[0] - min[0]) : 0, max[1] !== min[1] ? segments / (max[1] - min[1]) : 0]);
+
+    for (var _i3 = 0; _i3 < array.length; _i3 += 2) {
+      quantized[_i3 + 0] = Math.floor((array[_i3 + 0] - min[0]) * multiplier[0]);
+      quantized[_i3 + 1] = Math.floor((array[_i3 + 1] - min[1]) * multiplier[1]);
+    }
+
+    return {
+      quantized: quantized,
+      decodeMat: decodeMat
+    };
+  }
+});

data/lib-opal/js_wrap/three/utils/GeometryUtils.js

@@ -0,0 +1,192 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.GeometryUtils = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.gosper = gosper;
+  _exports.hilbert2D = hilbert2D;
+  _exports.hilbert3D = hilbert3D;
+
+  /**
+   * Generates 2D-Coordinates in a very fast way.
+   *
+   * Based on work by:
+   * @link http://www.openprocessing.org/sketch/15493
+   *
+   * @param center     Center of Hilbert curve.
+   * @param size       Total width of Hilbert curve.
+   * @param iterations Number of subdivisions.
+   * @param v0         Corner index -X, -Z.
+   * @param v1         Corner index -X, +Z.
+   * @param v2         Corner index +X, +Z.
+   * @param v3         Corner index +X, -Z.
+   */
+  function hilbert2D() {
+    var center = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _three.Vector3(0, 0, 0);
+    var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+    var iterations = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+    var v0 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    var v1 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+    var v2 = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 2;
+    var v3 = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 3;
+    var half = size / 2;
+    var vec_s = [new _three.Vector3(center.x - half, center.y, center.z - half), new _three.Vector3(center.x - half, center.y, center.z + half), new _three.Vector3(center.x + half, center.y, center.z + half), new _three.Vector3(center.x + half, center.y, center.z - half)];
+    var vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3]]; // Recurse iterations
+
+    if (0 <= --iterations) {
+      var tmp = [];
+      Array.prototype.push.apply(tmp, hilbert2D(vec[0], half, iterations, v0, v3, v2, v1));
+      Array.prototype.push.apply(tmp, hilbert2D(vec[1], half, iterations, v0, v1, v2, v3));
+      Array.prototype.push.apply(tmp, hilbert2D(vec[2], half, iterations, v0, v1, v2, v3));
+      Array.prototype.push.apply(tmp, hilbert2D(vec[3], half, iterations, v2, v1, v0, v3)); // Return recursive call
+
+      return tmp;
+    } // Return complete Hilbert Curve.
+
+
+    return vec;
+  }
+  /**
+   * Generates 3D-Coordinates in a very fast way.
+   *
+   * Based on work by:
+   * @link http://www.openprocessing.org/visuals/?visualID=15599
+   *
+   * @param center     Center of Hilbert curve.
+   * @param size       Total width of Hilbert curve.
+   * @param iterations Number of subdivisions.
+   * @param v0         Corner index -X, +Y, -Z.
+   * @param v1         Corner index -X, +Y, +Z.
+   * @param v2         Corner index -X, -Y, +Z.
+   * @param v3         Corner index -X, -Y, -Z.
+   * @param v4         Corner index +X, -Y, -Z.
+   * @param v5         Corner index +X, -Y, +Z.
+   * @param v6         Corner index +X, +Y, +Z.
+   * @param v7         Corner index +X, +Y, -Z.
+   */
+
+
+  function hilbert3D() {
+    var center = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _three.Vector3(0, 0, 0);
+    var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+    var iterations = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+    var v0 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    var v1 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+    var v2 = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 2;
+    var v3 = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 3;
+    var v4 = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 4;
+    var v5 = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 5;
+    var v6 = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : 6;
+    var v7 = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : 7;
+    // Default Vars
+    var half = size / 2;
+    var vec_s = [new _three.Vector3(center.x - half, center.y + half, center.z - half), new _three.Vector3(center.x - half, center.y + half, center.z + half), new _three.Vector3(center.x - half, center.y - half, center.z + half), new _three.Vector3(center.x - half, center.y - half, center.z - half), new _three.Vector3(center.x + half, center.y - half, center.z - half), new _three.Vector3(center.x + half, center.y - half, center.z + half), new _three.Vector3(center.x + half, center.y + half, center.z + half), new _three.Vector3(center.x + half, center.y + half, center.z - half)];
+    var vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3], vec_s[v4], vec_s[v5], vec_s[v6], vec_s[v7]]; // Recurse iterations
+
+    if (--iterations >= 0) {
+      var tmp = [];
+      Array.prototype.push.apply(tmp, hilbert3D(vec[0], half, iterations, v0, v3, v4, v7, v6, v5, v2, v1));
+      Array.prototype.push.apply(tmp, hilbert3D(vec[1], half, iterations, v0, v7, v6, v1, v2, v5, v4, v3));
+      Array.prototype.push.apply(tmp, hilbert3D(vec[2], half, iterations, v0, v7, v6, v1, v2, v5, v4, v3));
+      Array.prototype.push.apply(tmp, hilbert3D(vec[3], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5));
+      Array.prototype.push.apply(tmp, hilbert3D(vec[4], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5));
+      Array.prototype.push.apply(tmp, hilbert3D(vec[5], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7));
+      Array.prototype.push.apply(tmp, hilbert3D(vec[6], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7));
+      Array.prototype.push.apply(tmp, hilbert3D(vec[7], half, iterations, v6, v5, v2, v1, v0, v3, v4, v7)); // Return recursive call
+
+      return tmp;
+    } // Return complete Hilbert Curve.
+
+
+    return vec;
+  }
+  /**
+   * Generates a Gosper curve (lying in the XY plane)
+   *
+   * https://gist.github.com/nitaku/6521802
+   *
+   * @param size The size of a single gosper island.
+   */
+
+
+  function gosper() {
+    var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+
+    function fractalize(config) {
+      var output;
+      var input = config.axiom;
+
+      for (var i = 0, il = config.steps; 0 <= il ? i < il : i > il; 0 <= il ? i++ : i--) {
+        output = '';
+
+        for (var j = 0, jl = input.length; j < jl; j++) {
+          var char = input[j];
+
+          if (char in config.rules) {
+            output += config.rules[char];
+          } else {
+            output += char;
+          }
+        }
+
+        input = output;
+      }
+
+      return output;
+    }
+
+    function toPoints(config) {
+      var currX = 0,
+          currY = 0;
+      var angle = 0;
+      var path = [0, 0, 0];
+      var fractal = config.fractal;
+
+      for (var i = 0, l = fractal.length; i < l; i++) {
+        var char = fractal[i];
+
+        if (char === '+') {
+          angle += config.angle;
+        } else if (char === '-') {
+          angle -= config.angle;
+        } else if (char === 'F') {
+          currX += config.size * Math.cos(angle);
+          currY += -config.size * Math.sin(angle);
+          path.push(currX, currY, 0);
+        }
+      }
+
+      return path;
+    } //
+
+
+    var gosper = fractalize({
+      axiom: 'A',
+      steps: 4,
+      rules: {
+        A: 'A+BF++BF-FA--FAFA-BF+',
+        B: '-FA+BFBF++BF+FA--FA-B'
+      }
+    });
+    var points = toPoints({
+      fractal: gosper,
+      size: size,
+      angle: Math.PI / 3 // 60 degrees
+
+    });
+    return points;
+  }
+});