Split files

src/baker.js

@@ -0,0 +1,273 @@
+const THREE = require('./three')
+
+THREE.Baker = function() {};
+
+THREE.Baker.prototype = {
+
+  constructor: THREE.Baker,
+
+  parse: (function() {
+
+    var vector = new THREE.Vec3();
+    var normalMatrixWorld = new THREE.Matrix3();
+
+    return function parse(scene, options) {
+
+      if (options === undefined) options = {};
+
+      var binary = options.binary !== undefined ? options.binary : false;
+
+      //
+
+      var objects = [];
+      var triangles = 0;
+
+      scene.traverse(function(object) {
+
+        if (object.isMesh) {
+
+          if (object.pose && object.skeleton && typeof(object.skeleton.pose) == 'function') {
+            console.log('Posing object', object)
+            object.pose();
+          }
+          console.log(object)
+          var og = object.geometry;
+          var geometry = object.geometry;
+          /* FROM */
+
+          function checkBufferGeometryIntersection(object, positions, uvs, a, b, c) {
+            var inverseMatrix = new THREE.Matrix4();
+            var ray = new THREE.Ray();
+            var sphere = new THREE.Sphere();
+
+            var vA = new THREE.Vec3();
+            var vB = new THREE.Vec3();
+            var vC = new THREE.Vec3();
+
+            var tempA = new THREE.Vec3();
+            var tempB = new THREE.Vec3();
+            var tempC = new THREE.Vec3();
+
+            var uvA = new THREE.Vec2();
+            var uvB = new THREE.Vec2();
+            var uvC = new THREE.Vec2();
+
+            var barycoord = new THREE.Vec3();
+
+            var intersectionPoint = new THREE.Vec3();
+            var intersectionPointWorld = new THREE.Vec3();
+            vA.fromArray(positions, a * 3);
+            vB.fromArray(positions, b * 3);
+            vC.fromArray(positions, c * 3);
+
+            if (object.boneTransform) {
+
+              vA = object.boneTransform(vA, a);
+              vB = object.boneTransform(vB, b);
+              vC = object.boneTransform(vC, c);
+
+            }
+          }
+          var uvs, intersection;
+
+          if (geometry instanceof THREE.BufferGeometry) {
+            debugger;
+            console.log('BUFFER')
+            var a, b, c;
+            var index = geometry.index;
+            var attributes = geometry.attributes;
+            var positions = attributes.position.array;
+
+            if (attributes.uv !== undefined) {
+
+              uvs = attributes.uv.array;
+
+            }
+
+            if (index !== null) {
+
+              var indices = index.array;
+
+              for (var i = 0, l = indices.length; i < l; i += 3) {
+
+                a = indices[i];
+                b = indices[i + 1];
+                c = indices[i + 2];
+
+                intersection = checkBufferGeometryIntersection(this, positions, uvs, a, b, c);
+
+                if (intersection) {
+
+                  intersection.faceIndex = Math.floor(i / 3); // triangle number in indices buffer semantics
+                  intersects.push(intersection);
+
+                }
+
+              }
+
+            } else {
+
+
+              for (var i = 0, l = positions.length; i < l; i += 9) {
+
+                a = i / 3;
+                b = a + 1;
+                c = a + 2;
+
+                intersection = checkBufferGeometryIntersection(this, positions, uvs, a, b, c);
+
+                if (intersection) {
+
+                  intersection.index = a; // triangle number in positions buffer semantics
+                  intersects.push(intersection);
+
+                }
+
+              }
+
+            }
+
+          } else if (geometry instanceof THREE.Geometry) {
+            console.log('GEOMETRY')
+            var fvA, fvB, fvC;
+            //var isFaceMaterial = material instanceof THREE.MultiMaterial;
+            //var materials = isFaceMaterial === true ? material.materials : null;
+
+            var vertices = geometry.vertices;
+            var faces = geometry.faces;
+            var faceVertexUvs = geometry.faceVertexUvs[0];
+            if (faceVertexUvs.length > 0) uvs = faceVertexUvs;
+
+            for (var f = 0, fl = faces.length; f < fl; f++) {
+
+              var face = faces[f];
+              //var faceMaterial = isFaceMaterial === true ? materials[ face.materialIndex ] : material;
+
+              //if ( faceMaterial === undefined ) continue;
+
+              fvA = vertices[face.a];
+              fvB = vertices[face.b];
+              fvC = vertices[face.c];
+
+              /*
+              if ( faceMaterial.morphTargets === true ) {
+
+                  var morphTargets = geometry.morphTargets;
+                  var morphInfluences = this.morphTargetInfluences;
+
+                  vA.set( 0, 0, 0 );
+                  vB.set( 0, 0, 0 );
+                  vC.set( 0, 0, 0 );
+
+                  for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
+
+                      var influence = morphInfluences[ t ];
+
+                      if ( influence === 0 ) continue;
+
+                      var targets = morphTargets[ t ].vertices;
+
+                      vA.addScaledVector( tempA.subVectors( targets[ face.a ], fvA ), influence );
+                      vB.addScaledVector( tempB.subVectors( targets[ face.b ], fvB ), influence );
+                      vC.addScaledVector( tempC.subVectors( targets[ face.c ], fvC ), influence );
+
+                  }
+
+                  vA.add( fvA );
+                  vB.add( fvB );
+                  vC.add( fvC );
+
+                  fvA = vA;
+                  fvB = vB;
+                  fvC = vC;
+
+              }
+              */
+
+              if (this.boneTransform) {
+                console.log('YES')
+                fvA = this.boneTransform(fvA, face.a);
+                fvB = this.boneTransform(fvB, face.b);
+                fvC = this.boneTransform(fvC, face.c);
+
+              }
+
+
+
+            }
+
+          } else {
+            console.log(geometry && geometry.constructor.name || 'Non-Geo')
+          }
+
+
+          /* END FROM*/
+
+          if (geometry.isBufferGeometry) {
+            geometry = new THREE.Geometry().fromBufferGeometry(geometry);
+          }
+
+
+          /*
+          if ( geometry.isGeometry ) {
+              if (object.skeleton) {
+                  const allBones = object.skeleton.bones;
+                  const position = Array.from(og.attributes.position.array);
+                  const skinWeight = Array.from(og.attributes.skinWeight.array);
+                  const skinIndex = Array.from(og.attributes.skinIndex.array);
+                  // "loop each vert"
+                  geometry.vertices.forEach((v, i) => {
+                      const p = i * 3;
+                      const f = i * 4;
+                      var pos = new THREE.Vec3(position[p], position[p + 1], position[p + 2]);
+                      var weights = skinWeight.slice(i * 4, i * 4 + 4);
+                      var totalWeight = weights.reduce((a, b) => a + b);
+                      var indices = skinIndex.slice(i * 4, i * 4 + 4);
+                      var bones = indices.map((a, b) => allBones[a].matrix);
+                      // "then over each bone that affects that vert"
+                      var applied = bones.map((bone, i) =>
+                          pos.clone().applyMatrix4(
+                              // "weighted if you have bone weights"
+                              bone.clone().multiplyScalar(weights[i] / totalWeight)
+                          )
+                      )
+                      // "accumulate that"
+                      var final = applied.reduce((a, b) => a.add(b), new THREE.Vec3(0, 0, 0))
+
+                      final.multiplyScalar(1/4)
+                      //bones.forEach((bone, i) => pos.applyMatrix4(bone.clone().multiplyScalar(weights[i])))
+                      v.set(final.x, final.y, final.z)
+                  })
+                  /*
+                  geometry.vertices.forEach(v => {
+                      object.skeleton.bones.forEach(b => {
+                          window.xx = [v, b]
+                          v.applyMatrix4(b.matrixWorld.clone().multiplyScalar(1/object.skeleton.bones.length))
+                      })
+                  })
+                  * /
+              };
+
+              object.geometry = geometry;
+
+              triangles += geometry.faces.length;
+              objects.push( {
+
+                  geometry: geometry,
+                  matrixWorld: object.matrixWorld,
+                  boneMatrices: object.skeleton && object.skeleton.boneMatrices
+
+              } );
+
+          }
+          */
+
+        }
+
+      });
+
+    };
+
+  }())
+
+};

src/bone-transform-hack.js

@@ -0,0 +1,48 @@
+THREE.SkinnedMesh.prototype.boneTransform = (function() {
+
+  var clone = new THREE.Vec3(),
+    result = new THREE.Vec3(),
+    skinIndices = new THREE.Vec4(),
+    skinWeights = new THREE.Vec4();
+  var temp = new THREE.Vec3(),
+    tempMatrix = new THREE.Matrix4(),
+    properties = ['x', 'y', 'z', 'w'];
+
+  return function(vertex, index) {
+
+    if (this.geometry instanceof THREE.BufferGeometry) {
+
+      var index4 = index * 4;
+      skinIndices.fromArray(this.geometry.attributes.skinIndex.array, index4);
+      skinWeights.fromArray(this.geometry.attributes.skinWeight.array, index4);
+
+    } else if (this.geometry instanceof THREE.Geometry) {
+
+      skinIndices.copy(this.geometry.skinIndices[index]);
+      skinWeights.copy(this.geometry.skinWeights[index]);
+
+    }
+
+    var clone = vertex.clone().applyMatrix4(this.bindMatrix);
+    result.set(0, 0, 0);
+
+    for (var i = 0; i < 4; i++) {
+
+      var skinWeight = skinWeights[properties[i]];
+
+      if (skinWeight != 0) {
+
+        var boneIndex = skinIndices[properties[i]];
+        tempMatrix.multiplyMatrices(this.skeleton.bones[boneIndex].matrixWorld, this.skeleton.boneInverses[boneIndex]);
+        result.add(temp.copy(clone).applyMatrix4(tempMatrix).multiplyScalar(skinWeight));
+
+      }
+
+    }
+
+    return clone.copy(result.applyMatrix4(this.bindMatrixInverse));
+
+  };
+
+})();
+// Export scripts

src/code.js

@@ -0,0 +1,14 @@
+
+window.exportCode = () => {
+  window.code = {}
+  for (let pkg of Object.values(window.FuseBox.packages)) {
+    for (let moduleName in pkg.f) {
+      window.code[moduleName] = pkg.f[moduleName].fn.toString()
+    }
+  }
+  
+  console.log('All code saved to `window.code`. `exportCode()` to save it')
+  window.console.save(window.code, 'heroforge.json')
+}
+
+module.exports = window.exportCode

src/gltf-exporter.js

@@ -0,0 +1,1841 @@
+const THREE = require('./three')
+/**
+ * @author fernandojsg / http://fernandojsg.com
+ * @author Don McCurdy / https://www.donmccurdy.com
+ * @author Takahiro / https://github.com/takahirox
+ */
+
+//------------------------------------------------------------------------------
+// Constants
+//------------------------------------------------------------------------------
+var WEBGL_CONSTANTS = {
+  POINTS: 0x0000,
+  LINES: 0x0001,
+  LINE_LOOP: 0x0002,
+  LINE_STRIP: 0x0003,
+  TRIANGLES: 0x0004,
+  TRIANGLE_STRIP: 0x0005,
+  TRIANGLE_FAN: 0x0006,
+
+  UNSIGNED_BYTE: 0x1401,
+  UNSIGNED_SHORT: 0x1403,
+  FLOAT: 0x1406,
+  UNSIGNED_INT: 0x1405,
+  ARRAY_BUFFER: 0x8892,
+  ELEMENT_ARRAY_BUFFER: 0x8893,
+
+  NEAREST: 0x2600,
+  LINEAR: 0x2601,
+  NEAREST_MIPMAP_NEAREST: 0x2700,
+  LINEAR_MIPMAP_NEAREST: 0x2701,
+  NEAREST_MIPMAP_LINEAR: 0x2702,
+  LINEAR_MIPMAP_LINEAR: 0x2703
+};
+
+var THREE_TO_WEBGL = {
+  // @TODO Replace with computed property name [THREE.*] when available on es6
+  1003: WEBGL_CONSTANTS.NEAREST,
+  1004: WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST,
+  1005: WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR,
+  1006: WEBGL_CONSTANTS.LINEAR,
+  1007: WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST,
+  1008: WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR
+};
+
+var PATH_PROPERTIES = {
+  scale: 'scale',
+  position: 'translation',
+  quaternion: 'rotation',
+  morphTargetInfluences: 'weights'
+};
+
+//------------------------------------------------------------------------------
+// GLTF Exporter
+//------------------------------------------------------------------------------
+THREE.GLTFExporter = function() {};
+
+THREE.GLTFExporter.prototype = {
+
+  constructor: THREE.GLTFExporter,
+
+  /**
+   * Parse scenes and generate GLTF output
+   * @param  {THREE.Scene or [THREE.Scenes]} input   THREE.Scene or Array of THREE.Scenes
+   * @param  {Function} onDone  Callback on completed
+   * @param  {Object} options options
+   */
+  parse: function(input, onDone, options) {
+
+    var DEFAULT_OPTIONS = {
+      binary: false,
+      trs: false,
+      onlyVisible: true,
+      truncateDrawRange: true,
+      embedImages: true,
+      animations: [],
+      forceIndices: false,
+      forcePowerOfTwoTextures: false
+    };
+
+    options = Object.assign({}, DEFAULT_OPTIONS, options);
+
+    if (options.animations.length > 0) {
+
+      // Only TRS properties, and not matrices, may be targeted by animation.
+      options.trs = true;
+
+    }
+
+    var outputJSON = {
+
+      asset: {
+
+        version: "2.0",
+        generator: "THREE.GLTFExporter"
+
+      }
+
+    };
+
+    var byteOffset = 0;
+    var buffers = [];
+    var pending = [];
+    var nodeMap = new Map();
+    var skins = [];
+    var extensionsUsed = {};
+    var cachedData = {
+
+      attributes: new Map(),
+      materials: new Map(),
+      textures: new Map()
+
+    };
+
+    var cachedCanvas;
+
+    /**
+     * Compare two arrays
+     */
+    /**
+     * Compare two arrays
+     * @param  {Array} array1 Array 1 to compare
+     * @param  {Array} array2 Array 2 to compare
+     * @return {Boolean}        Returns true if both arrays are equal
+     */
+    function equalArray(array1, array2) {
+
+      return (array1.length === array2.length) && array1.every(function(element, index) {
+
+        return element === array2[index];
+
+      });
+
+    }
+
+    /**
+     * Converts a string to an ArrayBuffer.
+     * @param  {string} text
+     * @return {ArrayBuffer}
+     */
+    function stringToArrayBuffer(text) {
+
+      if (window.TextEncoder !== undefined) {
+
+        return new TextEncoder().encode(text).buffer;
+
+      }
+
+      var array = new Uint8Array(new ArrayBuffer(text.length));
+
+      for (var i = 0, il = text.length; i < il; i++) {
+
+        var value = text.charCodeAt(i);
+
+        // Replacing multi-byte character with space(0x20).
+        array[i] = value > 0xFF ? 0x20 : value;
+
+      }
+
+      return array.buffer;
+
+    }
+
+    /**
+     * Get the min and max vectors from the given attribute
+     * @param  {THREE.BufferAttribute} attribute Attribute to find the min/max in range from start to start + count
+     * @param  {Integer} start
+     * @param  {Integer} count
+     * @return {Object} Object containing the `min` and `max` values (As an array of attribute.itemSize components)
+     */
+    function getMinMax(attribute, start, count) {
+
+      var output = {
+
+        min: new Array(attribute.itemSize).fill(Number.POSITIVE_INFINITY),
+        max: new Array(attribute.itemSize).fill(Number.NEGATIVE_INFINITY)
+
+      };
+
+      for (var i = start; i < start + count; i++) {
+
+        for (var a = 0; a < attribute.itemSize; a++) {
+
+          var value = attribute.array[i * attribute.itemSize + a];
+          output.min[a] = Math.min(output.min[a], value);
+          output.max[a] = Math.max(output.max[a], value);
+
+        }
+
+      }
+
+      return output;
+
+    }
+
+    /**
+     * Checks if image size is POT.
+     *
+     * @param {Image} image The image to be checked.
+     * @returns {Boolean} Returns true if image size is POT.
+     *
+     */
+    function isPowerOfTwo(image) {
+
+      return THREE.Math.isPowerOfTwo(image.width) && THREE.Math.isPowerOfTwo(image.height);
+
+    }
+
+    /**
+     * Checks if normal attribute values are normalized.
+     *
+     * @param {THREE.BufferAttribute} normal
+     * @returns {Boolean}
+     *
+     */
+    function isNormalizedNormalAttribute(normal) {
+
+      if (cachedData.attributes.has(normal)) {
+
+        return false;
+
+      }
+
+      var v = new THREE.Vector3();
+
+      for (var i = 0, il = normal.count; i < il; i++) {
+
+        // 0.0005 is from glTF-validator
+        if (Math.abs(v.fromArray(normal.array, i * 3).length() - 1.0) > 0.0005) return false;
+
+      }
+
+      return true;
+
+    }
+
+    /**
+     * Creates normalized normal buffer attribute.
+     *
+     * @param {THREE.BufferAttribute} normal
+     * @returns {THREE.BufferAttribute}
+     *
+     */
+    function createNormalizedNormalAttribute(normal) {
+
+      if (cachedData.attributes.has(normal)) {
+
+        return cachedData.textures.get(normal);
+
+      }
+
+      var attribute = normal.clone();
+
+      var v = new THREE.Vector3();
+
+      for (var i = 0, il = attribute.count; i < il; i++) {
+
+        v.fromArray(attribute.array, i * 3);
+
+        if (v.x === 0 && v.y === 0 && v.z === 0) {
+
+          // if values can't be normalized set (1, 0, 0)
+          v.setX(1.0);
+
+        } else {
+
+          v.normalize();
+
+        }
+
+        v.toArray(attribute.array, i * 3);
+
+      }
+
+      cachedData.attributes.set(normal, attribute);
+
+      return attribute;
+
+    }
+
+    /**
+     * Get the required size + padding for a buffer, rounded to the next 4-byte boundary.
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#data-alignment
+     *
+     * @param {Integer} bufferSize The size the original buffer.
+     * @returns {Integer} new buffer size with required padding.
+     *
+     */
+    function getPaddedBufferSize(bufferSize) {
+
+      return Math.ceil(bufferSize / 4) * 4;
+
+    }
+
+    /**
+     * Returns a buffer aligned to 4-byte boundary.
+     *
+     * @param {ArrayBuffer} arrayBuffer Buffer to pad
+     * @param {Integer} paddingByte (Optional)
+     * @returns {ArrayBuffer} The same buffer if it's already aligned to 4-byte boundary or a new buffer
+     */
+    function getPaddedArrayBuffer(arrayBuffer, paddingByte) {
+
+      paddingByte = paddingByte || 0;
+
+      var paddedLength = getPaddedBufferSize(arrayBuffer.byteLength);
+
+      if (paddedLength !== arrayBuffer.byteLength) {
+
+        var array = new Uint8Array(paddedLength);
+        array.set(new Uint8Array(arrayBuffer));
+
+        if (paddingByte !== 0) {
+
+          for (var i = arrayBuffer.byteLength; i < paddedLength; i++) {
+
+            array[i] = paddingByte;
+
+          }
+
+        }
+
+        return array.buffer;
+
+      }
+
+      return arrayBuffer;
+
+    }
+
+    /**
+     * Serializes a userData.
+     *
+     * @param {THREE.Object3D|THREE.Material} object
+     * @returns {Object}
+     */
+    function serializeUserData(object) {
+
+      try {
+
+        return JSON.parse(JSON.stringify(object.userData));
+
+      } catch (error) {
+
+        console.warn('THREE.GLTFExporter: userData of \'' + object.name + '\' ' +
+          'won\'t be serialized because of JSON.stringify error - ' + error.message);
+
+        return {};
+
+      }
+
+    }
+
+    /**
+     * Process a buffer to append to the default one.
+     * @param  {ArrayBuffer} buffer
+     * @return {Integer}
+     */
+    function processBuffer(buffer) {
+
+      if (!outputJSON.buffers) {
+
+        outputJSON.buffers = [{
+          byteLength: 0
+        }];
+
+      }
+
+      // All buffers are merged before export.
+      buffers.push(buffer);
+
+      return 0;
+
+    }
+
+    /**
+     * Process and generate a BufferView
+     * @param  {THREE.BufferAttribute} attribute
+     * @param  {number} componentType
+     * @param  {number} start
+     * @param  {number} count
+     * @param  {number} target (Optional) Target usage of the BufferView
+     * @return {Object}
+     */
+    function processBufferView(attribute, componentType, start, count, target) {
+
+      if (!outputJSON.bufferViews) {
+
+        outputJSON.bufferViews = [];
+
+      }
+
+      // Create a new dataview and dump the attribute's array into it
+
+      var componentSize;
+
+      if (componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE) {
+
+        componentSize = 1;
+
+      } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT) {
+
+        componentSize = 2;
+
+      } else {
+
+        componentSize = 4;
+
+      }
+
+      var byteLength = getPaddedBufferSize(count * attribute.itemSize * componentSize);
+      var dataView = new DataView(new ArrayBuffer(byteLength));
+      var offset = 0;
+
+      for (var i = start; i < start + count; i++) {
+
+        for (var a = 0; a < attribute.itemSize; a++) {
+
+          // @TODO Fails on InterleavedBufferAttribute, and could probably be
+          // optimized for normal BufferAttribute.
+          var value = attribute.array[i * attribute.itemSize + a];
+
+          if (componentType === WEBGL_CONSTANTS.FLOAT) {
+
+            dataView.setFloat32(offset, value, true);
+
+          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_INT) {
+
+            dataView.setUint32(offset, value, true);
+
+          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT) {
+
+            dataView.setUint16(offset, value, true);
+
+          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE) {
+
+            dataView.setUint8(offset, value);
+
+          }
+
+          offset += componentSize;
+
+        }
+
+      }
+
+      var gltfBufferView = {
+
+        buffer: processBuffer(dataView.buffer),
+        byteOffset: byteOffset,
+        byteLength: byteLength
+
+      };
+
+      if (target !== undefined) gltfBufferView.target = target;
+
+      if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
+
+        // Only define byteStride for vertex attributes.
+        gltfBufferView.byteStride = attribute.itemSize * componentSize;
+
+      }
+
+      byteOffset += byteLength;
+
+      outputJSON.bufferViews.push(gltfBufferView);
+
+      // @TODO Merge bufferViews where possible.
+      var output = {
+
+        id: outputJSON.bufferViews.length - 1,
+        byteLength: 0
+
+      };
+
+      return output;
+
+    }
+
+    /**
+     * Process and generate a BufferView from an image Blob.
+     * @param {Blob} blob
+     * @return {Promise<Integer>}
+     */
+    function processBufferViewImage(blob) {
+
+      if (!outputJSON.bufferViews) {
+
+        outputJSON.bufferViews = [];
+
+      }
+
+      return new Promise(function(resolve) {
+
+        var reader = new window.FileReader();
+        reader.readAsArrayBuffer(blob);
+        reader.onloadend = function() {
+
+          var buffer = getPaddedArrayBuffer(reader.result);
+
+          var bufferView = {
+            buffer: processBuffer(buffer),
+            byteOffset: byteOffset,
+            byteLength: buffer.byteLength
+          };
+
+          byteOffset += buffer.byteLength;
+
+          outputJSON.bufferViews.push(bufferView);
+
+          resolve(outputJSON.bufferViews.length - 1);
+
+        };
+
+      });
+
+    }
+
+    /**
+     * Process attribute to generate an accessor
+     * @param  {THREE.BufferAttribute} attribute Attribute to process
+     * @param  {THREE.BufferGeometry} geometry (Optional) Geometry used for truncated draw range
+     * @param  {Integer} start (Optional)
+     * @param  {Integer} count (Optional)
+     * @return {Integer}           Index of the processed accessor on the "accessors" array
+     */
+    function processAccessor(attribute, geometry, start, count) {
+
+      var types = {
+
+        1: 'SCALAR',
+        2: 'VEC2',
+        3: 'VEC3',
+        4: 'VEC4',
+        16: 'MAT4'
+
+      };
+
+      var componentType;
+
+      // Detect the component type of the attribute array (float, uint or ushort)
+      if (attribute.array.constructor === Float32Array) {
+
+        componentType = WEBGL_CONSTANTS.FLOAT;
+
+      } else if (attribute.array.constructor === Uint32Array) {
+
+        componentType = WEBGL_CONSTANTS.UNSIGNED_INT;
+
+      } else if (attribute.array.constructor === Uint16Array) {
+
+        componentType = WEBGL_CONSTANTS.UNSIGNED_SHORT;
+
+      } else if (attribute.array.constructor === Uint8Array) {
+
+        componentType = WEBGL_CONSTANTS.UNSIGNED_BYTE;
+
+      } else {
+
+        throw new Error('THREE.GLTFExporter: Unsupported bufferAttribute component type.');
+
+      }
+
+      if (start === undefined) start = 0;
+      if (count === undefined) count = attribute.count;
+
+      // @TODO Indexed buffer geometry with drawRange not supported yet
+      if (options.truncateDrawRange && geometry !== undefined && geometry.index === null) {
+
+        var end = start + count;
+        var end2 = geometry.drawRange.count === Infinity ?
+          attribute.count :
+          geometry.drawRange.start + geometry.drawRange.count;
+
+        start = Math.max(start, geometry.drawRange.start);
+        count = Math.min(end, end2) - start;
+
+        if (count < 0) count = 0;
+
+      }
+
+      // Skip creating an accessor if the attribute doesn't have data to export
+      if (count === 0) {
+
+        return null;
+
+      }
+
+      var minMax = getMinMax(attribute, start, count);
+
+      var bufferViewTarget;
+
+      // If geometry isn't provided, don't infer the target usage of the bufferView. For
+      // animation samplers, target must not be set.
+      if (geometry !== undefined) {
+
+        bufferViewTarget = attribute === geometry.index ? WEBGL_CONSTANTS.ELEMENT_ARRAY_BUFFER : WEBGL_CONSTANTS.ARRAY_BUFFER;
+
+      }
+
+      var bufferView = processBufferView(attribute, componentType, start, count, bufferViewTarget);
+
+      var gltfAccessor = {
+
+        bufferView: bufferView.id,
+        byteOffset: bufferView.byteOffset,
+        componentType: componentType,
+        count: count,
+        max: minMax.max,
+        min: minMax.min,
+        type: types[attribute.itemSize]
+
+      };
+
+      if (!outputJSON.accessors) {
+
+        outputJSON.accessors = [];
+
+      }
+
+      outputJSON.accessors.push(gltfAccessor);
+
+      return outputJSON.accessors.length - 1;
+
+    }
+
+    /**
+     * Process image
+     * @param  {Texture} map Texture to process
+     * @return {Integer}     Index of the processed texture in the "images" array
+     */
+    function processImage(map) {
+
+      // @TODO Cache
+
+      if (!outputJSON.images) {
+
+        outputJSON.images = [];
+
+      }
+
+      var mimeType = map.format === THREE.RGBAFormat ? 'image/png' : 'image/jpeg';
+      var gltfImage = {
+        mimeType: mimeType
+      };
+
+      if (options.embedImages) {
+
+        var canvas = cachedCanvas = cachedCanvas || document.createElement('canvas');
+
+        canvas.width = map.image.width;
+        canvas.height = map.image.height;
+
+        if (options.forcePowerOfTwoTextures && !isPowerOfTwo(map.image)) {
+
+          console.warn('GLTFExporter: Resized non-power-of-two image.', map.image);
+
+          canvas.width = THREE.Math.floorPowerOfTwo(canvas.width);
+          canvas.height = THREE.Math.floorPowerOfTwo(canvas.height);
+
+        }
+
+        var ctx = canvas.getContext('2d');
+
+        if (map.flipY === true) {
+
+          ctx.translate(0, canvas.height);
+          ctx.scale(1, -1);
+
+        }
+
+        ctx.drawImage(map.image, 0, 0, canvas.width, canvas.height);
+
+        if (options.binary === true) {
+
+          pending.push(new Promise(function(resolve) {
+
+            canvas.toBlob(function(blob) {
+
+              processBufferViewImage(blob).then(function(bufferViewIndex) {
+
+                gltfImage.bufferView = bufferViewIndex;
+
+                resolve();
+
+              });
+
+            }, mimeType);
+
+          }));
+
+        } else {
+
+          gltfImage.uri = canvas.toDataURL(mimeType);
+
+        }
+
+      } else {
+
+        gltfImage.uri = map.image.src;
+
+      }
+
+      outputJSON.images.push(gltfImage);
+
+      return outputJSON.images.length - 1;
+
+    }
+
+    /**
+     * Process sampler
+     * @param  {Texture} map Texture to process
+     * @return {Integer}     Index of the processed texture in the "samplers" array
+     */
+    function processSampler(map) {
+
+      if (!outputJSON.samplers) {
+
+        outputJSON.samplers = [];
+
+      }
+
+      var gltfSampler = {
+
+        magFilter: THREE_TO_WEBGL[map.magFilter],
+        minFilter: THREE_TO_WEBGL[map.minFilter],
+        wrapS: THREE_TO_WEBGL[map.wrapS],
+        wrapT: THREE_TO_WEBGL[map.wrapT]
+
+      };
+
+      outputJSON.samplers.push(gltfSampler);
+
+      return outputJSON.samplers.length - 1;
+
+    }
+
+    /**
+     * Process texture
+     * @param  {Texture} map Map to process
+     * @return {Integer}     Index of the processed texture in the "textures" array
+     */
+    function processTexture(map) {
+
+      if (cachedData.textures.has(map)) {
+
+        return cachedData.textures.get(map);
+
+      }
+
+      if (!outputJSON.textures) {
+
+        outputJSON.textures = [];
+
+      }
+
+      var gltfTexture = {
+
+        sampler: processSampler(map),
+        source: processImage(map)
+
+      };
+
+      outputJSON.textures.push(gltfTexture);
+
+      var index = outputJSON.textures.length - 1;
+      cachedData.textures.set(map, index);
+
+      return index;
+
+    }
+
+    /**
+     * Process material
+     * @param  {THREE.Material} material Material to process
+     * @return {Integer}      Index of the processed material in the "materials" array
+     */
+    function processMaterial(material) {
+
+      if (cachedData.materials.has(material)) {
+
+        return cachedData.materials.get(material);
+
+      }
+
+      if (!outputJSON.materials) {
+
+        outputJSON.materials = [];
+
+      }
+
+      if (material.isShaderMaterial) {
+
+        console.warn('GLTFExporter: THREE.ShaderMaterial not supported.');
+        return null;
+
+      }
+
+      // @QUESTION Should we avoid including any attribute that has the default value?
+      var gltfMaterial = {
+
+        pbrMetallicRoughness: {}
+
+      };
+
+      if (material.isMeshBasicMaterial) {
+
+        gltfMaterial.extensions = {
+          KHR_materials_unlit: {}
+        };
+
+        extensionsUsed['KHR_materials_unlit'] = true;
+
+      } else if (!material.isMeshStandardMaterial) {
+
+        console.warn('GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.');
+
+      }
+
+      // pbrMetallicRoughness.baseColorFactor
+      var color = material.color.toArray().concat([material.opacity]);
+
+      if (!equalArray(color, [1, 1, 1, 1])) {
+
+        gltfMaterial.pbrMetallicRoughness.baseColorFactor = color;
+
+      }
+
+      if (material.isMeshStandardMaterial) {
+
+        gltfMaterial.pbrMetallicRoughness.metallicFactor = material.metalness;
+        gltfMaterial.pbrMetallicRoughness.roughnessFactor = material.roughness;
+
+      } else if (material.isMeshBasicMaterial) {
+
+        gltfMaterial.pbrMetallicRoughness.metallicFactor = 0.0;
+        gltfMaterial.pbrMetallicRoughness.roughnessFactor = 0.9;
+
+      } else {
+
+        gltfMaterial.pbrMetallicRoughness.metallicFactor = 0.5;
+        gltfMaterial.pbrMetallicRoughness.roughnessFactor = 0.5;
+
+      }
+
+      // pbrMetallicRoughness.metallicRoughnessTexture
+      if (material.metalnessMap || material.roughnessMap) {
+
+        if (material.metalnessMap === material.roughnessMap) {
+
+          gltfMaterial.pbrMetallicRoughness.metallicRoughnessTexture = {
+
+            index: processTexture(material.metalnessMap)
+
+          };
+
+        } else {
+
+          console.warn('THREE.GLTFExporter: Ignoring metalnessMap and roughnessMap because they are not the same Texture.');
+
+        }
+
+      }
+
+      // pbrMetallicRoughness.baseColorTexture
+      if (material.map) {
+
+        gltfMaterial.pbrMetallicRoughness.baseColorTexture = {
+
+          index: processTexture(material.map)
+
+        };
+
+      }
+
+      if (material.isMeshBasicMaterial ||
+        material.isLineBasicMaterial ||
+        material.isPointsMaterial) {
+
+      } else {
+
+        // emissiveFactor
+        var emissive = material.emissive.clone().multiplyScalar(material.emissiveIntensity).toArray();
+
+        if (!equalArray(emissive, [0, 0, 0])) {
+
+          gltfMaterial.emissiveFactor = emissive;
+
+        }
+
+        // emissiveTexture
+        if (material.emissiveMap) {
+
+          gltfMaterial.emissiveTexture = {
+
+            index: processTexture(material.emissiveMap)
+
+          };
+
+        }
+
+      }
+
+      // normalTexture
+      if (material.normalMap) {
+
+        gltfMaterial.normalTexture = {
+
+          index: processTexture(material.normalMap)
+
+        };
+
+        if (material.normalScale.x !== -1) {
+
+          if (material.normalScale.x !== material.normalScale.y) {
+
+            console.warn('THREE.GLTFExporter: Normal scale components are different, ignoring Y and exporting X.');
+
+          }
+
+          gltfMaterial.normalTexture.scale = material.normalScale.x;
+
+        }
+
+      }
+
+      // occlusionTexture
+      if (material.aoMap) {
+
+        gltfMaterial.occlusionTexture = {
+
+          index: processTexture(material.aoMap)
+
+        };
+
+        if (material.aoMapIntensity !== 1.0) {
+
+          gltfMaterial.occlusionTexture.strength = material.aoMapIntensity;
+
+        }
+
+      }
+
+      // alphaMode
+      if (material.transparent || material.alphaTest > 0.0) {
+
+        gltfMaterial.alphaMode = material.opacity < 1.0 ? 'BLEND' : 'MASK';
+
+        // Write alphaCutoff if it's non-zero and different from the default (0.5).
+        if (material.alphaTest > 0.0 && material.alphaTest !== 0.5) {
+
+          gltfMaterial.alphaCutoff = material.alphaTest;
+
+        }
+
+      }
+
+      // doubleSided
+      if (material.side === THREE.DoubleSide) {
+
+        gltfMaterial.doubleSided = true;
+
+      }
+
+      if (material.name !== '') {
+
+        gltfMaterial.name = material.name;
+
+      }
+
+      if (Object.keys(material.userData).length > 0) {
+
+        gltfMaterial.extras = serializeUserData(material);
+
+      }
+
+      outputJSON.materials.push(gltfMaterial);
+
+      var index = outputJSON.materials.length - 1;
+      cachedData.materials.set(material, index);
+
+      return index;
+
+    }
+
+    /**
+     * Process mesh
+     * @param  {THREE.Mesh} mesh Mesh to process
+     * @return {Integer}      Index of the processed mesh in the "meshes" array
+     */
+    function processMesh(mesh) {
+
+      var geometry = mesh.geometry;
+
+      var mode;
+
+      // Use the correct mode
+      if (mesh.isLineSegments) {
+
+        mode = WEBGL_CONSTANTS.LINES;
+
+      } else if (mesh.isLineLoop) {
+
+        mode = WEBGL_CONSTANTS.LINE_LOOP;
+
+      } else if (mesh.isLine) {
+
+        mode = WEBGL_CONSTANTS.LINE_STRIP;
+
+      } else if (mesh.isPoints) {
+
+        mode = WEBGL_CONSTANTS.POINTS;
+
+      } else {
+
+        if (!geometry.isBufferGeometry) {
+
+          var geometryTemp = new THREE.BufferGeometry();
+          geometryTemp.fromGeometry(geometry);
+          geometry = geometryTemp;
+
+        }
+
+        if (mesh.drawMode === THREE.TriangleFanDrawMode) {
+
+          console.warn('GLTFExporter: TriangleFanDrawMode and wireframe incompatible.');
+          mode = WEBGL_CONSTANTS.TRIANGLE_FAN;
+
+        } else if (mesh.drawMode === THREE.TriangleStripDrawMode) {
+
+          mode = mesh.material.wireframe ? WEBGL_CONSTANTS.LINE_STRIP : WEBGL_CONSTANTS.TRIANGLE_STRIP;
+
+        } else {
+
+          mode = mesh.material.wireframe ? WEBGL_CONSTANTS.LINES : WEBGL_CONSTANTS.TRIANGLES;
+
+        }
+
+      }
+
+      var gltfMesh = {};
+
+      var attributes = {};
+      var primitives = [];
+      var targets = [];
+
+      // Conversion between attributes names in threejs and gltf spec
+      var nameConversion = {
+
+        uv: 'TEXCOORD_0',
+        uv2: 'TEXCOORD_1',
+        color: 'COLOR_0',
+        skinWeight: 'WEIGHTS_0',
+        skinIndex: 'JOINTS_0'
+
+      };
+
+      var originalNormal = geometry.getAttribute('normal');
+
+      if (originalNormal !== undefined && !isNormalizedNormalAttribute(originalNormal)) {
+
+        console.warn('THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one.');
+
+        geometry.addAttribute('normal', createNormalizedNormalAttribute(originalNormal));
+
+      }
+
+      // @QUESTION Detect if .vertexColors = THREE.VertexColors?
+      // For every attribute create an accessor
+      for (var attributeName in geometry.attributes) {
+
+        var attribute = geometry.attributes[attributeName];
+        attributeName = nameConversion[attributeName] || attributeName.toUpperCase();
+
+        // JOINTS_0 must be UNSIGNED_BYTE or UNSIGNED_SHORT.
+        var array = attribute.array;
+        if (attributeName === 'JOINTS_0' &&
+          !(array instanceof Uint16Array) &&
+          !(array instanceof Uint8Array)) {
+
+          console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.');
+          attribute = new THREE.BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
+
+        }
+
+        if (attributeName.substr(0, 5) !== 'MORPH') {
+
+          var accessor = processAccessor(attribute, geometry);
+          if (accessor !== null) {
+
+            attributes[attributeName] = accessor;
+
+          }
+
+        }
+
+      }
+
+      if (originalNormal !== undefined) geometry.addAttribute('normal', originalNormal);
+
+      // Skip if no exportable attributes found
+      if (Object.keys(attributes).length === 0) {
+
+        return null;
+
+      }
+
+      // Morph targets
+      if (mesh.morphTargetInfluences !== undefined && mesh.morphTargetInfluences.length > 0) {
+
+        var weights = [];
+        var targetNames = [];
+        var reverseDictionary = {};
+
+        if (mesh.morphTargetDictionary !== undefined) {
+
+          for (var key in mesh.morphTargetDictionary) {
+
+            reverseDictionary[mesh.morphTargetDictionary[key]] = key;
+
+          }
+
+        }
+
+        for (var i = 0; i < mesh.morphTargetInfluences.length; ++i) {
+
+          var target = {};
+
+          var warned = false;
+
+          for (var attributeName in geometry.morphAttributes) {
+
+            // glTF 2.0 morph supports only POSITION/NORMAL/TANGENT.
+            // Three.js doesn't support TANGENT yet.
+
+            if (attributeName !== 'position' && attributeName !== 'normal') {
+
+              if (!warned) {
+
+                console.warn('GLTFExporter: Only POSITION and NORMAL morph are supported.');
+                warned = true;
+
+              }
+
+              continue;
+
+            }
+
+            var attribute = geometry.morphAttributes[attributeName][i];
+
+            // Three.js morph attribute has absolute values while the one of glTF has relative values.
+            //
+            // glTF 2.0 Specification:
+            // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#morph-targets
+
+            var baseAttribute = geometry.attributes[attributeName];
+            // Clones attribute not to override
+            var relativeAttribute = attribute.clone();
+
+            for (var j = 0, jl = attribute.count; j < jl; j++) {
+
+              relativeAttribute.setXYZ(
+                j,
+                attribute.getX(j) - baseAttribute.getX(j),
+                attribute.getY(j) - baseAttribute.getY(j),
+                attribute.getZ(j) - baseAttribute.getZ(j)
+              );
+
+            }
+
+            target[attributeName.toUpperCase()] = processAccessor(relativeAttribute, geometry);
+
+          }
+
+          targets.push(target);
+
+          weights.push(mesh.morphTargetInfluences[i]);
+          if (mesh.morphTargetDictionary !== undefined) targetNames.push(reverseDictionary[i]);
+
+        }
+
+        gltfMesh.weights = weights;
+
+        if (targetNames.length > 0) {
+
+          gltfMesh.extras = {};
+          gltfMesh.extras.targetNames = targetNames;
+
+        }
+
+      }
+
+      var extras = (Object.keys(geometry.userData || []).length > 0) ? serializeUserData(geometry) : undefined;
+
+      var forceIndices = options.forceIndices;
+      var isMultiMaterial = Array.isArray(mesh.material);
+
+      if (isMultiMaterial && mesh.geometry.groups.length === 0) return null;
+
+      if (!forceIndices && geometry.index === null && isMultiMaterial) {
+
+        // temporal workaround.
+        console.warn('THREE.GLTFExporter: Creating index for non-indexed multi-material mesh.');
+        forceIndices = true;
+
+      }
+
+      var didForceIndices = false;
+
+      if (geometry.index === null && forceIndices) {
+
+        var indices = [];
+
+        for (var i = 0, il = geometry.attributes.position.count; i < il; i++) {
+
+          indices[i] = i;
+
+        }
+
+        geometry.setIndex(indices);
+
+        didForceIndices = true;
+
+      }
+
+      var materials = isMultiMaterial ? mesh.material : [mesh.material];
+      var groups = isMultiMaterial ? mesh.geometry.groups : [{
+        materialIndex: 0,
+        start: undefined,
+        count: undefined
+      }];
+
+      for (var i = 0, il = groups.length; i < il; i++) {
+
+        var primitive = {
+          mode: mode,
+          attributes: attributes,
+        };
+
+        if (extras) primitive.extras = extras;
+
+        if (targets.length > 0) primitive.targets = targets;
+
+        if (geometry.index !== null) {
+
+          primitive.indices = processAccessor(geometry.index, geometry, groups[i].start, groups[i].count);
+
+        }
+
+        var material = processMaterial(materials[groups[i].materialIndex]);
+
+        if (material !== null) {
+
+          primitive.material = material;
+
+        }
+
+        primitives.push(primitive);
+
+      }
+
+      if (didForceIndices) {
+
+        geometry.setIndex(null);
+
+      }
+
+      gltfMesh.primitives = primitives;
+
+      if (!outputJSON.meshes) {
+
+        outputJSON.meshes = [];
+
+      }
+
+      outputJSON.meshes.push(gltfMesh);
+
+      return outputJSON.meshes.length - 1;
+
+    }
+
+    /**
+     * Process camera
+     * @param  {THREE.Camera} camera Camera to process
+     * @return {Integer}      Index of the processed mesh in the "camera" array
+     */
+    function processCamera(camera) {
+
+      if (!outputJSON.cameras) {
+
+        outputJSON.cameras = [];
+
+      }
+
+      var isOrtho = camera.isOrthographicCamera;
+
+      var gltfCamera = {
+
+        type: isOrtho ? 'orthographic' : 'perspective'
+
+      };
+
+      if (isOrtho) {
+
+        gltfCamera.orthographic = {
+
+          xmag: camera.right * 2,
+          ymag: camera.top * 2,
+          zfar: camera.far <= 0 ? 0.001 : camera.far,
+          znear: camera.near < 0 ? 0 : camera.near
+
+        };
+
+      } else {
+
+        gltfCamera.perspective = {
+
+          aspectRatio: camera.aspect,
+          yfov: THREE.Math.degToRad(camera.fov) / camera.aspect,
+          zfar: camera.far <= 0 ? 0.001 : camera.far,
+          znear: camera.near < 0 ? 0 : camera.near
+
+        };
+
+      }
+
+      if (camera.name !== '') {
+
+        gltfCamera.name = camera.type;
+
+      }
+
+      outputJSON.cameras.push(gltfCamera);
+
+      return outputJSON.cameras.length - 1;
+
+    }
+
+    /**
+     * Creates glTF animation entry from AnimationClip object.
+     *
+     * Status:
+     * - Only properties listed in PATH_PROPERTIES may be animated.
+     *
+     * @param {THREE.AnimationClip} clip
+     * @param {THREE.Object3D} root
+     * @return {number}
+     */
+    function processAnimation(clip, root) {
+
+      if (!outputJSON.animations) {
+
+        outputJSON.animations = [];
+
+      }
+
+      var channels = [];
+      var samplers = [];
+
+      for (var i = 0; i < clip.tracks.length; ++i) {
+
+        var track = clip.tracks[i];
+        var trackBinding = THREE.PropertyBinding.parseTrackName(track.name);
+        var trackNode = THREE.PropertyBinding.findNode(root, trackBinding.nodeName);
+        var trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
+
+        if (trackBinding.objectName === 'bones') {
+
+          if (trackNode.isSkinnedMesh === true) {
+
+            trackNode = trackNode.skeleton.getBoneByName(trackBinding.objectIndex);
+
+          } else {
+
+            trackNode = undefined;
+
+          }
+
+        }
+
+        if (!trackNode || !trackProperty) {
+
+          console.warn('THREE.GLTFExporter: Could not export animation track "%s".', track.name);
+          return null;
+
+        }
+
+        var inputItemSize = 1;
+        var outputItemSize = track.values.length / track.times.length;
+
+        if (trackProperty === PATH_PROPERTIES.morphTargetInfluences) {
+
+          outputItemSize /= trackNode.morphTargetInfluences.length;
+
+        }
+
+        var interpolation;
+
+        // @TODO export CubicInterpolant(InterpolateSmooth) as CUBICSPLINE
+
+        // Detecting glTF cubic spline interpolant by checking factory method's special property
+        // GLTFCubicSplineInterpolant is a custom interpolant and track doesn't return
+        // valid value from .getInterpolation().
+        if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
+
+          interpolation = 'CUBICSPLINE';
+
+          // itemSize of CUBICSPLINE keyframe is 9
+          // (VEC3 * 3: inTangent, splineVertex, and outTangent)
+          // but needs to be stored as VEC3 so dividing by 3 here.
+          outputItemSize /= 3;
+
+        } else if (track.getInterpolation() === THREE.InterpolateDiscrete) {
+
+          interpolation = 'STEP';
+
+        } else {
+
+          interpolation = 'LINEAR';
+
+        }
+
+        samplers.push({
+
+          input: processAccessor(new THREE.BufferAttribute(track.times, inputItemSize)),
+          output: processAccessor(new THREE.BufferAttribute(track.values, outputItemSize)),
+          interpolation: interpolation
+
+        });
+
+        channels.push({
+
+          sampler: samplers.length - 1,
+          target: {
+            node: nodeMap.get(trackNode),
+            path: trackProperty
+          }
+
+        });
+
+      }
+
+      outputJSON.animations.push({
+
+        name: clip.name || 'clip_' + outputJSON.animations.length,
+        samplers: samplers,
+        channels: channels
+
+      });
+
+      return outputJSON.animations.length - 1;
+
+    }
+
+    function processSkin(object) {
+
+      var node = outputJSON.nodes[nodeMap.get(object)];
+      var skeleton = object.skeleton;
+      var rootJoint = object.skeleton.bones[0];
+
+      if (rootJoint === undefined) return null;
+
+      var joints = [];
+      var inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
+
+      for (var i = 0; i < skeleton.bones.length; ++i) {
+
+        joints.push(nodeMap.get(skeleton.bones[i]));
+
+        skeleton.boneInverses[i].toArray(inverseBindMatrices, i * 16);
+
+      }
+
+      if (outputJSON.skins === undefined) {
+
+        outputJSON.skins = [];
+
+      }
+
+      outputJSON.skins.push({
+
+        inverseBindMatrices: processAccessor(new THREE.BufferAttribute(inverseBindMatrices, 16)),
+        joints: joints,
+        skeleton: nodeMap.get(rootJoint)
+
+      });
+
+      var skinIndex = node.skin = outputJSON.skins.length - 1;
+
+      return skinIndex;
+
+    }
+
+    /**
+     * Process Object3D node
+     * @param  {THREE.Object3D} node Object3D to processNode
+     * @return {Integer}      Index of the node in the nodes list
+     */
+    function processNode(object) {
+
+      if (object.isLight) {
+
+        console.warn('GLTFExporter: Unsupported node type:', object.constructor.name);
+        return null;
+
+      }
+
+      if (!outputJSON.nodes) {
+
+        outputJSON.nodes = [];
+
+      }
+
+      var gltfNode = {};
+
+      if (options.trs) {
+
+        var rotation = object.quaternion.toArray();
+        var position = object.position.toArray();
+        var scale = object.scale.toArray();
+
+        if (!equalArray(rotation, [0, 0, 0, 1])) {
+
+          gltfNode.rotation = rotation;
+
+        }
+
+        if (!equalArray(position, [0, 0, 0])) {
+
+          gltfNode.translation = position;
+
+        }
+
+        if (!equalArray(scale, [1, 1, 1])) {
+
+          gltfNode.scale = scale;
+
+        }
+
+      } else {
+
+        object.updateMatrix();
+        if (!equalArray(object.matrix.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+
+          gltfNode.matrix = object.matrix.elements;
+
+        }
+
+      }
+
+      // We don't export empty strings name because it represents no-name in Three.js.
+      if (object.name !== '') {
+
+        gltfNode.name = String(object.name);
+
+      }
+
+      if (object.userData && Object.keys(object.userData).length > 0) {
+
+        gltfNode.extras = serializeUserData(object);
+
+      }
+
+      if (object.isMesh || object.isLine || object.isPoints) {
+
+        var mesh = processMesh(object);
+
+        if (mesh !== null) {
+
+          gltfNode.mesh = mesh;
+
+        }
+
+      } else if (object.isCamera) {
+
+        gltfNode.camera = processCamera(object);
+
+      }
+
+      if (object.isSkinnedMesh) {
+
+        skins.push(object);
+
+      }
+
+      if (object.children.length > 0) {
+
+        var children = [];
+
+        for (var i = 0, l = object.children.length; i < l; i++) {
+
+          var child = object.children[i];
+
+          if (child.visible || options.onlyVisible === false) {
+
+            var node = processNode(child);
+
+            if (node !== null) {
+
+              children.push(node);
+
+            }
+
+          }
+
+        }
+
+        if (children.length > 0) {
+
+          gltfNode.children = children;
+
+        }
+
+
+      }
+
+      outputJSON.nodes.push(gltfNode);
+
+      var nodeIndex = outputJSON.nodes.length - 1;
+      nodeMap.set(object, nodeIndex);
+
+      return nodeIndex;
+
+    }
+
+    /**
+     * Process Scene
+     * @param  {THREE.Scene} node Scene to process
+     */
+    function processScene(scene) {
+
+      if (!outputJSON.scenes) {
+
+        outputJSON.scenes = [];
+        outputJSON.scene = 0;
+
+      }
+
+      var gltfScene = {
+
+        nodes: []
+
+      };
+
+      if (scene.name !== '') {
+
+        gltfScene.name = scene.name;
+
+      }
+
+      outputJSON.scenes.push(gltfScene);
+
+      var nodes = [];
+
+      for (var i = 0, l = scene.children.length; i < l; i++) {
+
+        var child = scene.children[i];
+
+        if (child.visible || options.onlyVisible === false) {
+
+          var node = processNode(child);
+
+          if (node !== null) {
+
+            nodes.push(node);
+
+          }
+
+        }
+
+      }
+
+      if (nodes.length > 0) {
+
+        gltfScene.nodes = nodes;
+
+      }
+
+    }
+
+    /**
+     * Creates a THREE.Scene to hold a list of objects and parse it
+     * @param  {Array} objects List of objects to process
+     */
+    function processObjects(objects) {
+
+      var scene = new THREE.Scene();
+      scene.name = 'AuxScene';
+
+      for (var i = 0; i < objects.length; i++) {
+
+        // We push directly to children instead of calling `add` to prevent
+        // modify the .parent and break its original scene and hierarchy
+        scene.children.push(objects[i]);
+
+      }
+
+      processScene(scene);
+
+    }
+
+    function processInput(input) {
+
+      input = input instanceof Array ? input : [input];
+
+      var objectsWithoutScene = [];
+
+      for (var i = 0; i < input.length; i++) {
+
+        if (input[i] instanceof THREE.Scene) {
+
+          processScene(input[i]);
+
+        } else {
+
+          objectsWithoutScene.push(input[i]);
+
+        }
+
+      }
+
+      if (objectsWithoutScene.length > 0) {
+
+        processObjects(objectsWithoutScene);
+
+      }
+
+      for (var i = 0; i < skins.length; ++i) {
+
+        processSkin(skins[i]);
+
+      }
+
+      for (var i = 0; i < options.animations.length; ++i) {
+
+        processAnimation(options.animations[i], input[0]);
+
+      }
+
+    }
+
+    processInput(input);
+
+    Promise.all(pending).then(function() {
+
+      // Merge buffers.
+      var blob = new Blob(buffers, {
+        type: 'application/octet-stream'
+      });
+
+      // Declare extensions.
+      var extensionsUsedList = Object.keys(extensionsUsed);
+      if (extensionsUsedList.length > 0) outputJSON.extensionsUsed = extensionsUsedList;
+
+      if (outputJSON.buffers && outputJSON.buffers.length > 0) {
+
+        // Update bytelength of the single buffer.
+        outputJSON.buffers[0].byteLength = blob.size;
+
+        var reader = new window.FileReader();
+
+        if (options.binary === true) {
+
+          // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
+
+          var GLB_HEADER_BYTES = 12;
+          var GLB_HEADER_MAGIC = 0x46546C67;
+          var GLB_VERSION = 2;
+
+          var GLB_CHUNK_PREFIX_BYTES = 8;
+          var GLB_CHUNK_TYPE_JSON = 0x4E4F534A;
+          var GLB_CHUNK_TYPE_BIN = 0x004E4942;
+
+          reader.readAsArrayBuffer(blob);
+          reader.onloadend = function() {
+
+            // Binary chunk.
+            var binaryChunk = getPaddedArrayBuffer(reader.result);
+            var binaryChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
+            binaryChunkPrefix.setUint32(0, binaryChunk.byteLength, true);
+            binaryChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_BIN, true);
+
+            // JSON chunk.
+            var jsonChunk = getPaddedArrayBuffer(stringToArrayBuffer(JSON.stringify(outputJSON)), 0x20);
+            var jsonChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
+            jsonChunkPrefix.setUint32(0, jsonChunk.byteLength, true);
+            jsonChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_JSON, true);
+
+            // GLB header.
+            var header = new ArrayBuffer(GLB_HEADER_BYTES);
+            var headerView = new DataView(header);
+            headerView.setUint32(0, GLB_HEADER_MAGIC, true);
+            headerView.setUint32(4, GLB_VERSION, true);
+            var totalByteLength = GLB_HEADER_BYTES +
+              jsonChunkPrefix.byteLength + jsonChunk.byteLength +
+              binaryChunkPrefix.byteLength + binaryChunk.byteLength;
+            headerView.setUint32(8, totalByteLength, true);
+
+            var glbBlob = new Blob([
+              header,
+              jsonChunkPrefix,
+              jsonChunk,
+              binaryChunkPrefix,
+              binaryChunk
+            ], {
+              type: 'application/octet-stream'
+            });
+
+            var glbReader = new window.FileReader();
+            glbReader.readAsArrayBuffer(glbBlob);
+            glbReader.onloadend = function() {
+
+              onDone(glbReader.result);
+
+            };
+
+          };
+
+        } else {
+
+          reader.readAsDataURL(blob);
+          reader.onloadend = function() {
+
+            var base64data = reader.result;
+            outputJSON.buffers[0].uri = base64data;
+            onDone(outputJSON);
+
+          };
+
+        }
+
+      } else {
+
+        onDone(outputJSON);
+
+      }
+
+    });
+
+  }
+
+};

src/index.js

@@ -1,2385 +1,20 @@
-const THREE = RK;
-THREE.Vector3 = THREE.Vec3;
-/*
-─ │ └ ├ ┌ ┬
+const tree = require('./tree')
+const walk = require('./walk')
 
-─ single item
+const THREE = require('./three')
 
-─ two items
-─ two items
-                                           last, children
-┬ root                 ['',   '',   '┬ ']     [true, true]
-├── first child        ['',   '├─', '─ ']     [false, false]
-├─┬ child parent       ['',   '├─', '┬ ']     [false, true]
-│ ├── first child      ['│ ', '├─', '─ ']     [false, false]
-│ └─┬ child parent     ['│ ', '└─', '┬ ']     [true, true]
-│   ├── first child    ['│   ', '├─', '─ ']   [false, false]
-│   └── last child     ['│   ', '└─', '─ ']   [true, false]
-└── last child         ['', '└─', '─ ']       [true, false]
-
-parent is last child ? '  ' : '│ '
-
-nSibling      part 1: ├─
-lastSibling   part 1: └─
-
-hasChildren   part 2: ┬
-noChildren    part 2: ─
-
-*/
-
-window.console.tree = (obj, prop, toString, forEach) => {
-  if (!toString) toString = x => x === null ? 'null' : x === undefined ? 'undefined' : x.toString()
-  if (!prop) {
-    prop = obj.children ? 'children'
-      : obj.childNodes ? 'childNodes'
-      : null
-  }
-  const output = []
-  const walk = (obj, part0, lastSibling) => {
-    let children = obj[prop]
-    if (children && !Array.isArray(children)) children = Array.from(children)
-    const len = children && children.length || 0
-    const part1 = lastSibling ? '└─' : '├─'
-    const part2 = len ? '┬ ' : '─ '
-    output.push(part0 + part1 + part2 + toString(obj))
-    if (forEach) forEach(obj, part0 + part1 + part2)
-    children.forEach((child, i) => {
-      walk(child, part0 + (lastSibling ? '  ' : '│ '), i === len - 1)
-    })
-  }
-  walk(obj, '  ', true)
-  return output.join('\n')
-}
-
-window.console.tree.withObject = (obj, prop, toString) => window.console.tree(obj, prop, toString, (x, y) => console.log(y, x)) && undefined
-
-window.console.tree.groups = (obj, prop) => {
-  if (!prop) {
-    prop = obj.children ? 'children'
-      : obj.childNodes ? 'childNodes'
-      : null
-  }
-  const walk = (obj) => {
-    let children = obj[prop]
-    if (children && !Array.isArray(children)) children = Array.from(children)
-    if (children && children.length) {
-        console.group(obj)
-        children.forEach(walk)
-        console.groupEnd()
-    } else {
-      console.log(obj)
-    }
-  }
-  walk(obj)
-}
-
-window.walk = function(root) {
-/*      const walk = (obj, i, tree, more) => {
-     const indent = tree + (more ? ' ├' : ' └')  //"".padRight(i * 2, ' ')
-     console.log(indent + obj.toString())
-     if (obj && obj.children) obj.children.forEach((x, y) => walk(x, i + 1, tree + (y < obj.children.length - 1 ? ' │' : '  '), y < obj.children.length - 1))
-  }
-  */
-  const walk = (obj, part0, lastSibling) => {
-    const part1 = lastSibling ? '└─' : '├─'
-    const part2 = obj.children.length ? '┬ ' : '─ '
-    console.log(part0 + part1 + part2 + obj.toString())
-    obj.children.forEach((child, i) => {
-      walk(child, part0 + (lastSibling ? '  ' : '│ '), i === obj.children.length - 1)
-    })
-  }
-  walk(root, '  ', true)
-}
-
-Object.keys(RK).forEach(key => {
-  const Type = RK[key]
-  if (Type && Type.prototype && !Type.prototype.hasOwnProperty('toString')) {
-    Type.prototype.toString = function() {
-      const description = [key, this.name, this.id].filter(x => x === 0 || x).join(' ')
-      return `[${description}]`
-    }
-  }
-})
-
-/**
-* @author fernandojsg / http://fernandojsg.com
-* @author Don McCurdy / https://www.donmccurdy.com
-* @author Takahiro / https://github.com/takahirox
-*/
-
-//------------------------------------------------------------------------------
-// Constants
-//------------------------------------------------------------------------------
-var WEBGL_CONSTANTS = {
-POINTS: 0x0000,
-LINES: 0x0001,
-LINE_LOOP: 0x0002,
-LINE_STRIP: 0x0003,
-TRIANGLES: 0x0004,
-TRIANGLE_STRIP: 0x0005,
-TRIANGLE_FAN: 0x0006,
-
-UNSIGNED_BYTE: 0x1401,
-UNSIGNED_SHORT: 0x1403,
-FLOAT: 0x1406,
-UNSIGNED_INT: 0x1405,
-ARRAY_BUFFER: 0x8892,
-ELEMENT_ARRAY_BUFFER: 0x8893,
-
-NEAREST: 0x2600,
-LINEAR: 0x2601,
-NEAREST_MIPMAP_NEAREST: 0x2700,
-LINEAR_MIPMAP_NEAREST: 0x2701,
-NEAREST_MIPMAP_LINEAR: 0x2702,
-LINEAR_MIPMAP_LINEAR: 0x2703
-};
-
-var THREE_TO_WEBGL = {
-// @TODO Replace with computed property name [THREE.*] when available on es6
-1003: WEBGL_CONSTANTS.NEAREST,
-1004: WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST,
-1005: WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR,
-1006: WEBGL_CONSTANTS.LINEAR,
-1007: WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST,
-1008: WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR
-};
-
-var PATH_PROPERTIES = {
-scale: 'scale',
-position: 'translation',
-quaternion: 'rotation',
-morphTargetInfluences: 'weights'
-};
-
-//------------------------------------------------------------------------------
-// GLTF Exporter
-//------------------------------------------------------------------------------
-THREE.GLTFExporter = function () {};
-
-THREE.GLTFExporter.prototype = {
-
-constructor: THREE.GLTFExporter,
-
-/**
-* Parse scenes and generate GLTF output
-* @param  {THREE.Scene or [THREE.Scenes]} input   THREE.Scene or Array of THREE.Scenes
-* @param  {Function} onDone  Callback on completed
-* @param  {Object} options options
-*/
-parse: function ( input, onDone, options ) {
-
-var DEFAULT_OPTIONS = {
-  binary: false,
-  trs: false,
-  onlyVisible: true,
-  truncateDrawRange: true,
-  embedImages: true,
-  animations: [],
-  forceIndices: false,
-  forcePowerOfTwoTextures: false
-};
-
-options = Object.assign( {}, DEFAULT_OPTIONS, options );
-
-if ( options.animations.length > 0 ) {
-
-  // Only TRS properties, and not matrices, may be targeted by animation.
-  options.trs = true;
-
-}
-
-var outputJSON = {
-
-  asset: {
-
-    version: "2.0",
-    generator: "THREE.GLTFExporter"
-
-  }
-
-};
-
-var byteOffset = 0;
-var buffers = [];
-var pending = [];
-var nodeMap = new Map();
-var skins = [];
-var extensionsUsed = {};
-var cachedData = {
-
-  attributes: new Map(),
-  materials: new Map(),
-  textures: new Map()
-
-};
-
-var cachedCanvas;
-
-/**
- * Compare two arrays
- */
-/**
- * Compare two arrays
- * @param  {Array} array1 Array 1 to compare
- * @param  {Array} array2 Array 2 to compare
- * @return {Boolean}        Returns true if both arrays are equal
- */
-function equalArray( array1, array2 ) {
-
-  return ( array1.length === array2.length ) && array1.every( function ( element, index ) {
-
-    return element === array2[ index ];
-
-  } );
-
-}
-
-/**
- * Converts a string to an ArrayBuffer.
- * @param  {string} text
- * @return {ArrayBuffer}
- */
-function stringToArrayBuffer( text ) {
-
-  if ( window.TextEncoder !== undefined ) {
-
-    return new TextEncoder().encode( text ).buffer;
-
-  }
-
-  var array = new Uint8Array( new ArrayBuffer( text.length ) );
-
-  for ( var i = 0, il = text.length; i < il; i ++ ) {
-
-    var value = text.charCodeAt( i );
-
-    // Replacing multi-byte character with space(0x20).
-    array[ i ] = value > 0xFF ? 0x20 : value;
-
-  }
-
-  return array.buffer;
-
-}
-
-/**
- * Get the min and max vectors from the given attribute
- * @param  {THREE.BufferAttribute} attribute Attribute to find the min/max in range from start to start + count
- * @param  {Integer} start
- * @param  {Integer} count
- * @return {Object} Object containing the `min` and `max` values (As an array of attribute.itemSize components)
- */
-function getMinMax( attribute, start, count ) {
-
-  var output = {
-
-    min: new Array( attribute.itemSize ).fill( Number.POSITIVE_INFINITY ),
-    max: new Array( attribute.itemSize ).fill( Number.NEGATIVE_INFINITY )
-
-  };
-
-  for ( var i = start; i < start + count; i ++ ) {
-
-    for ( var a = 0; a < attribute.itemSize; a ++ ) {
-
-      var value = attribute.array[ i * attribute.itemSize + a ];
-      output.min[ a ] = Math.min( output.min[ a ], value );
-      output.max[ a ] = Math.max( output.max[ a ], value );
-
-    }
-
-  }
-
-  return output;
-
-}
-
-/**
- * Checks if image size is POT.
- *
- * @param {Image} image The image to be checked.
- * @returns {Boolean} Returns true if image size is POT.
- *
- */
-function isPowerOfTwo( image ) {
-
-  return THREE.Math.isPowerOfTwo( image.width ) && THREE.Math.isPowerOfTwo( image.height );
-
-}
-
-/**
- * Checks if normal attribute values are normalized.
- *
- * @param {THREE.BufferAttribute} normal
- * @returns {Boolean}
- *
- */
-function isNormalizedNormalAttribute( normal ) {
-
-  if ( cachedData.attributes.has( normal ) ) {
-
-    return false;
-
-  }
-
-  var v = new THREE.Vector3();
-
-  for ( var i = 0, il = normal.count; i < il; i ++ ) {
-
-    // 0.0005 is from glTF-validator
-    if ( Math.abs( v.fromArray( normal.array, i * 3 ).length() - 1.0 ) > 0.0005 ) return false;
-
-  }
-
-  return true;
-
-}
-
-/**
- * Creates normalized normal buffer attribute.
- *
- * @param {THREE.BufferAttribute} normal
- * @returns {THREE.BufferAttribute}
- *
- */
-function createNormalizedNormalAttribute( normal ) {
-
-  if ( cachedData.attributes.has( normal ) ) {
-
-    return cachedData.textures.get( normal );
-
-  }
-
-  var attribute = normal.clone();
-
-  var v = new THREE.Vector3();
-
-  for ( var i = 0, il = attribute.count; i < il; i ++ ) {
-
-    v.fromArray( attribute.array, i * 3 );
-
-    if ( v.x === 0 && v.y === 0 && v.z === 0 ) {
-
-      // if values can't be normalized set (1, 0, 0)
-      v.setX( 1.0 );
-
-    } else {
-
-      v.normalize();
-
-    }
-
-    v.toArray( attribute.array, i * 3 );
-
-  }
-
-  cachedData.attributes.set( normal, attribute );
-
-  return attribute;
-
-}
-
-/**
- * Get the required size + padding for a buffer, rounded to the next 4-byte boundary.
- * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#data-alignment
- *
- * @param {Integer} bufferSize The size the original buffer.
- * @returns {Integer} new buffer size with required padding.
- *
- */
-function getPaddedBufferSize( bufferSize ) {
-
-  return Math.ceil( bufferSize / 4 ) * 4;
-
-}
-
-/**
- * Returns a buffer aligned to 4-byte boundary.
- *
- * @param {ArrayBuffer} arrayBuffer Buffer to pad
- * @param {Integer} paddingByte (Optional)
- * @returns {ArrayBuffer} The same buffer if it's already aligned to 4-byte boundary or a new buffer
- */
-function getPaddedArrayBuffer( arrayBuffer, paddingByte ) {
-
-  paddingByte = paddingByte || 0;
-
-  var paddedLength = getPaddedBufferSize( arrayBuffer.byteLength );
-
-  if ( paddedLength !== arrayBuffer.byteLength ) {
-
-    var array = new Uint8Array( paddedLength );
-    array.set( new Uint8Array( arrayBuffer ) );
-
-    if ( paddingByte !== 0 ) {
-
-      for ( var i = arrayBuffer.byteLength; i < paddedLength; i ++ ) {
-
-        array[ i ] = paddingByte;
-
-      }
-
-    }
-
-    return array.buffer;
-
-  }
-
-  return arrayBuffer;
-
-}
-
-/**
- * Serializes a userData.
- *
- * @param {THREE.Object3D|THREE.Material} object
- * @returns {Object}
- */
-function serializeUserData( object ) {
-
-  try {
-
-    return JSON.parse( JSON.stringify( object.userData ) );
-
-  } catch ( error ) {
-
-    console.warn( 'THREE.GLTFExporter: userData of \'' + object.name + '\' ' +
-      'won\'t be serialized because of JSON.stringify error - ' + error.message );
-
-    return {};
-
-  }
-
-}
-
-/**
- * Process a buffer to append to the default one.
- * @param  {ArrayBuffer} buffer
- * @return {Integer}
- */
-function processBuffer( buffer ) {
-
-  if ( ! outputJSON.buffers ) {
-
-    outputJSON.buffers = [ { byteLength: 0 } ];
-
-  }
-
-  // All buffers are merged before export.
-  buffers.push( buffer );
-
-  return 0;
-
-}
-
-/**
- * Process and generate a BufferView
- * @param  {THREE.BufferAttribute} attribute
- * @param  {number} componentType
- * @param  {number} start
- * @param  {number} count
- * @param  {number} target (Optional) Target usage of the BufferView
- * @return {Object}
- */
-function processBufferView( attribute, componentType, start, count, target ) {
-
-  if ( ! outputJSON.bufferViews ) {
-
-    outputJSON.bufferViews = [];
-
-  }
-
-  // Create a new dataview and dump the attribute's array into it
-
-  var componentSize;
-
-  if ( componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE ) {
-
-    componentSize = 1;
-
-  } else if ( componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT ) {
-
-    componentSize = 2;
-
-  } else {
-
-    componentSize = 4;
-
-  }
-
-  var byteLength = getPaddedBufferSize( count * attribute.itemSize * componentSize );
-  var dataView = new DataView( new ArrayBuffer( byteLength ) );
-  var offset = 0;
-
-  for ( var i = start; i < start + count; i ++ ) {
-
-    for ( var a = 0; a < attribute.itemSize; a ++ ) {
-
-      // @TODO Fails on InterleavedBufferAttribute, and could probably be
-      // optimized for normal BufferAttribute.
-      var value = attribute.array[ i * attribute.itemSize + a ];
-
-      if ( componentType === WEBGL_CONSTANTS.FLOAT ) {
-
-        dataView.setFloat32( offset, value, true );
-
-      } else if ( componentType === WEBGL_CONSTANTS.UNSIGNED_INT ) {
-
-        dataView.setUint32( offset, value, true );
-
-      } else if ( componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT ) {
-
-        dataView.setUint16( offset, value, true );
-
-      } else if ( componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE ) {
-
-        dataView.setUint8( offset, value );
-
-      }
-
-      offset += componentSize;
-
-    }
-
-  }
-
-  var gltfBufferView = {
-
-    buffer: processBuffer( dataView.buffer ),
-    byteOffset: byteOffset,
-    byteLength: byteLength
-
-  };
-
-  if ( target !== undefined ) gltfBufferView.target = target;
-
-  if ( target === WEBGL_CONSTANTS.ARRAY_BUFFER ) {
-
-    // Only define byteStride for vertex attributes.
-    gltfBufferView.byteStride = attribute.itemSize * componentSize;
-
-  }
-
-  byteOffset += byteLength;
-
-  outputJSON.bufferViews.push( gltfBufferView );
-
-  // @TODO Merge bufferViews where possible.
-  var output = {
-
-    id: outputJSON.bufferViews.length - 1,
-    byteLength: 0
-
-  };
-
-  return output;
-
-}
-
-/**
- * Process and generate a BufferView from an image Blob.
- * @param {Blob} blob
- * @return {Promise<Integer>}
- */
-function processBufferViewImage( blob ) {
-
-  if ( ! outputJSON.bufferViews ) {
-
-    outputJSON.bufferViews = [];
-
-  }
-
-  return new Promise( function ( resolve ) {
-
-    var reader = new window.FileReader();
-    reader.readAsArrayBuffer( blob );
-    reader.onloadend = function () {
-
-      var buffer = getPaddedArrayBuffer( reader.result );
-
-      var bufferView = {
-        buffer: processBuffer( buffer ),
-        byteOffset: byteOffset,
-        byteLength: buffer.byteLength
-      };
-
-      byteOffset += buffer.byteLength;
-
-      outputJSON.bufferViews.push( bufferView );
-
-      resolve( outputJSON.bufferViews.length - 1 );
-
-    };
-
-  } );
-
-}
-
-/**
- * Process attribute to generate an accessor
- * @param  {THREE.BufferAttribute} attribute Attribute to process
- * @param  {THREE.BufferGeometry} geometry (Optional) Geometry used for truncated draw range
- * @param  {Integer} start (Optional)
- * @param  {Integer} count (Optional)
- * @return {Integer}           Index of the processed accessor on the "accessors" array
- */
-function processAccessor( attribute, geometry, start, count ) {
-
-  var types = {
-
-    1: 'SCALAR',
-    2: 'VEC2',
-    3: 'VEC3',
-    4: 'VEC4',
-    16: 'MAT4'
-
-  };
-
-  var componentType;
-
-  // Detect the component type of the attribute array (float, uint or ushort)
-  if ( attribute.array.constructor === Float32Array ) {
-
-    componentType = WEBGL_CONSTANTS.FLOAT;
-
-  } else if ( attribute.array.constructor === Uint32Array ) {
-
-    componentType = WEBGL_CONSTANTS.UNSIGNED_INT;
-
-  } else if ( attribute.array.constructor === Uint16Array ) {
-
-    componentType = WEBGL_CONSTANTS.UNSIGNED_SHORT;
-
-  } else if ( attribute.array.constructor === Uint8Array ) {
-
-    componentType = WEBGL_CONSTANTS.UNSIGNED_BYTE;
-
-  } else {
-
-    throw new Error( 'THREE.GLTFExporter: Unsupported bufferAttribute component type.' );
-
-  }
-
-  if ( start === undefined ) start = 0;
-  if ( count === undefined ) count = attribute.count;
-
-  // @TODO Indexed buffer geometry with drawRange not supported yet
-  if ( options.truncateDrawRange && geometry !== undefined && geometry.index === null ) {
-
-    var end = start + count;
-    var end2 = geometry.drawRange.count === Infinity
-        ? attribute.count
-        : geometry.drawRange.start + geometry.drawRange.count;
-
-    start = Math.max( start, geometry.drawRange.start );
-    count = Math.min( end, end2 ) - start;
-
-    if ( count < 0 ) count = 0;
-
-  }
-
-  // Skip creating an accessor if the attribute doesn't have data to export
-  if ( count === 0 ) {
-
-    return null;
-
-  }
-
-  var minMax = getMinMax( attribute, start, count );
-
-  var bufferViewTarget;
-
-  // If geometry isn't provided, don't infer the target usage of the bufferView. For
-  // animation samplers, target must not be set.
-  if ( geometry !== undefined ) {
-
-    bufferViewTarget = attribute === geometry.index ? WEBGL_CONSTANTS.ELEMENT_ARRAY_BUFFER : WEBGL_CONSTANTS.ARRAY_BUFFER;
-
-  }
-
-  var bufferView = processBufferView( attribute, componentType, start, count, bufferViewTarget );
-
-  var gltfAccessor = {
-
-    bufferView: bufferView.id,
-    byteOffset: bufferView.byteOffset,
-    componentType: componentType,
-    count: count,
-    max: minMax.max,
-    min: minMax.min,
-    type: types[ attribute.itemSize ]
-
-  };
-
-  if ( ! outputJSON.accessors ) {
-
-    outputJSON.accessors = [];
-
-  }
-
-  outputJSON.accessors.push( gltfAccessor );
-
-  return outputJSON.accessors.length - 1;
-
-}
-
-/**
- * Process image
- * @param  {Texture} map Texture to process
- * @return {Integer}     Index of the processed texture in the "images" array
- */
-function processImage( map ) {
-
-  // @TODO Cache
-
-  if ( ! outputJSON.images ) {
-
-    outputJSON.images = [];
-
-  }
-
-  var mimeType = map.format === THREE.RGBAFormat ? 'image/png' : 'image/jpeg';
-  var gltfImage = { mimeType: mimeType };
-
-  if ( options.embedImages ) {
-
-    var canvas = cachedCanvas = cachedCanvas || document.createElement( 'canvas' );
-
-    canvas.width = map.image.width;
-    canvas.height = map.image.height;
-
-    if ( options.forcePowerOfTwoTextures && ! isPowerOfTwo( map.image ) ) {
-
-      console.warn( 'GLTFExporter: Resized non-power-of-two image.', map.image );
-
-      canvas.width = THREE.Math.floorPowerOfTwo( canvas.width );
-      canvas.height = THREE.Math.floorPowerOfTwo( canvas.height );
-
-    }
-
-    var ctx = canvas.getContext( '2d' );
-
-    if ( map.flipY === true ) {
-
-      ctx.translate( 0, canvas.height );
-      ctx.scale( 1, - 1 );
-
-    }
-
-    ctx.drawImage( map.image, 0, 0, canvas.width, canvas.height );
-
-    if ( options.binary === true ) {
-
-      pending.push( new Promise( function ( resolve ) {
-
-        canvas.toBlob( function ( blob ) {
-
-          processBufferViewImage( blob ).then( function ( bufferViewIndex ) {
-
-            gltfImage.bufferView = bufferViewIndex;
-
-            resolve();
-
-          } );
-
-        }, mimeType );
-
-      } ) );
-
-    } else {
-
-      gltfImage.uri = canvas.toDataURL( mimeType );
-
-    }
-
-  } else {
-
-    gltfImage.uri = map.image.src;
-
-  }
-
-  outputJSON.images.push( gltfImage );
-
-  return outputJSON.images.length - 1;
-
-}
-
-/**
- * Process sampler
- * @param  {Texture} map Texture to process
- * @return {Integer}     Index of the processed texture in the "samplers" array
- */
-function processSampler( map ) {
-
-  if ( ! outputJSON.samplers ) {
-
-    outputJSON.samplers = [];
-
-  }
-
-  var gltfSampler = {
-
-    magFilter: THREE_TO_WEBGL[ map.magFilter ],
-    minFilter: THREE_TO_WEBGL[ map.minFilter ],
-    wrapS: THREE_TO_WEBGL[ map.wrapS ],
-    wrapT: THREE_TO_WEBGL[ map.wrapT ]
-
-  };
-
-  outputJSON.samplers.push( gltfSampler );
-
-  return outputJSON.samplers.length - 1;
-
-}
-
-/**
- * Process texture
- * @param  {Texture} map Map to process
- * @return {Integer}     Index of the processed texture in the "textures" array
- */
-function processTexture( map ) {
-
-  if ( cachedData.textures.has( map ) ) {
-
-    return cachedData.textures.get( map );
-
-  }
-
-  if ( ! outputJSON.textures ) {
-
-    outputJSON.textures = [];
-
-  }
-
-  var gltfTexture = {
-
-    sampler: processSampler( map ),
-    source: processImage( map )
-
-  };
-
-  outputJSON.textures.push( gltfTexture );
-
-  var index = outputJSON.textures.length - 1;
-  cachedData.textures.set( map, index );
-
-  return index;
-
-}
-
-/**
- * Process material
- * @param  {THREE.Material} material Material to process
- * @return {Integer}      Index of the processed material in the "materials" array
- */
-function processMaterial( material ) {
-
-  if ( cachedData.materials.has( material ) ) {
-
-    return cachedData.materials.get( material );
-
-  }
-
-  if ( ! outputJSON.materials ) {
-
-    outputJSON.materials = [];
-
-  }
-
-  if ( material.isShaderMaterial ) {
-
-    console.warn( 'GLTFExporter: THREE.ShaderMaterial not supported.' );
-    return null;
-
-  }
-
-  // @QUESTION Should we avoid including any attribute that has the default value?
-  var gltfMaterial = {
-
-    pbrMetallicRoughness: {}
-
-  };
-
-  if ( material.isMeshBasicMaterial ) {
-
-    gltfMaterial.extensions = { KHR_materials_unlit: {} };
-
-    extensionsUsed[ 'KHR_materials_unlit' ] = true;
-
-  } else if ( ! material.isMeshStandardMaterial ) {
-
-    console.warn( 'GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.' );
-
-  }
-
-  // pbrMetallicRoughness.baseColorFactor
-  var color = material.color.toArray().concat( [ material.opacity ] );
-
-  if ( ! equalArray( color, [ 1, 1, 1, 1 ] ) ) {
-
-    gltfMaterial.pbrMetallicRoughness.baseColorFactor = color;
-
-  }
-
-  if ( material.isMeshStandardMaterial ) {
-
-    gltfMaterial.pbrMetallicRoughness.metallicFactor = material.metalness;
-    gltfMaterial.pbrMetallicRoughness.roughnessFactor = material.roughness;
-
-  } else if ( material.isMeshBasicMaterial ) {
-
-    gltfMaterial.pbrMetallicRoughness.metallicFactor = 0.0;
-    gltfMaterial.pbrMetallicRoughness.roughnessFactor = 0.9;
-
-  } else {
-
-    gltfMaterial.pbrMetallicRoughness.metallicFactor = 0.5;
-    gltfMaterial.pbrMetallicRoughness.roughnessFactor = 0.5;
-
-  }
-
-  // pbrMetallicRoughness.metallicRoughnessTexture
-  if ( material.metalnessMap || material.roughnessMap ) {
-
-    if ( material.metalnessMap === material.roughnessMap ) {
-
-      gltfMaterial.pbrMetallicRoughness.metallicRoughnessTexture = {
-
-        index: processTexture( material.metalnessMap )
-
-      };
-
-    } else {
-
-      console.warn( 'THREE.GLTFExporter: Ignoring metalnessMap and roughnessMap because they are not the same Texture.' );
-
-    }
-
-  }
-
-  // pbrMetallicRoughness.baseColorTexture
-  if ( material.map ) {
-
-    gltfMaterial.pbrMetallicRoughness.baseColorTexture = {
-
-      index: processTexture( material.map )
-
-    };
-
-  }
-
-  if ( material.isMeshBasicMaterial ||
-    material.isLineBasicMaterial ||
-    material.isPointsMaterial ) {
-
-  } else {
-
-    // emissiveFactor
-    var emissive = material.emissive.clone().multiplyScalar( material.emissiveIntensity ).toArray();
-
-    if ( ! equalArray( emissive, [ 0, 0, 0 ] ) ) {
-
-      gltfMaterial.emissiveFactor = emissive;
-
-    }
-
-    // emissiveTexture
-    if ( material.emissiveMap ) {
-
-      gltfMaterial.emissiveTexture = {
-
-        index: processTexture( material.emissiveMap )
-
-      };
-
-    }
-
-  }
-
-  // normalTexture
-  if ( material.normalMap ) {
-
-    gltfMaterial.normalTexture = {
-
-      index: processTexture( material.normalMap )
-
-    };
-
-    if ( material.normalScale.x !== - 1 ) {
-
-      if ( material.normalScale.x !== material.normalScale.y ) {
-
-        console.warn( 'THREE.GLTFExporter: Normal scale components are different, ignoring Y and exporting X.' );
-
-      }
-
-      gltfMaterial.normalTexture.scale = material.normalScale.x;
-
-    }
-
-  }
-
-  // occlusionTexture
-  if ( material.aoMap ) {
-
-    gltfMaterial.occlusionTexture = {
-
-      index: processTexture( material.aoMap )
-
-    };
-
-    if ( material.aoMapIntensity !== 1.0 ) {
-
-      gltfMaterial.occlusionTexture.strength = material.aoMapIntensity;
-
-    }
-
-  }
-
-  // alphaMode
-  if ( material.transparent || material.alphaTest > 0.0 ) {
-
-    gltfMaterial.alphaMode = material.opacity < 1.0 ? 'BLEND' : 'MASK';
-
-    // Write alphaCutoff if it's non-zero and different from the default (0.5).
-    if ( material.alphaTest > 0.0 && material.alphaTest !== 0.5 ) {
-
-      gltfMaterial.alphaCutoff = material.alphaTest;
-
-    }
-
-  }
-
-  // doubleSided
-  if ( material.side === THREE.DoubleSide ) {
-
-    gltfMaterial.doubleSided = true;
-
-  }
-
-  if ( material.name !== '' ) {
-
-    gltfMaterial.name = material.name;
-
-  }
-
-  if ( Object.keys( material.userData ).length > 0 ) {
-
-    gltfMaterial.extras = serializeUserData( material );
-
-  }
-
-  outputJSON.materials.push( gltfMaterial );
-
-  var index = outputJSON.materials.length - 1;
-  cachedData.materials.set( material, index );
-
-  return index;
-
-}
-
-/**
- * Process mesh
- * @param  {THREE.Mesh} mesh Mesh to process
- * @return {Integer}      Index of the processed mesh in the "meshes" array
- */
-function processMesh( mesh ) {
-
-  var geometry = mesh.geometry;
-
-  var mode;
-
-  // Use the correct mode
-  if ( mesh.isLineSegments ) {
-
-    mode = WEBGL_CONSTANTS.LINES;
-
-  } else if ( mesh.isLineLoop ) {
-
-    mode = WEBGL_CONSTANTS.LINE_LOOP;
-
-  } else if ( mesh.isLine ) {
-
-    mode = WEBGL_CONSTANTS.LINE_STRIP;
-
-  } else if ( mesh.isPoints ) {
-
-    mode = WEBGL_CONSTANTS.POINTS;
-
-  } else {
-
-    if ( ! geometry.isBufferGeometry ) {
-
-      var geometryTemp = new THREE.BufferGeometry();
-      geometryTemp.fromGeometry( geometry );
-      geometry = geometryTemp;
-
-    }
-
-    if ( mesh.drawMode === THREE.TriangleFanDrawMode ) {
-
-      console.warn( 'GLTFExporter: TriangleFanDrawMode and wireframe incompatible.' );
-      mode = WEBGL_CONSTANTS.TRIANGLE_FAN;
-
-    } else if ( mesh.drawMode === THREE.TriangleStripDrawMode ) {
-
-      mode = mesh.material.wireframe ? WEBGL_CONSTANTS.LINE_STRIP : WEBGL_CONSTANTS.TRIANGLE_STRIP;
-
-    } else {
-
-      mode = mesh.material.wireframe ? WEBGL_CONSTANTS.LINES : WEBGL_CONSTANTS.TRIANGLES;
-
-    }
-
-  }
-
-  var gltfMesh = {};
-
-  var attributes = {};
-  var primitives = [];
-  var targets = [];
-
-  // Conversion between attributes names in threejs and gltf spec
-  var nameConversion = {
-
-    uv: 'TEXCOORD_0',
-    uv2: 'TEXCOORD_1',
-    color: 'COLOR_0',
-    skinWeight: 'WEIGHTS_0',
-    skinIndex: 'JOINTS_0'
-
-  };
-
-  var originalNormal = geometry.getAttribute( 'normal' );
-
-  if ( originalNormal !== undefined && ! isNormalizedNormalAttribute( originalNormal ) ) {
-
-    console.warn( 'THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one.' );
-
-    geometry.addAttribute( 'normal', createNormalizedNormalAttribute( originalNormal ) );
-
-  }
-
-  // @QUESTION Detect if .vertexColors = THREE.VertexColors?
-  // For every attribute create an accessor
-  for ( var attributeName in geometry.attributes ) {
-
-    var attribute = geometry.attributes[ attributeName ];
-    attributeName = nameConversion[ attributeName ] || attributeName.toUpperCase();
-
-    // JOINTS_0 must be UNSIGNED_BYTE or UNSIGNED_SHORT.
-    var array = attribute.array;
-    if ( attributeName === 'JOINTS_0' &&
-      ! ( array instanceof Uint16Array ) &&
-      ! ( array instanceof Uint8Array ) ) {
-
-      console.warn( 'GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.' );
-      attribute = new THREE.BufferAttribute( new Uint16Array( array ), attribute.itemSize, attribute.normalized );
-
-    }
-
-    if ( attributeName.substr( 0, 5 ) !== 'MORPH' ) {
-
-      var accessor = processAccessor( attribute, geometry );
-      if ( accessor !== null ) {
-
-        attributes[ attributeName ] = accessor;
-
-      }
-
-    }
-
-  }
-
-  if ( originalNormal !== undefined ) geometry.addAttribute( 'normal', originalNormal );
-
-  // Skip if no exportable attributes found
-  if ( Object.keys( attributes ).length === 0 ) {
-
-    return null;
-
-  }
-
-  // Morph targets
-  if ( mesh.morphTargetInfluences !== undefined && mesh.morphTargetInfluences.length > 0 ) {
-
-    var weights = [];
-    var targetNames = [];
-    var reverseDictionary = {};
-
-    if ( mesh.morphTargetDictionary !== undefined ) {
-
-      for ( var key in mesh.morphTargetDictionary ) {
-
-        reverseDictionary[ mesh.morphTargetDictionary[ key ] ] = key;
-
-      }
-
-    }
-
-    for ( var i = 0; i < mesh.morphTargetInfluences.length; ++ i ) {
-
-      var target = {};
-
-      var warned = false;
-
-      for ( var attributeName in geometry.morphAttributes ) {
-
-        // glTF 2.0 morph supports only POSITION/NORMAL/TANGENT.
-        // Three.js doesn't support TANGENT yet.
-
-        if ( attributeName !== 'position' && attributeName !== 'normal' ) {
-
-          if ( ! warned ) {
-
-            console.warn( 'GLTFExporter: Only POSITION and NORMAL morph are supported.' );
-            warned = true;
-
-          }
-
-          continue;
-
-        }
-
-        var attribute = geometry.morphAttributes[ attributeName ][ i ];
-
-        // Three.js morph attribute has absolute values while the one of glTF has relative values.
-        //
-        // glTF 2.0 Specification:
-        // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#morph-targets
-
-        var baseAttribute = geometry.attributes[ attributeName ];
-        // Clones attribute not to override
-        var relativeAttribute = attribute.clone();
-
-        for ( var j = 0, jl = attribute.count; j < jl; j ++ ) {
-
-          relativeAttribute.setXYZ(
-            j,
-            attribute.getX( j ) - baseAttribute.getX( j ),
-            attribute.getY( j ) - baseAttribute.getY( j ),
-            attribute.getZ( j ) - baseAttribute.getZ( j )
-          );
-
-        }
-
-        target[ attributeName.toUpperCase() ] = processAccessor( relativeAttribute, geometry );
-
-      }
-
-      targets.push( target );
-
-      weights.push( mesh.morphTargetInfluences[ i ] );
-      if ( mesh.morphTargetDictionary !== undefined ) targetNames.push( reverseDictionary[ i ] );
-
-    }
-
-    gltfMesh.weights = weights;
-
-    if ( targetNames.length > 0 ) {
-
-      gltfMesh.extras = {};
-      gltfMesh.extras.targetNames = targetNames;
-
-    }
-
-  }
-
-  var extras = ( Object.keys( geometry.userData || [] ).length > 0 ) ? serializeUserData( geometry ) : undefined;
-
-  var forceIndices = options.forceIndices;
-  var isMultiMaterial = Array.isArray( mesh.material );
-
-  if ( isMultiMaterial && mesh.geometry.groups.length === 0 ) return null;
-
-  if ( ! forceIndices && geometry.index === null && isMultiMaterial ) {
-
-    // temporal workaround.
-    console.warn( 'THREE.GLTFExporter: Creating index for non-indexed multi-material mesh.' );
-    forceIndices = true;
-
-  }
-
-  var didForceIndices = false;
-
-  if ( geometry.index === null && forceIndices ) {
-
-    var indices = [];
-
-    for ( var i = 0, il = geometry.attributes.position.count; i < il; i ++ ) {
-
-      indices[ i ] = i;
-
-    }
-
-    geometry.setIndex( indices );
-
-    didForceIndices = true;
-
-  }
-
-  var materials = isMultiMaterial ? mesh.material : [ mesh.material ];
-  var groups = isMultiMaterial ? mesh.geometry.groups : [ { materialIndex: 0, start: undefined, count: undefined } ];
-
-  for ( var i = 0, il = groups.length; i < il; i ++ ) {
-
-    var primitive = {
-      mode: mode,
-      attributes: attributes,
-    };
-
-    if ( extras ) primitive.extras = extras;
-
-    if ( targets.length > 0 ) primitive.targets = targets;
-
-    if ( geometry.index !== null ) {
-
-      primitive.indices = processAccessor( geometry.index, geometry, groups[ i ].start, groups[ i ].count );
-
-    }
-
-    var material = processMaterial( materials[ groups[ i ].materialIndex ] );
-
-    if ( material !== null ) {
-
-      primitive.material = material;
-
-    }
-
-    primitives.push( primitive );
-
-  }
-
-  if ( didForceIndices ) {
-
-    geometry.setIndex( null );
-
-  }
-
-  gltfMesh.primitives = primitives;
-
-  if ( ! outputJSON.meshes ) {
-
-    outputJSON.meshes = [];
-
-  }
-
-  outputJSON.meshes.push( gltfMesh );
-
-  return outputJSON.meshes.length - 1;
-
-}
-
-/**
- * Process camera
- * @param  {THREE.Camera} camera Camera to process
- * @return {Integer}      Index of the processed mesh in the "camera" array
- */
-function processCamera( camera ) {
-
-  if ( ! outputJSON.cameras ) {
-
-    outputJSON.cameras = [];
-
-  }
-
-  var isOrtho = camera.isOrthographicCamera;
-
-  var gltfCamera = {
-
-    type: isOrtho ? 'orthographic' : 'perspective'
-
-  };
-
-  if ( isOrtho ) {
-
-    gltfCamera.orthographic = {
-
-      xmag: camera.right * 2,
-      ymag: camera.top * 2,
-      zfar: camera.far <= 0 ? 0.001 : camera.far,
-      znear: camera.near < 0 ? 0 : camera.near
-
-    };
-
-  } else {
-
-    gltfCamera.perspective = {
-
-      aspectRatio: camera.aspect,
-      yfov: THREE.Math.degToRad( camera.fov ) / camera.aspect,
-      zfar: camera.far <= 0 ? 0.001 : camera.far,
-      znear: camera.near < 0 ? 0 : camera.near
-
-    };
-
-  }
-
-  if ( camera.name !== '' ) {
-
-    gltfCamera.name = camera.type;
-
-  }
-
-  outputJSON.cameras.push( gltfCamera );
-
-  return outputJSON.cameras.length - 1;
-
-}
-
-/**
- * Creates glTF animation entry from AnimationClip object.
- *
- * Status:
- * - Only properties listed in PATH_PROPERTIES may be animated.
- *
- * @param {THREE.AnimationClip} clip
- * @param {THREE.Object3D} root
- * @return {number}
- */
-function processAnimation( clip, root ) {
-
-  if ( ! outputJSON.animations ) {
-
-    outputJSON.animations = [];
-
-  }
-
-  var channels = [];
-  var samplers = [];
-
-  for ( var i = 0; i < clip.tracks.length; ++ i ) {
-
-    var track = clip.tracks[ i ];
-    var trackBinding = THREE.PropertyBinding.parseTrackName( track.name );
-    var trackNode = THREE.PropertyBinding.findNode( root, trackBinding.nodeName );
-    var trackProperty = PATH_PROPERTIES[ trackBinding.propertyName ];
-
-    if ( trackBinding.objectName === 'bones' ) {
-
-      if ( trackNode.isSkinnedMesh === true ) {
-
-        trackNode = trackNode.skeleton.getBoneByName( trackBinding.objectIndex );
-
-      } else {
-
-        trackNode = undefined;
-
-      }
-
-    }
-
-    if ( ! trackNode || ! trackProperty ) {
-
-      console.warn( 'THREE.GLTFExporter: Could not export animation track "%s".', track.name );
-      return null;
-
-    }
-
-    var inputItemSize = 1;
-    var outputItemSize = track.values.length / track.times.length;
-
-    if ( trackProperty === PATH_PROPERTIES.morphTargetInfluences ) {
-
-      outputItemSize /= trackNode.morphTargetInfluences.length;
-
-    }
-
-    var interpolation;
-
-    // @TODO export CubicInterpolant(InterpolateSmooth) as CUBICSPLINE
-
-    // Detecting glTF cubic spline interpolant by checking factory method's special property
-    // GLTFCubicSplineInterpolant is a custom interpolant and track doesn't return
-    // valid value from .getInterpolation().
-    if ( track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true ) {
-
-      interpolation = 'CUBICSPLINE';
-
-      // itemSize of CUBICSPLINE keyframe is 9
-      // (VEC3 * 3: inTangent, splineVertex, and outTangent)
-      // but needs to be stored as VEC3 so dividing by 3 here.
-      outputItemSize /= 3;
-
-    } else if ( track.getInterpolation() === THREE.InterpolateDiscrete ) {
-
-      interpolation = 'STEP';
-
-    } else {
-
-      interpolation = 'LINEAR';
-
-    }
-
-    samplers.push( {
-
-      input: processAccessor( new THREE.BufferAttribute( track.times, inputItemSize ) ),
-      output: processAccessor( new THREE.BufferAttribute( track.values, outputItemSize ) ),
-      interpolation: interpolation
-
-    } );
-
-    channels.push( {
-
-      sampler: samplers.length - 1,
-      target: {
-        node: nodeMap.get( trackNode ),
-        path: trackProperty
-      }
-
-    } );
-
-  }
-
-  outputJSON.animations.push( {
-
-    name: clip.name || 'clip_' + outputJSON.animations.length,
-    samplers: samplers,
-    channels: channels
-
-  } );
-
-  return outputJSON.animations.length - 1;
-
-}
-
-function processSkin( object ) {
-
-  var node = outputJSON.nodes[ nodeMap.get( object ) ];
-  var skeleton = object.skeleton;
-  var rootJoint = object.skeleton.bones[ 0 ];
-
-  if ( rootJoint === undefined ) return null;
-
-  var joints = [];
-  var inverseBindMatrices = new Float32Array( skeleton.bones.length * 16 );
-
-  for ( var i = 0; i < skeleton.bones.length; ++ i ) {
-
-    joints.push( nodeMap.get( skeleton.bones[ i ] ) );
-
-    skeleton.boneInverses[ i ].toArray( inverseBindMatrices, i * 16 );
-
-  }
-
-  if ( outputJSON.skins === undefined ) {
-
-    outputJSON.skins = [];
-
-  }
-
-  outputJSON.skins.push( {
-
-    inverseBindMatrices: processAccessor( new THREE.BufferAttribute( inverseBindMatrices, 16 ) ),
-    joints: joints,
-    skeleton: nodeMap.get( rootJoint )
-
-  } );
-
-  var skinIndex = node.skin = outputJSON.skins.length - 1;
-
-  return skinIndex;
-
-}
-
-/**
- * Process Object3D node
- * @param  {THREE.Object3D} node Object3D to processNode
- * @return {Integer}      Index of the node in the nodes list
- */
-function processNode( object ) {
-
-  if ( object.isLight ) {
-
-    console.warn( 'GLTFExporter: Unsupported node type:', object.constructor.name );
-    return null;
-
-  }
-
-  if ( ! outputJSON.nodes ) {
-
-    outputJSON.nodes = [];
-
-  }
-
-  var gltfNode = {};
-
-  if ( options.trs ) {
-
-    var rotation = object.quaternion.toArray();
-    var position = object.position.toArray();
-    var scale = object.scale.toArray();
-
-    if ( ! equalArray( rotation, [ 0, 0, 0, 1 ] ) ) {
-
-      gltfNode.rotation = rotation;
-
-    }
-
-    if ( ! equalArray( position, [ 0, 0, 0 ] ) ) {
-
-      gltfNode.translation = position;
-
-    }
-
-    if ( ! equalArray( scale, [ 1, 1, 1 ] ) ) {
-
-      gltfNode.scale = scale;
-
-    }
-
-  } else {
-
-    object.updateMatrix();
-    if ( ! equalArray( object.matrix.elements, [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ] ) ) {
-
-      gltfNode.matrix = object.matrix.elements;
-
-    }
-
-  }
-
-  // We don't export empty strings name because it represents no-name in Three.js.
-  if ( object.name !== '' ) {
-
-    gltfNode.name = String( object.name );
-
-  }
-
-  if ( object.userData && Object.keys( object.userData ).length > 0 ) {
-
-    gltfNode.extras = serializeUserData( object );
-
-  }
-
-  if ( object.isMesh || object.isLine || object.isPoints ) {
-
-    var mesh = processMesh( object );
-
-    if ( mesh !== null ) {
-
-      gltfNode.mesh = mesh;
-
-    }
-
-  } else if ( object.isCamera ) {
-
-    gltfNode.camera = processCamera( object );
-
-  }
-
-  if ( object.isSkinnedMesh ) {
-
-    skins.push( object );
-
-  }
-
-  if ( object.children.length > 0 ) {
-
-    var children = [];
-
-    for ( var i = 0, l = object.children.length; i < l; i ++ ) {
-
-      var child = object.children[ i ];
-
-      if ( child.visible || options.onlyVisible === false ) {
-
-        var node = processNode( child );
-
-        if ( node !== null ) {
-
-          children.push( node );
-
-        }
-
-      }
-
-    }
-
-    if ( children.length > 0 ) {
-
-      gltfNode.children = children;
-
-    }
-
-
-  }
-
-  outputJSON.nodes.push( gltfNode );
-
-  var nodeIndex = outputJSON.nodes.length - 1;
-  nodeMap.set( object, nodeIndex );
-
-  return nodeIndex;
-
-}
-
-/**
- * Process Scene
- * @param  {THREE.Scene} node Scene to process
- */
-function processScene( scene ) {
-
-  if ( ! outputJSON.scenes ) {
-
-    outputJSON.scenes = [];
-    outputJSON.scene = 0;
-
-  }
-
-  var gltfScene = {
-
-    nodes: []
-
-  };
-
-  if ( scene.name !== '' ) {
-
-    gltfScene.name = scene.name;
-
-  }
-
-  outputJSON.scenes.push( gltfScene );
-
-  var nodes = [];
-
-  for ( var i = 0, l = scene.children.length; i < l; i ++ ) {
-
-    var child = scene.children[ i ];
-
-    if ( child.visible || options.onlyVisible === false ) {
-
-      var node = processNode( child );
-
-      if ( node !== null ) {
-
-        nodes.push( node );
-
-      }
-
-    }
-
-  }
-
-  if ( nodes.length > 0 ) {
-
-    gltfScene.nodes = nodes;
-
-  }
-
-}
-
-/**
- * Creates a THREE.Scene to hold a list of objects and parse it
- * @param  {Array} objects List of objects to process
- */
-function processObjects( objects ) {
-
-  var scene = new THREE.Scene();
-  scene.name = 'AuxScene';
-
-  for ( var i = 0; i < objects.length; i ++ ) {
-
-    // We push directly to children instead of calling `add` to prevent
-    // modify the .parent and break its original scene and hierarchy
-    scene.children.push( objects[ i ] );
-
-  }
-
-  processScene( scene );
-
-}
-
-function processInput( input ) {
-
-  input = input instanceof Array ? input : [ input ];
-
-  var objectsWithoutScene = [];
-
-  for ( var i = 0; i < input.length; i ++ ) {
-
-    if ( input[ i ] instanceof THREE.Scene ) {
-
-      processScene( input[ i ] );
-
-    } else {
-
-      objectsWithoutScene.push( input[ i ] );
-
-    }
-
-  }
-
-  if ( objectsWithoutScene.length > 0 ) {
-
-    processObjects( objectsWithoutScene );
-
-  }
-
-  for ( var i = 0; i < skins.length; ++ i ) {
-
-    processSkin( skins[ i ] );
-
-  }
-
-  for ( var i = 0; i < options.animations.length; ++ i ) {
-
-    processAnimation( options.animations[ i ], input[ 0 ] );
-
-  }
-
-}
-
-processInput( input );
-
-Promise.all( pending ).then( function () {
-
-  // Merge buffers.
-  var blob = new Blob( buffers, { type: 'application/octet-stream' } );
-
-  // Declare extensions.
-  var extensionsUsedList = Object.keys( extensionsUsed );
-  if ( extensionsUsedList.length > 0 ) outputJSON.extensionsUsed = extensionsUsedList;
-
-  if ( outputJSON.buffers && outputJSON.buffers.length > 0 ) {
-
-    // Update bytelength of the single buffer.
-    outputJSON.buffers[ 0 ].byteLength = blob.size;
-
-    var reader = new window.FileReader();
-
-    if ( options.binary === true ) {
-
-      // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
-
-      var GLB_HEADER_BYTES = 12;
-      var GLB_HEADER_MAGIC = 0x46546C67;
-      var GLB_VERSION = 2;
-
-      var GLB_CHUNK_PREFIX_BYTES = 8;
-      var GLB_CHUNK_TYPE_JSON = 0x4E4F534A;
-      var GLB_CHUNK_TYPE_BIN = 0x004E4942;
-
-      reader.readAsArrayBuffer( blob );
-      reader.onloadend = function () {
-
-        // Binary chunk.
-        var binaryChunk = getPaddedArrayBuffer( reader.result );
-        var binaryChunkPrefix = new DataView( new ArrayBuffer( GLB_CHUNK_PREFIX_BYTES ) );
-        binaryChunkPrefix.setUint32( 0, binaryChunk.byteLength, true );
-        binaryChunkPrefix.setUint32( 4, GLB_CHUNK_TYPE_BIN, true );
-
-        // JSON chunk.
-        var jsonChunk = getPaddedArrayBuffer( stringToArrayBuffer( JSON.stringify( outputJSON ) ), 0x20 );
-        var jsonChunkPrefix = new DataView( new ArrayBuffer( GLB_CHUNK_PREFIX_BYTES ) );
-        jsonChunkPrefix.setUint32( 0, jsonChunk.byteLength, true );
-        jsonChunkPrefix.setUint32( 4, GLB_CHUNK_TYPE_JSON, true );
-
-        // GLB header.
-        var header = new ArrayBuffer( GLB_HEADER_BYTES );
-        var headerView = new DataView( header );
-        headerView.setUint32( 0, GLB_HEADER_MAGIC, true );
-        headerView.setUint32( 4, GLB_VERSION, true );
-        var totalByteLength = GLB_HEADER_BYTES
-          + jsonChunkPrefix.byteLength + jsonChunk.byteLength
-          + binaryChunkPrefix.byteLength + binaryChunk.byteLength;
-        headerView.setUint32( 8, totalByteLength, true );
-
-        var glbBlob = new Blob( [
-          header,
-          jsonChunkPrefix,
-          jsonChunk,
-          binaryChunkPrefix,
-          binaryChunk
-        ], { type: 'application/octet-stream' } );
-
-        var glbReader = new window.FileReader();
-        glbReader.readAsArrayBuffer( glbBlob );
-        glbReader.onloadend = function () {
-
-          onDone( glbReader.result );
-
-        };
-
-      };
-
-    } else {
-
-      reader.readAsDataURL( blob );
-      reader.onloadend = function () {
-
-        var base64data = reader.result;
-        outputJSON.buffers[ 0 ].uri = base64data;
-        onDone( outputJSON );
-
-      };
-
-    }
-
-  } else {
-
-    onDone( outputJSON );
-
-  }
-
-} );
-
-}
-
-};
-
-
-THREE.STLExporter = function () {};
-
-THREE.STLExporter.prototype = {
-
-    constructor: THREE.STLExporter,
-
-    parse: ( function () {
-
-        var vector = new THREE.Vec3();
-        var normalMatrixWorld = new THREE.Matrix3();
-
-        return function parse( scene, options ) {
-
-            if ( options === undefined ) options = {};
-
-            var binary = options.binary !== undefined ? options.binary : false;
-
-            //
-
-            var objects = [];
-            var triangles = 0;
-
-            scene.traverse( function ( object ) {
-
-                if ( object.isMesh ) {
-
-                    if (object.pose && object.skeleton && typeof(object.skeleton.pose) == 'function') {
-                        console.log('Posing object', object)
-                        object.pose();
-                    }
-                    console.log(object)
-
-                    var geometry = object.geometry;
-
-                    if ( geometry.isBufferGeometry ) {
-
-                        geometry = new THREE.Geometry().fromBufferGeometry( geometry );
-
-                    }
-
-                    if ( geometry.isGeometry ) {
-
-                        triangles += geometry.faces.length;
-                        objects.push( {
-
-                            geometry: geometry,
-                            matrixWorld: object.matrixWorld,
-                            boneMatrices: object.skeleton && object.skeleton.boneMatrices
-
-                        } );
-
-                    }
-
-                }
-
-            } );
-
-            if ( true ) {
-                var output = '';
-
-                output += 'solid exported\n';
-
-                for ( var i = 0, il = objects.length; i < il; i ++ ) {
-
-                    var object = objects[ i ];
-
-                    var vertices = object.geometry.vertices;
-                    var faces = object.geometry.faces;
-                    var matrixWorld = object.matrixWorld;
-                    var boneMatrices = object.boneMatrices;
-
-                    normalMatrixWorld.getNormalMatrix( matrixWorld );
-
-                    for ( var j = 0, jl = faces.length; j < jl; j ++ ) {
-
-                        var face = faces[ j ];
-
-                        vector.copy( face.normal )// .applyMatrix3( normalMatrixWorld ).normalize();
-
-                        output += '\tfacet normal ' + vector.x + ' ' + vector.y + ' ' + vector.z + '\n';
-                        output += '\t\touter loop\n';
-
-                        var indices = [ face.a, face.b, face.c ];
-
-                        for ( var k = 0; k < 3; k ++ ) {
-
-                            vector.copy( vertices[ indices[ k ] ] ).applyMatrix4( matrixWorld );
-
-                            output += '\t\t\tvertex ' + vector.x + ' ' + vector.y + ' ' + vector.z + '\n';
-
-                        }
-
-                        output += '\t\tendloop\n';
-                        output += '\tendfacet\n';
-
-                    }
-
-                }
-
-                output += 'endsolid exported\n';
-
-                return output;
-
-            }
-
-        };
-
-    }() )
-
-};
-
-
-THREE.Baker = function () {};
-
-THREE.Baker.prototype = {
-
-    constructor: THREE.Baker,
-
-    parse: ( function () {
-
-        var vector = new THREE.Vec3();
-        var normalMatrixWorld = new THREE.Matrix3();
-
-        return function parse( scene, options ) {
-
-            if ( options === undefined ) options = {};
-
-            var binary = options.binary !== undefined ? options.binary : false;
-
-            //
-
-            var objects = [];
-            var triangles = 0;
-
-            scene.traverse( function ( object ) {
-
-                if ( object.isMesh ) {
-
-                    if (object.pose && object.skeleton && typeof(object.skeleton.pose) == 'function') {
-                        console.log('Posing object', object)
-                        object.pose();
-                    }
-                    console.log(object)
-                    var og = object.geometry;
-                    var geometry = object.geometry;
-/* FROM */
-
-                    function checkBufferGeometryIntersection( object, positions, uvs, a, b, c ) {
-var inverseMatrix = new THREE.Matrix4();
-var ray = new THREE.Ray();
-var sphere = new THREE.Sphere();
-
-var vA = new THREE.Vec3();
-var vB = new THREE.Vec3();
-var vC = new THREE.Vec3();
-
-var tempA = new THREE.Vec3();
-var tempB = new THREE.Vec3();
-var tempC = new THREE.Vec3();
-
-var uvA = new THREE.Vec2();
-var uvB = new THREE.Vec2();
-var uvC = new THREE.Vec2();
-
-var barycoord = new THREE.Vec3();
-
-var intersectionPoint = new THREE.Vec3();
-var intersectionPointWorld = new THREE.Vec3();
-                        vA.fromArray( positions, a * 3 );
-                        vB.fromArray( positions, b * 3 );
-                        vC.fromArray( positions, c * 3 );
-
-                        if ( object.boneTransform ) {
-
-                            vA = object.boneTransform( vA, a );
-                            vB = object.boneTransform( vB, b );
-                            vC = object.boneTransform( vC, c );
-
-                        }
-                    }
-                    var uvs, intersection;
-
-                    if ( geometry instanceof THREE.BufferGeometry ) {
-                        debugger;
-console.log('BUFFER')
-                        var a, b, c;
-                        var index = geometry.index;
-                        var attributes = geometry.attributes;
-                        var positions = attributes.position.array;
-
-                        if ( attributes.uv !== undefined ) {
-
-                            uvs = attributes.uv.array;
-
-                        }
-
-                        if ( index !== null ) {
-
-                            var indices = index.array;
-
-                            for ( var i = 0, l = indices.length; i < l; i += 3 ) {
-
-                                a = indices[ i ];
-                                b = indices[ i + 1 ];
-                                c = indices[ i + 2 ];
-
-                                intersection = checkBufferGeometryIntersection( this, positions, uvs, a, b, c );
-
-                                if ( intersection ) {
-
-                                    intersection.faceIndex = Math.floor( i / 3 ); // triangle number in indices buffer semantics
-                                    intersects.push( intersection );
-
-                                }
-
-                            }
-
-                        } else {
-
-
-                            for ( var i = 0, l = positions.length; i < l; i += 9 ) {
-
-                                a = i / 3;
-                                b = a + 1;
-                                c = a + 2;
-
-                                intersection = checkBufferGeometryIntersection( this, positions, uvs, a, b, c );
-
-                                if ( intersection ) {
-
-                                    intersection.index = a; // triangle number in positions buffer semantics
-                                    intersects.push( intersection );
-
-                                }
-
-                            }
-
-                        }
-
-                    } else if ( geometry instanceof THREE.Geometry ) {
-console.log('GEOMETRY')
-                        var fvA, fvB, fvC;
-                        //var isFaceMaterial = material instanceof THREE.MultiMaterial;
-                        //var materials = isFaceMaterial === true ? material.materials : null;
-
-                        var vertices = geometry.vertices;
-                        var faces = geometry.faces;
-                        var faceVertexUvs = geometry.faceVertexUvs[ 0 ];
-                        if ( faceVertexUvs.length > 0 ) uvs = faceVertexUvs;
-
-                        for ( var f = 0, fl = faces.length; f < fl; f ++ ) {
-
-                            var face = faces[ f ];
-                            //var faceMaterial = isFaceMaterial === true ? materials[ face.materialIndex ] : material;
-
-                            //if ( faceMaterial === undefined ) continue;
-
-                            fvA = vertices[ face.a ];
-                            fvB = vertices[ face.b ];
-                            fvC = vertices[ face.c ];
-
-                            /*
-                            if ( faceMaterial.morphTargets === true ) {
-
-                                var morphTargets = geometry.morphTargets;
-                                var morphInfluences = this.morphTargetInfluences;
-
-                                vA.set( 0, 0, 0 );
-                                vB.set( 0, 0, 0 );
-                                vC.set( 0, 0, 0 );
-
-                                for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
-
-                                    var influence = morphInfluences[ t ];
-
-                                    if ( influence === 0 ) continue;
-
-                                    var targets = morphTargets[ t ].vertices;
-
-                                    vA.addScaledVector( tempA.subVectors( targets[ face.a ], fvA ), influence );
-                                    vB.addScaledVector( tempB.subVectors( targets[ face.b ], fvB ), influence );
-                                    vC.addScaledVector( tempC.subVectors( targets[ face.c ], fvC ), influence );
-
-                                }
-
-                                vA.add( fvA );
-                                vB.add( fvB );
-                                vC.add( fvC );
-
-                                fvA = vA;
-                                fvB = vB;
-                                fvC = vC;
-
-                            }
-                            */
-
-                            if ( this.boneTransform ) {
-console.log('YES')
-                                fvA = this.boneTransform( fvA, face.a );
-                                fvB = this.boneTransform( fvB, face.b );
-                                fvC = this.boneTransform( fvC, face.c );
-
-                            }
-
-
-
-                        }
-
-                    } else {
-                       console.log(geometry && geometry.constructor.name || 'Non-Geo')
-                    }
-
-
-/* END FROM*/
-
-                    if ( geometry.isBufferGeometry ) {
-                        geometry = new THREE.Geometry().fromBufferGeometry( geometry );
-                    }
-
-
-                    /*
-                    if ( geometry.isGeometry ) {
-                        if (object.skeleton) {
-                            const allBones = object.skeleton.bones;
-                            const position = Array.from(og.attributes.position.array);
-                            const skinWeight = Array.from(og.attributes.skinWeight.array);
-                            const skinIndex = Array.from(og.attributes.skinIndex.array);
-                            // "loop each vert"
-                            geometry.vertices.forEach((v, i) => {
-                                const p = i * 3;
-                                const f = i * 4;
-                                var pos = new THREE.Vec3(position[p], position[p + 1], position[p + 2]);
-                                var weights = skinWeight.slice(i * 4, i * 4 + 4);
-                                var totalWeight = weights.reduce((a, b) => a + b);
-                                var indices = skinIndex.slice(i * 4, i * 4 + 4);
-                                var bones = indices.map((a, b) => allBones[a].matrix);
-                                // "then over each bone that affects that vert"
-                                var applied = bones.map((bone, i) =>
-                                    pos.clone().applyMatrix4(
-                                        // "weighted if you have bone weights"
-                                        bone.clone().multiplyScalar(weights[i] / totalWeight)
-                                    )
-                                )
-                                // "accumulate that"
-                                var final = applied.reduce((a, b) => a.add(b), new THREE.Vec3(0, 0, 0))
-
-                                final.multiplyScalar(1/4)
-                                //bones.forEach((bone, i) => pos.applyMatrix4(bone.clone().multiplyScalar(weights[i])))
-                                v.set(final.x, final.y, final.z)
-                            })
-                            /*
-                            geometry.vertices.forEach(v => {
-                                object.skeleton.bones.forEach(b => {
-                                    window.xx = [v, b]
-                                    v.applyMatrix4(b.matrixWorld.clone().multiplyScalar(1/object.skeleton.bones.length))
-                                })
-                            })
-                            * /
-                        };
-
-                        object.geometry = geometry;
-
-                        triangles += geometry.faces.length;
-                        objects.push( {
-
-                            geometry: geometry,
-                            matrixWorld: object.matrixWorld,
-                            boneMatrices: object.skeleton && object.skeleton.boneMatrices
-
-                        } );
-
-                    }
-                    */
-
-                }
-
-            } );
-
-        };
-
-    }() )
-
-};
-
-THREE.SkinnedMesh.prototype.boneTransform = ( function() {
-
-    var clone = new THREE.Vec3(), result = new THREE.Vec3(), skinIndices = new THREE.Vec4(), skinWeights = new THREE.Vec4();
-    var temp = new THREE.Vec3(), tempMatrix = new THREE.Matrix4(), properties = [ 'x', 'y', 'z', 'w' ];
-
-    return function( vertex, index ) {
-
-        if ( this.geometry instanceof THREE.BufferGeometry ) {
-
-            var index4 = index * 4;
-            skinIndices.fromArray( this.geometry.attributes.skinIndex.array, index4 );
-            skinWeights.fromArray( this.geometry.attributes.skinWeight.array, index4 );
-
-        } else if ( this.geometry instanceof THREE.Geometry ) {
-
-            skinIndices.copy( this.geometry.skinIndices[ index ] );
-            skinWeights.copy( this.geometry.skinWeights[ index ] );
-
-        }
-
-        var clone = vertex.clone().applyMatrix4( this.bindMatrix ); result.set( 0, 0, 0 );
-
-        for ( var i = 0; i < 4; i ++ ) {
-
-            var skinWeight = skinWeights[ properties[ i ] ];
-
-            if ( skinWeight != 0 ) {
-
-                var boneIndex = skinIndices[ properties[ i ] ];
-                tempMatrix.multiplyMatrices( this.skeleton.bones[ boneIndex ].matrixWorld, this.skeleton.boneInverses[ boneIndex ] );
-                result.add( temp.copy( clone ).applyMatrix4( tempMatrix ).multiplyScalar( skinWeight ) );
-
-            }
-
-        }
-
-        return clone.copy( result.applyMatrix4( this.bindMatrixInverse ) );
-
-    };
-
-} )();
-// Export scripts
-
-window.code = {}
-for (let pkg of Object.values(window.FuseBox.packages)) {
-    for (let moduleName in pkg.f) {
-        window.code[moduleName] = pkg.f[moduleName].fn.toString()
-    }
-}
-
-console.log('All code saved to `window.code`. `exportCode()` to save it')
-
-window.exportCode = () => {
-    window.console.save(window.code, 'heroforge.json')
-}
 window.bake = () => {
-    const baker = new THREE.Baker();
-    baker.parse(CK.characters[0].characterDisplay.threeObj);
-    console.log('Baked');
+  const baker = new THREE.Baker();
+  baker.parse(CK.characters[0].characterDisplay.threeObj);
+  console.log('Baked');
 }
 window.save = (filename) => {
-    const exporter = new THREE.GLTFExporter();
-    exporter.parse(CK.characters[0].characterDisplay.threeObj, data => {
-      window.data = data;
-      console.log('done')
-      if (filename) console.save(JSON.stringify(window.data), `${filename}.gltf`)
-    })
+  const exporter = new THREE.GLTFExporter();
+  exporter.parse(CK.characters[0].characterDisplay.threeObj, data => {
+    window.data = data;
+    console.log('done')
+    if (filename) console.save(JSON.stringify(window.data), `${filename}.gltf`)
+  })
 }
 
 // Your code here...

src/stl-exporter.js

@@ -0,0 +1,113 @@
+const THREE = require('./three')
+
+THREE.STLExporter = function() {};
+
+THREE.STLExporter.prototype = {
+
+  constructor: THREE.STLExporter,
+
+  parse: (function() {
+
+    var vector = new THREE.Vec3();
+    var normalMatrixWorld = new THREE.Matrix3();
+
+    return function parse(scene, options) {
+
+      if (options === undefined) options = {};
+
+      var binary = options.binary !== undefined ? options.binary : false;
+
+      //
+
+      var objects = [];
+      var triangles = 0;
+
+      scene.traverse(function(object) {
+
+        if (object.isMesh) {
+
+          if (object.pose && object.skeleton && typeof(object.skeleton.pose) == 'function') {
+            console.log('Posing object', object)
+            object.pose();
+          }
+          console.log(object)
+
+          var geometry = object.geometry;
+
+          if (geometry.isBufferGeometry) {
+
+            geometry = new THREE.Geometry().fromBufferGeometry(geometry);
+
+          }
+
+          if (geometry.isGeometry) {
+
+            triangles += geometry.faces.length;
+            objects.push({
+
+              geometry: geometry,
+              matrixWorld: object.matrixWorld,
+              boneMatrices: object.skeleton && object.skeleton.boneMatrices
+
+            });
+
+          }
+
+        }
+
+      });
+
+      if (true) {
+        var output = '';
+
+        output += 'solid exported\n';
+
+        for (var i = 0, il = objects.length; i < il; i++) {
+
+          var object = objects[i];
+
+          var vertices = object.geometry.vertices;
+          var faces = object.geometry.faces;
+          var matrixWorld = object.matrixWorld;
+          var boneMatrices = object.boneMatrices;
+
+          normalMatrixWorld.getNormalMatrix(matrixWorld);
+
+          for (var j = 0, jl = faces.length; j < jl; j++) {
+
+            var face = faces[j];
+
+            vector.copy(face.normal) // .applyMatrix3( normalMatrixWorld ).normalize();
+
+            output += '\tfacet normal ' + vector.x + ' ' + vector.y + ' ' + vector.z + '\n';
+            output += '\t\touter loop\n';
+
+            var indices = [face.a, face.b, face.c];
+
+            for (var k = 0; k < 3; k++) {
+
+              vector.copy(vertices[indices[k]]).applyMatrix4(matrixWorld);
+
+              output += '\t\t\tvertex ' + vector.x + ' ' + vector.y + ' ' + vector.z + '\n';
+
+            }
+
+            output += '\t\tendloop\n';
+            output += '\tendfacet\n';
+
+          }
+
+        }
+
+        output += 'endsolid exported\n';
+
+        return output;
+
+      }
+
+    };
+
+  }())
+
+};
+

src/three.js

@@ -0,0 +1,18 @@
+const THREE = RK;
+THREE.Vector3 = THREE.Vec3;
+
+// Add default .toString() functions to display the type, name, and ID.
+Object.keys(RK).forEach(key => {
+  const Type = RK[key]
+  if (Type && Type.prototype && !Type.prototype.hasOwnProperty('toString')) {
+    Type.prototype.toString = function() {
+      const description = [key, this.name, this.id].filter(x => x === 0 || x).join(' ')
+      return `[${description}]`
+    }
+  }
+})
+
+module.exports = THREE
+require('./gltf-exporter')
+require('./stl-exporter')
+require('./baker')

src/tree.js

@@ -0,0 +1,74 @@
+/*
+─ │ └ ├ ┌ ┬
+
+─ single item
+
+─ two items
+─ two items
+                                           last, children
+┬ root                 ['',   '',   '┬ ']     [true, true]
+├── first child        ['',   '├─', '─ ']     [false, false]
+├─┬ child parent       ['',   '├─', '┬ ']     [false, true]
+│ ├── first child      ['│ ', '├─', '─ ']     [false, false]
+│ └─┬ child parent     ['│ ', '└─', '┬ ']     [true, true]
+│   ├── first child    ['│   ', '├─', '─ ']   [false, false]
+│   └── last child     ['│   ', '└─', '─ ']   [true, false]
+└── last child         ['', '└─', '─ ']       [true, false]
+
+parent is last child ? '  ' : '│ '
+
+nSibling      part 1: ├─
+lastSibling   part 1: └─
+
+hasChildren   part 2: ┬
+noChildren    part 2: ─
+
+*/
+
+window.console.tree = (obj, prop, toString, forEach) => {
+  if (!toString) toString = x => x === null ? 'null' : x === undefined ? 'undefined' : x.toString()
+  if (!prop) {
+    prop = obj.children ? 'children'
+      : obj.childNodes ? 'childNodes'
+      : null
+  }
+  const output = []
+  const walk = (obj, part0, lastSibling) => {
+    let children = obj[prop]
+    if (children && !Array.isArray(children)) children = Array.from(children)
+    const len = children && children.length || 0
+    const part1 = lastSibling ? '└─' : '├─'
+    const part2 = len ? '┬ ' : '─ '
+    output.push(part0 + part1 + part2 + toString(obj))
+    if (forEach) forEach(obj, part0 + part1 + part2)
+    children.forEach((child, i) => {
+      walk(child, part0 + (lastSibling ? '  ' : '│ '), i === len - 1)
+    })
+  }
+  walk(obj, '  ', true)
+  return output.join('\n')
+}
+
+window.console.tree.withObject = (obj, prop, toString) => window.console.tree(obj, prop, toString, (x, y) => console.log(y, x)) && undefined
+
+window.console.tree.groups = (obj, prop) => {
+  if (!prop) {
+    prop = obj.children ? 'children'
+      : obj.childNodes ? 'childNodes'
+      : null
+  }
+  const walk = (obj) => {
+    let children = obj[prop]
+    if (children && !Array.isArray(children)) children = Array.from(children)
+    if (children && children.length) {
+        console.group(obj)
+        children.forEach(walk)
+        console.groupEnd()
+    } else {
+      console.log(obj)
+    }
+  }
+  walk(obj)
+}
+
+module.exports = window.console.tree

src/walk.js

@@ -0,0 +1,19 @@
+window.walk = function(root) {
+  /*      const walk = (obj, i, tree, more) => {
+      const indent = tree + (more ? ' ├' : ' └')  //"".padRight(i * 2, ' ')
+      console.log(indent + obj.toString())
+      if (obj && obj.children) obj.children.forEach((x, y) => walk(x, i + 1, tree + (y < obj.children.length - 1 ? ' │' : '  '), y < obj.children.length - 1))
+  }
+  */
+  const walk = (obj, part0, lastSibling) => {
+    const part1 = lastSibling ? '└─' : '├─'
+    const part2 = obj.children.length ? '┬ ' : '─ '
+    console.log(part0 + part1 + part2 + obj.toString())
+    obj.children.forEach((child, i) => {
+      walk(child, part0 + (lastSibling ? '  ' : '│ '), i === obj.children.length - 1)
+    })
+  }
+  walk(root, '  ', true)
+}
+
+module.exports = walk