livecodingspace-app/public/vwf/model/aframe/extras/aframe-extras.loaders.js

(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
'use strict';

require('./src/loaders');

},{"./src/loaders":8}],2:[function(require,module,exports){
'use strict';

var _typeof2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
  return typeof obj === "undefined" ? "undefined" : _typeof2(obj);
} : function (obj) {
  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof2(obj);
};

/**
 * @author Kyle-Larson https://github.com/Kyle-Larson
 * @author Takahiro https://github.com/takahirox
 * @author Lewy Blue https://github.com/looeee
 *
 * Loader loads FBX file and generates Group representing FBX scene.
 * Requires FBX file to be >= 7.0 and in ASCII or to be any version in Binary format.
 *
 * Supports:
 *  Mesh Generation (Positional Data)
 *  Normal Data (Per Vertex Drawing Instance)
 *  UV Data (Per Vertex Drawing Instance)
 *  Skinning
 *  Animation
 *  - Separated Animations based on stacks.
 *  - Skeletal & Non-Skeletal Animations
 *  NURBS (Open, Closed and Periodic forms)
 *
 * Needs Support:
 *  Euler rotation order
 *
 *
 * FBX format references:
 *  https://wiki.blender.org/index.php/User:Mont29/Foundation/FBX_File_Structure
 *
 *  Binary format specification:
 *    https://code.blender.org/2013/08/fbx-binary-file-format-specification/
 *    https://wiki.rogiken.org/specifications/file-format/fbx/ (more detail but Japanese)
 */

// Monkeypatch for <r89
THREE.LoaderUtils = {
  extractUrlBase: THREE.Loader.prototype.extractUrlBase,
  decodeText: function decodeText(array) {
    return new TextDecoder().decode(array);
  }
};

(function () {

  module.exports = THREE.FBXLoader = function (manager) {

    this.manager = manager !== undefined ? manager : THREE.DefaultLoadingManager;
  };

  Object.assign(THREE.FBXLoader.prototype, {

    load: function load(url, onLoad, onProgress, onError) {

      var self = this;

      var resourceDirectory = THREE.LoaderUtils.extractUrlBase(url);

      var loader = new THREE.FileLoader(this.manager);
      loader.setResponseType('arraybuffer');
      loader.load(url, function (buffer) {

        try {

          var scene = self.parse(buffer, resourceDirectory);
          onLoad(scene);
        } catch (error) {

          window.setTimeout(function () {

            if (onError) onError(error);

            self.manager.itemError(url);
          }, 0);
        }
      }, onProgress, onError);
    },

    parse: function parse(FBXBuffer, resourceDirectory) {

      var FBXTree;

      if (isFbxFormatBinary(FBXBuffer)) {

        FBXTree = new BinaryParser().parse(FBXBuffer);
      } else {

        var FBXText = convertArrayBufferToString(FBXBuffer);

        if (!isFbxFormatASCII(FBXText)) {

          throw new Error('THREE.FBXLoader: Unknown format.');
        }

        if (getFbxVersion(FBXText) < 7000) {

          throw new Error('THREE.FBXLoader: FBX version not supported, FileVersion: ' + getFbxVersion(FBXText));
        }

        FBXTree = new TextParser().parse(FBXText);
      }

      // console.log( FBXTree );

      var connections = parseConnections(FBXTree);
      var images = parseImages(FBXTree);
      var textures = parseTextures(FBXTree, new THREE.TextureLoader(this.manager).setPath(resourceDirectory), images, connections);
      var materials = parseMaterials(FBXTree, textures, connections);
      var skeletons = parseDeformers(FBXTree, connections);
      var geometryMap = parseGeometries(FBXTree, connections, skeletons);
      var sceneGraph = parseScene(FBXTree, connections, skeletons, geometryMap, materials);

      return sceneGraph;
    }

  });

  // Parses FBXTree.Connections which holds parent-child connections between objects (e.g. material -> texture, model->geometry )
  // and details the connection type
  function parseConnections(FBXTree) {

    var connectionMap = new Map();

    if ('Connections' in FBXTree) {

      var rawConnections = FBXTree.Connections.connections;

      rawConnections.forEach(function (rawConnection) {

        var fromID = rawConnection[0];
        var toID = rawConnection[1];
        var relationship = rawConnection[2];

        if (!connectionMap.has(fromID)) {

          connectionMap.set(fromID, {
            parents: [],
            children: []
          });
        }

        var parentRelationship = { ID: toID, relationship: relationship };
        connectionMap.get(fromID).parents.push(parentRelationship);

        if (!connectionMap.has(toID)) {

          connectionMap.set(toID, {
            parents: [],
            children: []
          });
        }

        var childRelationship = { ID: fromID, relationship: relationship };
        connectionMap.get(toID).children.push(childRelationship);
      });
    }

    return connectionMap;
  }

  // Parse FBXTree.Objects.Video for embedded image data
  // These images are connected to textures in FBXTree.Objects.Textures
  // via FBXTree.Connections.
  function parseImages(FBXTree) {

    var images = {};
    var blobs = {};

    if ('Video' in FBXTree.Objects) {

      var videoNodes = FBXTree.Objects.Video;

      for (var nodeID in videoNodes) {

        var videoNode = videoNodes[nodeID];

        var id = parseInt(nodeID);

        images[id] = videoNode.Filename;

        // raw image data is in videoNode.Content
        if ('Content' in videoNode) {

          var arrayBufferContent = videoNode.Content instanceof ArrayBuffer && videoNode.Content.byteLength > 0;
          var base64Content = typeof videoNode.Content === 'string' && videoNode.Content !== '';

          if (arrayBufferContent || base64Content) {

            var image = parseImage(videoNodes[nodeID]);

            blobs[videoNode.Filename] = image;
          }
        }
      }
    }

    for (var id in images) {

      var filename = images[id];

      if (blobs[filename] !== undefined) images[id] = blobs[filename];else images[id] = images[id].split('\\').pop();
    }

    return images;
  }

  // Parse embedded image data in FBXTree.Video.Content
  function parseImage(videoNode) {

    var content = videoNode.Content;
    var fileName = videoNode.RelativeFilename || videoNode.Filename;
    var extension = fileName.slice(fileName.lastIndexOf('.') + 1).toLowerCase();

    var type;

    switch (extension) {

      case 'bmp':

        type = 'image/bmp';
        break;

      case 'jpg':
      case 'jpeg':

        type = 'image/jpeg';
        break;

      case 'png':

        type = 'image/png';
        break;

      case 'tif':

        type = 'image/tiff';
        break;

      default:

        console.warn('FBXLoader: Image type "' + extension + '" is not supported.');
        return;

    }

    if (typeof content === 'string') {
      // ASCII format

      return 'data:' + type + ';base64,' + content;
    } else {
      // Binary Format

      var array = new Uint8Array(content);
      return window.URL.createObjectURL(new Blob([array], { type: type }));
    }
  }

  // Parse nodes in FBXTree.Objects.Texture
  // These contain details such as UV scaling, cropping, rotation etc and are connected
  // to images in FBXTree.Objects.Video
  function parseTextures(FBXTree, loader, images, connections) {

    var textureMap = new Map();

    if ('Texture' in FBXTree.Objects) {

      var textureNodes = FBXTree.Objects.Texture;
      for (var nodeID in textureNodes) {

        var texture = parseTexture(textureNodes[nodeID], loader, images, connections);
        textureMap.set(parseInt(nodeID), texture);
      }
    }

    return textureMap;
  }

  // Parse individual node in FBXTree.Objects.Texture
  function parseTexture(textureNode, loader, images, connections) {

    var texture = loadTexture(textureNode, loader, images, connections);

    texture.ID = textureNode.id;

    texture.name = textureNode.attrName;

    var wrapModeU = textureNode.WrapModeU;
    var wrapModeV = textureNode.WrapModeV;

    var valueU = wrapModeU !== undefined ? wrapModeU.value : 0;
    var valueV = wrapModeV !== undefined ? wrapModeV.value : 0;

    // http://download.autodesk.com/us/fbx/SDKdocs/FBX_SDK_Help/files/fbxsdkref/class_k_fbx_texture.html#889640e63e2e681259ea81061b85143a
    // 0: repeat(default), 1: clamp

    texture.wrapS = valueU === 0 ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
    texture.wrapT = valueV === 0 ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;

    if ('Scaling' in textureNode) {

      var values = textureNode.Scaling.value;

      texture.repeat.x = values[0];
      texture.repeat.y = values[1];
    }

    return texture;
  }

  // load a texture specified as a blob or data URI, or via an external URL using THREE.TextureLoader
  function loadTexture(textureNode, loader, images, connections) {

    var fileName;

    var currentPath = loader.path;

    var children = connections.get(textureNode.id).children;

    if (children !== undefined && children.length > 0 && images[children[0].ID] !== undefined) {

      fileName = images[children[0].ID];

      if (fileName.indexOf('blob:') === 0 || fileName.indexOf('data:') === 0) {

        loader.setPath(undefined);
      }
    }

    var texture = loader.load(fileName);

    loader.setPath(currentPath);

    return texture;
  }

  // Parse nodes in FBXTree.Objects.Material
  function parseMaterials(FBXTree, textureMap, connections) {

    var materialMap = new Map();

    if ('Material' in FBXTree.Objects) {

      var materialNodes = FBXTree.Objects.Material;

      for (var nodeID in materialNodes) {

        var material = parseMaterial(FBXTree, materialNodes[nodeID], textureMap, connections);

        if (material !== null) materialMap.set(parseInt(nodeID), material);
      }
    }

    return materialMap;
  }

  // Parse single node in FBXTree.Objects.Material
  // Materials are connected to texture maps in FBXTree.Objects.Textures
  // FBX format currently only supports Lambert and Phong shading models
  function parseMaterial(FBXTree, materialNode, textureMap, connections) {

    var ID = materialNode.id;
    var name = materialNode.attrName;
    var type = materialNode.ShadingModel;

    //Case where FBX wraps shading model in property object.
    if ((typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object') {

      type = type.value;
    }

    // Ignore unused materials which don't have any connections.
    if (!connections.has(ID)) return null;

    var parameters = parseParameters(FBXTree, materialNode, textureMap, ID, connections);

    var material;

    switch (type.toLowerCase()) {

      case 'phong':
        material = new THREE.MeshPhongMaterial();
        break;
      case 'lambert':
        material = new THREE.MeshLambertMaterial();
        break;
      default:
        console.warn('THREE.FBXLoader: unknown material type "%s". Defaulting to MeshPhongMaterial.', type);
        material = new THREE.MeshPhongMaterial({ color: 0x3300ff });
        break;

    }

    material.setValues(parameters);
    material.name = name;

    return material;
  }

  // Parse FBX material and return parameters suitable for a three.js material
  // Also parse the texture map and return any textures associated with the material
  function parseParameters(FBXTree, properties, textureMap, ID, connections) {

    var parameters = {};

    if (properties.BumpFactor) {

      parameters.bumpScale = properties.BumpFactor.value;
    }
    if (properties.Diffuse) {

      parameters.color = new THREE.Color().fromArray(properties.Diffuse.value);
    }
    if (properties.DisplacementFactor) {

      parameters.displacementScale = properties.DisplacementFactor.value;
    }
    if (properties.ReflectionFactor) {

      parameters.reflectivity = properties.ReflectionFactor.value;
    }
    if (properties.Specular) {

      parameters.specular = new THREE.Color().fromArray(properties.Specular.value);
    }
    if (properties.Shininess) {

      parameters.shininess = properties.Shininess.value;
    }
    if (properties.Emissive) {

      parameters.emissive = new THREE.Color().fromArray(properties.Emissive.value);
    }
    if (properties.EmissiveFactor) {

      parameters.emissiveIntensity = parseFloat(properties.EmissiveFactor.value);
    }
    if (properties.Opacity) {

      parameters.opacity = parseFloat(properties.Opacity.value);
    }
    if (parameters.opacity < 1.0) {

      parameters.transparent = true;
    }

    connections.get(ID).children.forEach(function (child) {

      var type = child.relationship;

      switch (type) {

        case 'Bump':
          parameters.bumpMap = textureMap.get(child.ID);
          break;

        case 'DiffuseColor':
          parameters.map = getTexture(FBXTree, textureMap, child.ID, connections);
          break;

        case 'DisplacementColor':
          parameters.displacementMap = getTexture(FBXTree, textureMap, child.ID, connections);
          break;

        case 'EmissiveColor':
          parameters.emissiveMap = getTexture(FBXTree, textureMap, child.ID, connections);
          break;

        case 'NormalMap':
          parameters.normalMap = getTexture(FBXTree, textureMap, child.ID, connections);
          break;

        case 'ReflectionColor':
          parameters.envMap = getTexture(FBXTree, textureMap, child.ID, connections);
          parameters.envMap.mapping = THREE.EquirectangularReflectionMapping;
          break;

        case 'SpecularColor':
          parameters.specularMap = getTexture(FBXTree, textureMap, child.ID, connections);
          break;

        case 'TransparentColor':
          parameters.alphaMap = getTexture(FBXTree, textureMap, child.ID, connections);
          parameters.transparent = true;
          break;

        case 'AmbientColor':
        case 'ShininessExponent': // AKA glossiness map
        case 'SpecularFactor': // AKA specularLevel
        case 'VectorDisplacementColor': // NOTE: Seems to be a copy of DisplacementColor
        default:
          console.warn('THREE.FBXLoader: %s map is not supported in three.js, skipping texture.', type);
          break;

      }
    });

    return parameters;
  }

  // get a texture from the textureMap for use by a material.
  function getTexture(FBXTree, textureMap, id, connections) {

    // if the texture is a layered texture, just use the first layer and issue a warning
    if ('LayeredTexture' in FBXTree.Objects && id in FBXTree.Objects.LayeredTexture) {

      console.warn('THREE.FBXLoader: layered textures are not supported in three.js. Discarding all but first layer.');
      id = connections.get(id).children[0].ID;
    }

    return textureMap.get(id);
  }

  // Parse nodes in FBXTree.Objects.Deformer
  // Deformer node can contain skinning or Vertex Cache animation data, however only skinning is supported here
  // Generates map of Skeleton-like objects for use later when generating and binding skeletons.
  function parseDeformers(FBXTree, connections) {

    var skeletons = {};

    if ('Deformer' in FBXTree.Objects) {

      var DeformerNodes = FBXTree.Objects.Deformer;

      for (var nodeID in DeformerNodes) {

        var deformerNode = DeformerNodes[nodeID];

        if (deformerNode.attrType === 'Skin') {

          var relationships = connections.get(parseInt(nodeID));

          var skeleton = parseSkeleton(relationships, DeformerNodes);
          skeleton.ID = nodeID;

          if (relationships.parents.length > 1) console.warn('THREE.FBXLoader: skeleton attached to more than one geometry is not supported.');
          skeleton.geometryID = relationships.parents[0].ID;

          skeletons[nodeID] = skeleton;
        }
      }
    }

    return skeletons;
  }

  // Parse single nodes in FBXTree.Objects.Deformer
  // The top level deformer nodes have type 'Skin' and subDeformer nodes have type 'Cluster'
  // Each skin node represents a skeleton and each cluster node represents a bone
  function parseSkeleton(connections, deformerNodes) {

    var rawBones = [];

    connections.children.forEach(function (child) {

      var subDeformerNode = deformerNodes[child.ID];

      if (subDeformerNode.attrType !== 'Cluster') return;

      var rawBone = {

        ID: child.ID,
        indices: [],
        weights: [],
        transform: new THREE.Matrix4().fromArray(subDeformerNode.Transform.a),
        transformLink: new THREE.Matrix4().fromArray(subDeformerNode.TransformLink.a),
        linkMode: subDeformerNode.Mode

      };

      if ('Indexes' in subDeformerNode) {

        rawBone.indices = subDeformerNode.Indexes.a;
        rawBone.weights = subDeformerNode.Weights.a;
      }

      rawBones.push(rawBone);
    });

    return {

      rawBones: rawBones,
      bones: []

    };
  }

  // Parse nodes in FBXTree.Objects.Geometry
  function parseGeometries(FBXTree, connections, skeletons) {

    var geometryMap = new Map();

    if ('Geometry' in FBXTree.Objects) {

      var geometryNodes = FBXTree.Objects.Geometry;

      for (var nodeID in geometryNodes) {

        var relationships = connections.get(parseInt(nodeID));
        var geo = parseGeometry(FBXTree, relationships, geometryNodes[nodeID], skeletons);

        geometryMap.set(parseInt(nodeID), geo);
      }
    }

    return geometryMap;
  }

  // Parse single node in FBXTree.Objects.Geometry
  function parseGeometry(FBXTree, relationships, geometryNode, skeletons) {

    switch (geometryNode.attrType) {

      case 'Mesh':
        return parseMeshGeometry(FBXTree, relationships, geometryNode, skeletons);
        break;

      case 'NurbsCurve':
        return parseNurbsGeometry(geometryNode);
        break;

    }
  }

  // Parse single node mesh geometry in FBXTree.Objects.Geometry
  function parseMeshGeometry(FBXTree, relationships, geometryNode, skeletons) {

    var modelNodes = relationships.parents.map(function (parent) {

      return FBXTree.Objects.Model[parent.ID];
    });

    // don't create geometry if it is not associated with any models
    if (modelNodes.length === 0) return;

    var skeleton = relationships.children.reduce(function (skeleton, child) {

      if (skeletons[child.ID] !== undefined) skeleton = skeletons[child.ID];

      return skeleton;
    }, null);

    var preTransform = new THREE.Matrix4();

    // TODO: if there is more than one model associated with the geometry, AND the models have
    // different geometric transforms, then this will cause problems
    // if ( modelNodes.length > 1 ) { }

    // For now just assume one model and get the preRotations from that
    var modelNode = modelNodes[0];

    if ('GeometricRotation' in modelNode) {

      var array = modelNode.GeometricRotation.value.map(THREE.Math.degToRad);
      array[3] = 'ZYX';

      preTransform.makeRotationFromEuler(new THREE.Euler().fromArray(array));
    }

    if ('GeometricTranslation' in modelNode) {

      preTransform.setPosition(new THREE.Vector3().fromArray(modelNode.GeometricTranslation.value));
    }

    return genGeometry(FBXTree, relationships, geometryNode, skeleton, preTransform);
  }

  // Generate a THREE.BufferGeometry from a node in FBXTree.Objects.Geometry
  function genGeometry(FBXTree, relationships, geometryNode, skeleton, preTransform) {

    var vertexPositions = geometryNode.Vertices.a;
    var vertexIndices = geometryNode.PolygonVertexIndex.a;

    // create arrays to hold the final data used to build the buffergeometry
    var vertexBuffer = [];
    var normalBuffer = [];
    var colorsBuffer = [];
    var uvsBuffer = [];
    var materialIndexBuffer = [];
    var vertexWeightsBuffer = [];
    var weightsIndicesBuffer = [];

    if (geometryNode.LayerElementColor) {

      var colorInfo = getColors(geometryNode.LayerElementColor[0]);
    }

    if (geometryNode.LayerElementMaterial) {

      var materialInfo = getMaterials(geometryNode.LayerElementMaterial[0]);
    }

    if (geometryNode.LayerElementNormal) {

      var normalInfo = getNormals(geometryNode.LayerElementNormal[0]);
    }

    if (geometryNode.LayerElementUV) {

      var uvInfo = [];
      var i = 0;
      while (geometryNode.LayerElementUV[i]) {

        uvInfo.push(getUVs(geometryNode.LayerElementUV[i]));
        i++;
      }
    }

    var weightTable = {};

    if (skeleton !== null) {

      skeleton.rawBones.forEach(function (rawBone, i) {

        // loop over the bone's vertex indices and weights
        rawBone.indices.forEach(function (index, j) {

          if (weightTable[index] === undefined) weightTable[index] = [];

          weightTable[index].push({

            id: i,
            weight: rawBone.weights[j]

          });
        });
      });
    }

    var polygonIndex = 0;
    var faceLength = 0;
    var displayedWeightsWarning = false;

    // these will hold data for a single face
    var vertexPositionIndexes = [];
    var faceNormals = [];
    var faceColors = [];
    var faceUVs = [];
    var faceWeights = [];
    var faceWeightIndices = [];

    vertexIndices.forEach(function (vertexIndex, polygonVertexIndex) {

      var endOfFace = false;

      // Face index and vertex index arrays are combined in a single array
      // A cube with quad faces looks like this:
      // PolygonVertexIndex: *24 {
      //  a: 0, 1, 3, -3, 2, 3, 5, -5, 4, 5, 7, -7, 6, 7, 1, -1, 1, 7, 5, -4, 6, 0, 2, -5
      //  }
      // Negative numbers mark the end of a face - first face here is 0, 1, 3, -3
      // to find index of last vertex multiply by -1 and subtract 1: -3 * - 1 - 1 = 2
      if (vertexIndex < 0) {

        vertexIndex = vertexIndex ^ -1; // equivalent to ( x * -1 ) - 1
        vertexIndices[polygonVertexIndex] = vertexIndex;
        endOfFace = true;
      }

      var weightIndices = [];
      var weights = [];

      vertexPositionIndexes.push(vertexIndex * 3, vertexIndex * 3 + 1, vertexIndex * 3 + 2);

      if (colorInfo) {

        var data = getData(polygonVertexIndex, polygonIndex, vertexIndex, colorInfo);

        faceColors.push(data[0], data[1], data[2]);
      }

      if (skeleton) {

        if (weightTable[vertexIndex] !== undefined) {

          weightTable[vertexIndex].forEach(function (wt) {

            weights.push(wt.weight);
            weightIndices.push(wt.id);
          });
        }

        if (weights.length > 4) {

          if (!displayedWeightsWarning) {

            console.warn('THREE.FBXLoader: Vertex has more than 4 skinning weights assigned to vertex. Deleting additional weights.');
            displayedWeightsWarning = true;
          }

          var wIndex = [0, 0, 0, 0];
          var Weight = [0, 0, 0, 0];

          weights.forEach(function (weight, weightIndex) {

            var currentWeight = weight;
            var currentIndex = weightIndices[weightIndex];

            Weight.forEach(function (comparedWeight, comparedWeightIndex, comparedWeightArray) {

              if (currentWeight > comparedWeight) {

                comparedWeightArray[comparedWeightIndex] = currentWeight;
                currentWeight = comparedWeight;

                var tmp = wIndex[comparedWeightIndex];
                wIndex[comparedWeightIndex] = currentIndex;
                currentIndex = tmp;
              }
            });
          });

          weightIndices = wIndex;
          weights = Weight;
        }

        // if the weight array is shorter than 4 pad with 0s
        while (weights.length < 4) {

          weights.push(0);
          weightIndices.push(0);
        }

        for (var i = 0; i < 4; ++i) {

          faceWeights.push(weights[i]);
          faceWeightIndices.push(weightIndices[i]);
        }
      }

      if (normalInfo) {

        var data = getData(polygonVertexIndex, polygonIndex, vertexIndex, normalInfo);

        faceNormals.push(data[0], data[1], data[2]);
      }

      if (materialInfo && materialInfo.mappingType !== 'AllSame') {

        var materialIndex = getData(polygonVertexIndex, polygonIndex, vertexIndex, materialInfo)[0];
      }

      if (uvInfo) {

        uvInfo.forEach(function (uv, i) {

          var data = getData(polygonVertexIndex, polygonIndex, vertexIndex, uv);

          if (faceUVs[i] === undefined) {

            faceUVs[i] = [];
          }

          faceUVs[i].push(data[0]);
          faceUVs[i].push(data[1]);
        });
      }

      faceLength++;

      // we have reached the end of a face - it may have 4 sides though
      // in which case the data is split to represent two 3 sided faces
      if (endOfFace) {

        for (var i = 2; i < faceLength; i++) {

          vertexBuffer.push(vertexPositions[vertexPositionIndexes[0]]);
          vertexBuffer.push(vertexPositions[vertexPositionIndexes[1]]);
          vertexBuffer.push(vertexPositions[vertexPositionIndexes[2]]);

          vertexBuffer.push(vertexPositions[vertexPositionIndexes[(i - 1) * 3]]);
          vertexBuffer.push(vertexPositions[vertexPositionIndexes[(i - 1) * 3 + 1]]);
          vertexBuffer.push(vertexPositions[vertexPositionIndexes[(i - 1) * 3 + 2]]);

          vertexBuffer.push(vertexPositions[vertexPositionIndexes[i * 3]]);
          vertexBuffer.push(vertexPositions[vertexPositionIndexes[i * 3 + 1]]);
          vertexBuffer.push(vertexPositions[vertexPositionIndexes[i * 3 + 2]]);

          if (skeleton) {

            vertexWeightsBuffer.push(faceWeights[0]);
            vertexWeightsBuffer.push(faceWeights[1]);
            vertexWeightsBuffer.push(faceWeights[2]);
            vertexWeightsBuffer.push(faceWeights[3]);

            vertexWeightsBuffer.push(faceWeights[(i - 1) * 4]);
            vertexWeightsBuffer.push(faceWeights[(i - 1) * 4 + 1]);
            vertexWeightsBuffer.push(faceWeights[(i - 1) * 4 + 2]);
            vertexWeightsBuffer.push(faceWeights[(i - 1) * 4 + 3]);

            vertexWeightsBuffer.push(faceWeights[i * 4]);
            vertexWeightsBuffer.push(faceWeights[i * 4 + 1]);
            vertexWeightsBuffer.push(faceWeights[i * 4 + 2]);
            vertexWeightsBuffer.push(faceWeights[i * 4 + 3]);

            weightsIndicesBuffer.push(faceWeightIndices[0]);
            weightsIndicesBuffer.push(faceWeightIndices[1]);
            weightsIndicesBuffer.push(faceWeightIndices[2]);
            weightsIndicesBuffer.push(faceWeightIndices[3]);

            weightsIndicesBuffer.push(faceWeightIndices[(i - 1) * 4]);
            weightsIndicesBuffer.push(faceWeightIndices[(i - 1) * 4 + 1]);
            weightsIndicesBuffer.push(faceWeightIndices[(i - 1) * 4 + 2]);
            weightsIndicesBuffer.push(faceWeightIndices[(i - 1) * 4 + 3]);

            weightsIndicesBuffer.push(faceWeightIndices[i * 4]);
            weightsIndicesBuffer.push(faceWeightIndices[i * 4 + 1]);
            weightsIndicesBuffer.push(faceWeightIndices[i * 4 + 2]);
            weightsIndicesBuffer.push(faceWeightIndices[i * 4 + 3]);
          }

          if (colorInfo) {

            colorsBuffer.push(faceColors[0]);
            colorsBuffer.push(faceColors[1]);
            colorsBuffer.push(faceColors[2]);

            colorsBuffer.push(faceColors[(i - 1) * 3]);
            colorsBuffer.push(faceColors[(i - 1) * 3 + 1]);
            colorsBuffer.push(faceColors[(i - 1) * 3 + 2]);

            colorsBuffer.push(faceColors[i * 3]);
            colorsBuffer.push(faceColors[i * 3 + 1]);
            colorsBuffer.push(faceColors[i * 3 + 2]);
          }

          if (materialInfo && materialInfo.mappingType !== 'AllSame') {

            materialIndexBuffer.push(materialIndex);
            materialIndexBuffer.push(materialIndex);
            materialIndexBuffer.push(materialIndex);
          }

          if (normalInfo) {

            normalBuffer.push(faceNormals[0]);
            normalBuffer.push(faceNormals[1]);
            normalBuffer.push(faceNormals[2]);

            normalBuffer.push(faceNormals[(i - 1) * 3]);
            normalBuffer.push(faceNormals[(i - 1) * 3 + 1]);
            normalBuffer.push(faceNormals[(i - 1) * 3 + 2]);

            normalBuffer.push(faceNormals[i * 3]);
            normalBuffer.push(faceNormals[i * 3 + 1]);
            normalBuffer.push(faceNormals[i * 3 + 2]);
          }

          if (uvInfo) {

            uvInfo.forEach(function (uv, j) {

              if (uvsBuffer[j] === undefined) uvsBuffer[j] = [];

              uvsBuffer[j].push(faceUVs[j][0]);
              uvsBuffer[j].push(faceUVs[j][1]);

              uvsBuffer[j].push(faceUVs[j][(i - 1) * 2]);
              uvsBuffer[j].push(faceUVs[j][(i - 1) * 2 + 1]);

              uvsBuffer[j].push(faceUVs[j][i * 2]);
              uvsBuffer[j].push(faceUVs[j][i * 2 + 1]);
            });
          }
        }

        polygonIndex++;
        faceLength = 0;

        // reset arrays for the next face
        vertexPositionIndexes = [];
        faceNormals = [];
        faceColors = [];
        faceUVs = [];
        faceWeights = [];
        faceWeightIndices = [];
      }
    });

    var geo = new THREE.BufferGeometry();
    geo.name = geometryNode.name;

    var positionAttribute = new THREE.Float32BufferAttribute(vertexBuffer, 3);

    preTransform.applyToBufferAttribute(positionAttribute);

    geo.addAttribute('position', positionAttribute);

    if (colorsBuffer.length > 0) {

      geo.addAttribute('color', new THREE.Float32BufferAttribute(colorsBuffer, 3));
    }

    if (skeleton) {

      geo.addAttribute('skinIndex', new THREE.Float32BufferAttribute(weightsIndicesBuffer, 4));

      geo.addAttribute('skinWeight', new THREE.Float32BufferAttribute(vertexWeightsBuffer, 4));

      // used later to bind the skeleton to the model
      geo.FBX_Deformer = skeleton;
    }

    if (normalBuffer.length > 0) {

      var normalAttribute = new THREE.Float32BufferAttribute(normalBuffer, 3);

      var normalMatrix = new THREE.Matrix3().getNormalMatrix(preTransform);
      normalMatrix.applyToBufferAttribute(normalAttribute);

      geo.addAttribute('normal', normalAttribute);
    }

    uvsBuffer.forEach(function (uvBuffer, i) {

      // subsequent uv buffers are called 'uv1', 'uv2', ...
      var name = 'uv' + (i + 1).toString();

      // the first uv buffer is just called 'uv'
      if (i === 0) {

        name = 'uv';
      }

      geo.addAttribute(name, new THREE.Float32BufferAttribute(uvsBuffer[i], 2));
    });

    if (materialInfo && materialInfo.mappingType !== 'AllSame') {

      // Convert the material indices of each vertex into rendering groups on the geometry.
      var prevMaterialIndex = materialIndexBuffer[0];
      var startIndex = 0;

      materialIndexBuffer.forEach(function (currentIndex, i) {

        if (currentIndex !== prevMaterialIndex) {

          geo.addGroup(startIndex, i - startIndex, prevMaterialIndex);

          prevMaterialIndex = currentIndex;
          startIndex = i;
        }
      });

      // the loop above doesn't add the last group, do that here.
      if (geo.groups.length > 0) {

        var lastGroup = geo.groups[geo.groups.length - 1];
        var lastIndex = lastGroup.start + lastGroup.count;

        if (lastIndex !== materialIndexBuffer.length) {

          geo.addGroup(lastIndex, materialIndexBuffer.length - lastIndex, prevMaterialIndex);
        }
      }

      // case where there are multiple materials but the whole geometry is only
      // using one of them
      if (geo.groups.length === 0) {

        geo.addGroup(0, materialIndexBuffer.length, materialIndexBuffer[0]);
      }
    }

    return geo;
  }

  // Parse normal from FBXTree.Objects.Geometry.LayerElementNormal if it exists
  function getNormals(NormalNode) {

    var mappingType = NormalNode.MappingInformationType;
    var referenceType = NormalNode.ReferenceInformationType;
    var buffer = NormalNode.Normals.a;
    var indexBuffer = [];
    if (referenceType === 'IndexToDirect') {

      if ('NormalIndex' in NormalNode) {

        indexBuffer = NormalNode.NormalIndex.a;
      } else if ('NormalsIndex' in NormalNode) {

        indexBuffer = NormalNode.NormalsIndex.a;
      }
    }

    return {
      dataSize: 3,
      buffer: buffer,
      indices: indexBuffer,
      mappingType: mappingType,
      referenceType: referenceType
    };
  }

  // Parse UVs from FBXTree.Objects.Geometry.LayerElementUV if it exists
  function getUVs(UVNode) {

    var mappingType = UVNode.MappingInformationType;
    var referenceType = UVNode.ReferenceInformationType;
    var buffer = UVNode.UV.a;
    var indexBuffer = [];
    if (referenceType === 'IndexToDirect') {

      indexBuffer = UVNode.UVIndex.a;
    }

    return {
      dataSize: 2,
      buffer: buffer,
      indices: indexBuffer,
      mappingType: mappingType,
      referenceType: referenceType
    };
  }

  // Parse Vertex Colors from FBXTree.Objects.Geometry.LayerElementColor if it exists
  function getColors(ColorNode) {

    var mappingType = ColorNode.MappingInformationType;
    var referenceType = ColorNode.ReferenceInformationType;
    var buffer = ColorNode.Colors.a;
    var indexBuffer = [];
    if (referenceType === 'IndexToDirect') {

      indexBuffer = ColorNode.ColorIndex.a;
    }

    return {
      dataSize: 4,
      buffer: buffer,
      indices: indexBuffer,
      mappingType: mappingType,
      referenceType: referenceType
    };
  }

  // Parse mapping and material data in FBXTree.Objects.Geometry.LayerElementMaterial if it exists
  function getMaterials(MaterialNode) {

    var mappingType = MaterialNode.MappingInformationType;
    var referenceType = MaterialNode.ReferenceInformationType;

    if (mappingType === 'NoMappingInformation') {

      return {
        dataSize: 1,
        buffer: [0],
        indices: [0],
        mappingType: 'AllSame',
        referenceType: referenceType
      };
    }

    var materialIndexBuffer = MaterialNode.Materials.a;

    // Since materials are stored as indices, there's a bit of a mismatch between FBX and what
    // we expect.So we create an intermediate buffer that points to the index in the buffer,
    // for conforming with the other functions we've written for other data.
    var materialIndices = [];

    for (var i = 0; i < materialIndexBuffer.length; ++i) {

      materialIndices.push(i);
    }

    return {
      dataSize: 1,
      buffer: materialIndexBuffer,
      indices: materialIndices,
      mappingType: mappingType,
      referenceType: referenceType
    };
  }

  // Functions use the infoObject and given indices to return value array of geometry.
  // Parameters:
  // 	- polygonVertexIndex - Index of vertex in draw order (which index of the index buffer refers to this vertex).
  // 	- polygonIndex - Index of polygon in geometry.
  // 	- vertexIndex - Index of vertex inside vertex buffer (used because some data refers to old index buffer that we don't use anymore).
  // 	- infoObject: can be materialInfo, normalInfo, UVInfo or colorInfo
  // Index type:
  //	- Direct: index is same as polygonVertexIndex
  //	- IndexToDirect: infoObject has it's own set of indices
  var dataArray = [];

  var GetData = {

    ByPolygonVertex: {

      Direct: function Direct(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {

        var from = polygonVertexIndex * infoObject.dataSize;
        var to = polygonVertexIndex * infoObject.dataSize + infoObject.dataSize;

        return slice(dataArray, infoObject.buffer, from, to);
      },

      IndexToDirect: function IndexToDirect(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {

        var index = infoObject.indices[polygonVertexIndex];
        var from = index * infoObject.dataSize;
        var to = index * infoObject.dataSize + infoObject.dataSize;

        return slice(dataArray, infoObject.buffer, from, to);
      }

    },

    ByPolygon: {

      Direct: function Direct(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {

        var from = polygonIndex * infoObject.dataSize;
        var to = polygonIndex * infoObject.dataSize + infoObject.dataSize;

        return slice(dataArray, infoObject.buffer, from, to);
      },

      IndexToDirect: function IndexToDirect(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {

        var index = infoObject.indices[polygonIndex];
        var from = index * infoObject.dataSize;
        var to = index * infoObject.dataSize + infoObject.dataSize;

        return slice(dataArray, infoObject.buffer, from, to);
      }

    },

    ByVertice: {

      Direct: function Direct(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {

        var from = vertexIndex * infoObject.dataSize;
        var to = vertexIndex * infoObject.dataSize + infoObject.dataSize;

        return slice(dataArray, infoObject.buffer, from, to);
      }

    },

    AllSame: {

      IndexToDirect: function IndexToDirect(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {

        var from = infoObject.indices[0] * infoObject.dataSize;
        var to = infoObject.indices[0] * infoObject.dataSize + infoObject.dataSize;

        return slice(dataArray, infoObject.buffer, from, to);
      }

    }

  };

  function getData(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) {

    return GetData[infoObject.mappingType][infoObject.referenceType](polygonVertexIndex, polygonIndex, vertexIndex, infoObject);
  }

  // Generate a NurbGeometry from a node in FBXTree.Objects.Geometry
  function parseNurbsGeometry(geometryNode) {

    if (THREE.NURBSCurve === undefined) {

      console.error('THREE.FBXLoader: The loader relies on THREE.NURBSCurve for any nurbs present in the model. Nurbs will show up as empty geometry.');
      return new THREE.BufferGeometry();
    }

    var order = parseInt(geometryNode.Order);

    if (isNaN(order)) {

      console.error('THREE.FBXLoader: Invalid Order %s given for geometry ID: %s', geometryNode.Order, geometryNode.id);
      return new THREE.BufferGeometry();
    }

    var degree = order - 1;

    var knots = geometryNode.KnotVector.a;
    var controlPoints = [];
    var pointsValues = geometryNode.Points.a;

    for (var i = 0, l = pointsValues.length; i < l; i += 4) {

      controlPoints.push(new THREE.Vector4().fromArray(pointsValues, i));
    }

    var startKnot, endKnot;

    if (geometryNode.Form === 'Closed') {

      controlPoints.push(controlPoints[0]);
    } else if (geometryNode.Form === 'Periodic') {

      startKnot = degree;
      endKnot = knots.length - 1 - startKnot;

      for (var i = 0; i < degree; ++i) {

        controlPoints.push(controlPoints[i]);
      }
    }

    var curve = new THREE.NURBSCurve(degree, knots, controlPoints, startKnot, endKnot);
    var vertices = curve.getPoints(controlPoints.length * 7);

    var positions = new Float32Array(vertices.length * 3);

    vertices.forEach(function (vertex, i) {

      vertex.toArray(positions, i * 3);
    });

    var geometry = new THREE.BufferGeometry();
    geometry.addAttribute('position', new THREE.BufferAttribute(positions, 3));

    return geometry;
  }

  // create the main THREE.Group() to be returned by the loader
  function parseScene(FBXTree, connections, skeletons, geometryMap, materialMap) {

    var sceneGraph = new THREE.Group();

    var modelMap = parseModels(FBXTree, skeletons, geometryMap, materialMap, connections);

    var modelNodes = FBXTree.Objects.Model;

    modelMap.forEach(function (model) {

      var modelNode = modelNodes[model.ID];
      setLookAtProperties(FBXTree, model, modelNode, connections, sceneGraph);

      var parentConnections = connections.get(model.ID).parents;

      parentConnections.forEach(function (connection) {

        var parent = modelMap.get(connection.ID);
        if (parent !== undefined) parent.add(model);
      });

      if (model.parent === null) {

        sceneGraph.add(model);
      }
    });

    bindSkeleton(FBXTree, skeletons, geometryMap, modelMap, connections);

    addAnimations(FBXTree, connections, sceneGraph);

    createAmbientLight(FBXTree, sceneGraph);

    return sceneGraph;
  }

  // parse nodes in FBXTree.Objects.Model
  function parseModels(FBXTree, skeletons, geometryMap, materialMap, connections) {

    var modelMap = new Map();
    var modelNodes = FBXTree.Objects.Model;

    for (var nodeID in modelNodes) {

      var id = parseInt(nodeID);
      var node = modelNodes[nodeID];
      var relationships = connections.get(id);

      var model = buildSkeleton(relationships, skeletons, id, node.attrName);

      if (!model) {

        switch (node.attrType) {

          case 'Camera':
            model = createCamera(FBXTree, relationships);
            break;
          case 'Light':
            model = createLight(FBXTree, relationships);
            break;
          case 'Mesh':
            model = createMesh(FBXTree, relationships, geometryMap, materialMap);
            break;
          case 'NurbsCurve':
            model = createCurve(relationships, geometryMap);
            break;
          case 'LimbNode': // usually associated with a Bone, however if a Bone was not created we'll make a Group instead
          case 'Null':
          default:
            model = new THREE.Group();
            break;

        }

        model.name = THREE.PropertyBinding.sanitizeNodeName(node.attrName);
        model.ID = id;
      }

      setModelTransforms(FBXTree, model, node);
      modelMap.set(id, model);
    }

    return modelMap;
  }

  function buildSkeleton(relationships, skeletons, id, name) {

    var bone = null;

    relationships.parents.forEach(function (parent) {

      for (var ID in skeletons) {

        var skeleton = skeletons[ID];

        skeleton.rawBones.forEach(function (rawBone, i) {

          if (rawBone.ID === parent.ID) {

            var subBone = bone;
            bone = new THREE.Bone();
            bone.matrixWorld.copy(rawBone.transformLink);

            // set name and id here - otherwise in cases where "subBone" is created it will not have a name / id
            bone.name = THREE.PropertyBinding.sanitizeNodeName(name);
            bone.ID = id;

            skeleton.bones[i] = bone;

            // In cases where a bone is shared between multiple meshes
            // duplicate the bone here and and it as a child of the first bone
            if (subBone !== null) {

              bone.add(subBone);
            }
          }
        });
      }
    });

    return bone;
  }

  // create a THREE.PerspectiveCamera or THREE.OrthographicCamera
  function createCamera(FBXTree, relationships) {

    var model;
    var cameraAttribute;

    relationships.children.forEach(function (child) {

      var attr = FBXTree.Objects.NodeAttribute[child.ID];

      if (attr !== undefined) {

        cameraAttribute = attr;
      }
    });

    if (cameraAttribute === undefined) {

      model = new THREE.Object3D();
    } else {

      var type = 0;
      if (cameraAttribute.CameraProjectionType !== undefined && cameraAttribute.CameraProjectionType.value === 1) {

        type = 1;
      }

      var nearClippingPlane = 1;
      if (cameraAttribute.NearPlane !== undefined) {

        nearClippingPlane = cameraAttribute.NearPlane.value / 1000;
      }

      var farClippingPlane = 1000;
      if (cameraAttribute.FarPlane !== undefined) {

        farClippingPlane = cameraAttribute.FarPlane.value / 1000;
      }

      var width = window.innerWidth;
      var height = window.innerHeight;

      if (cameraAttribute.AspectWidth !== undefined && cameraAttribute.AspectHeight !== undefined) {

        width = cameraAttribute.AspectWidth.value;
        height = cameraAttribute.AspectHeight.value;
      }

      var aspect = width / height;

      var fov = 45;
      if (cameraAttribute.FieldOfView !== undefined) {

        fov = cameraAttribute.FieldOfView.value;
      }

      var focalLength = cameraAttribute.FocalLength ? cameraAttribute.FocalLength.value : null;

      switch (type) {

        case 0:
          // Perspective
          model = new THREE.PerspectiveCamera(fov, aspect, nearClippingPlane, farClippingPlane);
          if (focalLength !== null) model.setFocalLength(focalLength);
          break;

        case 1:
          // Orthographic
          model = new THREE.OrthographicCamera(-width / 2, width / 2, height / 2, -height / 2, nearClippingPlane, farClippingPlane);
          break;

        default:
          console.warn('THREE.FBXLoader: Unknown camera type ' + type + '.');
          model = new THREE.Object3D();
          break;

      }
    }

    return model;
  }

  // Create a THREE.DirectionalLight, THREE.PointLight or THREE.SpotLight
  function createLight(FBXTree, relationships) {

    var model;
    var lightAttribute;

    relationships.children.forEach(function (child) {

      var attr = FBXTree.Objects.NodeAttribute[child.ID];

      if (attr !== undefined) {

        lightAttribute = attr;
      }
    });

    if (lightAttribute === undefined) {

      model = new THREE.Object3D();
    } else {

      var type;

      // LightType can be undefined for Point lights
      if (lightAttribute.LightType === undefined) {

        type = 0;
      } else {

        type = lightAttribute.LightType.value;
      }

      var color = 0xffffff;

      if (lightAttribute.Color !== undefined) {

        color = new THREE.Color().fromArray(lightAttribute.Color.value);
      }

      var intensity = lightAttribute.Intensity === undefined ? 1 : lightAttribute.Intensity.value / 100;

      // light disabled
      if (lightAttribute.CastLightOnObject !== undefined && lightAttribute.CastLightOnObject.value === 0) {

        intensity = 0;
      }

      var distance = 0;
      if (lightAttribute.FarAttenuationEnd !== undefined) {

        if (lightAttribute.EnableFarAttenuation !== undefined && lightAttribute.EnableFarAttenuation.value === 0) {

          distance = 0;
        } else {

          distance = lightAttribute.FarAttenuationEnd.value / 1000;
        }
      }

      // TODO: could this be calculated linearly from FarAttenuationStart to FarAttenuationEnd?
      var decay = 1;

      switch (type) {

        case 0:
          // Point
          model = new THREE.PointLight(color, intensity, distance, decay);
          break;

        case 1:
          // Directional
          model = new THREE.DirectionalLight(color, intensity);
          break;

        case 2:
          // Spot
          var angle = Math.PI / 3;

          if (lightAttribute.InnerAngle !== undefined) {

            angle = THREE.Math.degToRad(lightAttribute.InnerAngle.value);
          }

          var penumbra = 0;
          if (lightAttribute.OuterAngle !== undefined) {

            // TODO: this is not correct - FBX calculates outer and inner angle in degrees
            // with OuterAngle > InnerAngle && OuterAngle <= Math.PI
            // while three.js uses a penumbra between (0, 1) to attenuate the inner angle
            penumbra = THREE.Math.degToRad(lightAttribute.OuterAngle.value);
            penumbra = Math.max(penumbra, 1);
          }

          model = new THREE.SpotLight(color, intensity, distance, angle, penumbra, decay);
          break;

        default:
          console.warn('THREE.FBXLoader: Unknown light type ' + lightAttribute.LightType.value + ', defaulting to a THREE.PointLight.');
          model = new THREE.PointLight(color, intensity);
          break;

      }

      if (lightAttribute.CastShadows !== undefined && lightAttribute.CastShadows.value === 1) {

        model.castShadow = true;
      }
    }

    return model;
  }

  function createMesh(FBXTree, relationships, geometryMap, materialMap) {

    var model;
    var geometry = null;
    var material = null;
    var materials = [];

    // get geometry and materials(s) from connections
    relationships.children.forEach(function (child) {

      if (geometryMap.has(child.ID)) {

        geometry = geometryMap.get(child.ID);
      }

      if (materialMap.has(child.ID)) {

        materials.push(materialMap.get(child.ID));
      }
    });

    if (materials.length > 1) {

      material = materials;
    } else if (materials.length > 0) {

      material = materials[0];
    } else {

      material = new THREE.MeshPhongMaterial({ color: 0xcccccc });
      materials.push(material);
    }

    if ('color' in geometry.attributes) {

      materials.forEach(function (material) {

        material.vertexColors = THREE.VertexColors;
      });
    }

    if (geometry.FBX_Deformer) {

      materials.forEach(function (material) {

        material.skinning = true;
      });

      model = new THREE.SkinnedMesh(geometry, material);
    } else {

      model = new THREE.Mesh(geometry, material);
    }

    return model;
  }

  function createCurve(relationships, geometryMap) {

    var geometry = relationships.children.reduce(function (geo, child) {

      if (geometryMap.has(child.ID)) geo = geometryMap.get(child.ID);

      return geo;
    }, null);

    // FBX does not list materials for Nurbs lines, so we'll just put our own in here.
    var material = new THREE.LineBasicMaterial({ color: 0x3300ff, linewidth: 1 });
    return new THREE.Line(geometry, material);
  }

  // Parse ambient color in FBXTree.GlobalSettings - if it's not set to black (default), create an ambient light
  function createAmbientLight(FBXTree, sceneGraph) {

    if ('GlobalSettings' in FBXTree && 'AmbientColor' in FBXTree.GlobalSettings) {

      var ambientColor = FBXTree.GlobalSettings.AmbientColor.value;
      var r = ambientColor[0];
      var g = ambientColor[1];
      var b = ambientColor[2];

      if (r !== 0 || g !== 0 || b !== 0) {

        var color = new THREE.Color(r, g, b);
        sceneGraph.add(new THREE.AmbientLight(color, 1));
      }
    }
  }

  function setLookAtProperties(FBXTree, model, modelNode, connections, sceneGraph) {

    if ('LookAtProperty' in modelNode) {

      var children = connections.get(model.ID).children;

      children.forEach(function (child) {

        if (child.relationship === 'LookAtProperty') {

          var lookAtTarget = FBXTree.Objects.Model[child.ID];

          if ('Lcl_Translation' in lookAtTarget) {

            var pos = lookAtTarget.Lcl_Translation.value;

            // DirectionalLight, SpotLight
            if (model.target !== undefined) {

              model.target.position.fromArray(pos);
              sceneGraph.add(model.target);
            } else {
              // Cameras and other Object3Ds

              model.lookAt(new THREE.Vector3().fromArray(pos));
            }
          }
        }
      });
    }
  }

  // parse the model node for transform details and apply them to the model
  function setModelTransforms(FBXTree, model, modelNode) {

    // http://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_class_fbx_euler_html
    if ('RotationOrder' in modelNode) {

      var enums = ['XYZ', // default
      'XZY', 'YZX', 'ZXY', 'YXZ', 'ZYX', 'SphericXYZ'];

      var value = parseInt(modelNode.RotationOrder.value, 10);

      if (value > 0 && value < 6) {

        // model.rotation.order = enums[ value ];

        // Note: Euler order other than XYZ is currently not supported, so just display a warning for now
        console.warn('THREE.FBXLoader: unsupported Euler Order: %s. Currently only XYZ order is supported. Animations and rotations may be incorrect.', enums[value]);
      } else if (value === 6) {

        console.warn('THREE.FBXLoader: unsupported Euler Order: Spherical XYZ. Animations and rotations may be incorrect.');
      }
    }

    if ('Lcl_Translation' in modelNode) {

      model.position.fromArray(modelNode.Lcl_Translation.value);
    }

    if ('Lcl_Rotation' in modelNode) {

      var rotation = modelNode.Lcl_Rotation.value.map(THREE.Math.degToRad);
      rotation.push('ZYX');
      model.rotation.fromArray(rotation);
    }

    if ('Lcl_Scaling' in modelNode) {

      model.scale.fromArray(modelNode.Lcl_Scaling.value);
    }

    if ('PreRotation' in modelNode) {

      var array = modelNode.PreRotation.value.map(THREE.Math.degToRad);
      array[3] = 'ZYX';

      var preRotations = new THREE.Euler().fromArray(array);

      preRotations = new THREE.Quaternion().setFromEuler(preRotations);
      var currentRotation = new THREE.Quaternion().setFromEuler(model.rotation);
      preRotations.multiply(currentRotation);
      model.rotation.setFromQuaternion(preRotations, 'ZYX');
    }
  }

  function bindSkeleton(FBXTree, skeletons, geometryMap, modelMap, connections) {

    var bindMatrices = parsePoseNodes(FBXTree);

    for (var ID in skeletons) {

      var skeleton = skeletons[ID];

      var parents = connections.get(parseInt(skeleton.ID)).parents;

      parents.forEach(function (parent) {

        if (geometryMap.has(parent.ID)) {

          var geoID = parent.ID;
          var geoRelationships = connections.get(geoID);

          geoRelationships.parents.forEach(function (geoConnParent) {

            if (modelMap.has(geoConnParent.ID)) {

              var model = modelMap.get(geoConnParent.ID);

              model.bind(new THREE.Skeleton(skeleton.bones), bindMatrices[geoConnParent.ID]);
            }
          });
        }
      });
    }
  }

  function parsePoseNodes(FBXTree) {

    var bindMatrices = {};

    if ('Pose' in FBXTree.Objects) {

      var BindPoseNode = FBXTree.Objects.Pose;

      for (var nodeID in BindPoseNode) {

        if (BindPoseNode[nodeID].attrType === 'BindPose') {

          var poseNodes = BindPoseNode[nodeID].PoseNode;

          if (Array.isArray(poseNodes)) {

            poseNodes.forEach(function (poseNode) {

              bindMatrices[poseNode.Node] = new THREE.Matrix4().fromArray(poseNode.Matrix.a);
            });
          } else {

            bindMatrices[poseNodes.Node] = new THREE.Matrix4().fromArray(poseNodes.Matrix.a);
          }
        }
      }
    }

    return bindMatrices;
  }

  function parseAnimations(FBXTree, connections) {

    // since the actual transformation data is stored in FBXTree.Objects.AnimationCurve,
    // if this is undefined we can safely assume there are no animations
    if (FBXTree.Objects.AnimationCurve === undefined) return undefined;

    var curveNodesMap = parseAnimationCurveNodes(FBXTree);

    parseAnimationCurves(FBXTree, connections, curveNodesMap);

    var layersMap = parseAnimationLayers(FBXTree, connections, curveNodesMap);
    var rawClips = parseAnimStacks(FBXTree, connections, layersMap);

    return rawClips;
  }

  // parse nodes in FBXTree.Objects.AnimationCurveNode
  // each AnimationCurveNode holds data for an animation transform for a model (e.g. left arm rotation )
  // and is referenced by an AnimationLayer
  function parseAnimationCurveNodes(FBXTree) {

    var rawCurveNodes = FBXTree.Objects.AnimationCurveNode;

    var curveNodesMap = new Map();

    for (var nodeID in rawCurveNodes) {

      var rawCurveNode = rawCurveNodes[nodeID];

      if (rawCurveNode.attrName.match(/S|R|T/) !== null) {

        var curveNode = {

          id: rawCurveNode.id,
          attr: rawCurveNode.attrName,
          curves: {}

        };

        curveNodesMap.set(curveNode.id, curveNode);
      }
    }

    return curveNodesMap;
  }

  // parse nodes in FBXTree.Objects.AnimationCurve and connect them up to
  // previously parsed AnimationCurveNodes. Each AnimationCurve holds data for a single animated
  // axis ( e.g. times and values of x rotation)
  function parseAnimationCurves(FBXTree, connections, curveNodesMap) {

    var rawCurves = FBXTree.Objects.AnimationCurve;

    for (var nodeID in rawCurves) {

      var animationCurve = {

        id: rawCurves[nodeID].id,
        times: rawCurves[nodeID].KeyTime.a.map(convertFBXTimeToSeconds),
        values: rawCurves[nodeID].KeyValueFloat.a

      };

      var relationships = connections.get(animationCurve.id);

      if (relationships !== undefined) {

        var animationCurveID = relationships.parents[0].ID;
        var animationCurveRelationship = relationships.parents[0].relationship;
        var axis = '';

        if (animationCurveRelationship.match(/X/)) {

          axis = 'x';
        } else if (animationCurveRelationship.match(/Y/)) {

          axis = 'y';
        } else if (animationCurveRelationship.match(/Z/)) {

          axis = 'z';
        } else {

          continue;
        }

        curveNodesMap.get(animationCurveID).curves[axis] = animationCurve;
      }
    }
  }

  // parse nodes in FBXTree.Objects.AnimationLayer. Each layers holds references
  // to various AnimationCurveNodes and is referenced by an AnimationStack node
  // note: theoretically a stack can multiple layers, however in practice there always seems to be one per stack
  function parseAnimationLayers(FBXTree, connections, curveNodesMap) {

    var rawLayers = FBXTree.Objects.AnimationLayer;

    var layersMap = new Map();

    for (var nodeID in rawLayers) {

      var layerCurveNodes = [];

      var connection = connections.get(parseInt(nodeID));

      if (connection !== undefined) {

        // all the animationCurveNodes used in the layer
        var children = connection.children;

        children.forEach(function (child, i) {

          if (curveNodesMap.has(child.ID)) {

            var curveNode = curveNodesMap.get(child.ID);

            // check that the curves are defined for at least one axis, otherwise ignore the curveNode
            if (curveNode.curves.x !== undefined || curveNode.curves.y !== undefined || curveNode.curves.z !== undefined) {

              if (layerCurveNodes[i] === undefined) {

                var modelID;

                connections.get(child.ID).parents.forEach(function (parent) {

                  if (parent.relationship !== undefined) modelID = parent.ID;
                });

                var rawModel = FBXTree.Objects.Model[modelID.toString()];

                var node = {

                  modelName: THREE.PropertyBinding.sanitizeNodeName(rawModel.attrName),
                  initialPosition: [0, 0, 0],
                  initialRotation: [0, 0, 0],
                  initialScale: [1, 1, 1]

                };

                if ('Lcl_Translation' in rawModel) node.initialPosition = rawModel.Lcl_Translation.value;

                if ('Lcl_Rotation' in rawModel) node.initialRotation = rawModel.Lcl_Rotation.value;

                if ('Lcl_Scaling' in rawModel) node.initialScale = rawModel.Lcl_Scaling.value;

                // if the animated model is pre rotated, we'll have to apply the pre rotations to every
                // animation value as well
                if ('PreRotation' in rawModel) node.preRotations = rawModel.PreRotation.value;

                layerCurveNodes[i] = node;
              }

              layerCurveNodes[i][curveNode.attr] = curveNode;
            }
          }
        });

        layersMap.set(parseInt(nodeID), layerCurveNodes);
      }
    }

    return layersMap;
  }

  // parse nodes in FBXTree.Objects.AnimationStack. These are the top level node in the animation
  // hierarchy. Each Stack node will be used to create a THREE.AnimationClip
  function parseAnimStacks(FBXTree, connections, layersMap) {

    var rawStacks = FBXTree.Objects.AnimationStack;

    // connect the stacks (clips) up to the layers
    var rawClips = {};

    for (var nodeID in rawStacks) {

      var children = connections.get(parseInt(nodeID)).children;

      if (children.length > 1) {

        // it seems like stacks will always be associated with a single layer. But just in case there are files
        // where there are multiple layers per stack, we'll display a warning
        console.warn('THREE.FBXLoader: Encountered an animation stack with multiple layers, this is currently not supported. Ignoring subsequent layers.');
      }

      var layer = layersMap.get(children[0].ID);

      rawClips[nodeID] = {

        name: rawStacks[nodeID].attrName,
        layer: layer

      };
    }

    return rawClips;
  }

  // take raw animation data from parseAnimations and connect it up to the loaded models
  function addAnimations(FBXTree, connections, sceneGraph) {

    sceneGraph.animations = [];

    var rawClips = parseAnimations(FBXTree, connections);

    if (rawClips === undefined) return;

    for (var key in rawClips) {

      var rawClip = rawClips[key];

      var clip = addClip(rawClip);

      sceneGraph.animations.push(clip);
    }
  }

  function addClip(rawClip) {

    var tracks = [];

    rawClip.layer.forEach(function (rawTracks) {

      tracks = tracks.concat(generateTracks(rawTracks));
    });

    return new THREE.AnimationClip(rawClip.name, -1, tracks);
  }

  function generateTracks(rawTracks) {

    var tracks = [];

    if (rawTracks.T !== undefined && Object.keys(rawTracks.T.curves).length > 0) {

      var positionTrack = generateVectorTrack(rawTracks.modelName, rawTracks.T.curves, rawTracks.initialPosition, 'position');
      if (positionTrack !== undefined) tracks.push(positionTrack);
    }

    if (rawTracks.R !== undefined && Object.keys(rawTracks.R.curves).length > 0) {

      var rotationTrack = generateRotationTrack(rawTracks.modelName, rawTracks.R.curves, rawTracks.initialRotation, rawTracks.preRotations);
      if (rotationTrack !== undefined) tracks.push(rotationTrack);
    }

    if (rawTracks.S !== undefined && Object.keys(rawTracks.S.curves).length > 0) {

      var scaleTrack = generateVectorTrack(rawTracks.modelName, rawTracks.S.curves, rawTracks.initialScale, 'scale');
      if (scaleTrack !== undefined) tracks.push(scaleTrack);
    }

    return tracks;
  }

  function generateVectorTrack(modelName, curves, initialValue, type) {

    var times = getTimesForAllAxes(curves);
    var values = getKeyframeTrackValues(times, curves, initialValue);

    return new THREE.VectorKeyframeTrack(modelName + '.' + type, times, values);
  }

  function generateRotationTrack(modelName, curves, initialValue, preRotations) {

    if (curves.x !== undefined) curves.x.values = curves.x.values.map(THREE.Math.degToRad);
    if (curves.y !== undefined) curves.y.values = curves.y.values.map(THREE.Math.degToRad);
    if (curves.z !== undefined) curves.z.values = curves.z.values.map(THREE.Math.degToRad);

    var times = getTimesForAllAxes(curves);
    var values = getKeyframeTrackValues(times, curves, initialValue);

    if (preRotations !== undefined) {

      preRotations = preRotations.map(THREE.Math.degToRad);
      preRotations.push('ZYX');

      preRotations = new THREE.Euler().fromArray(preRotations);
      preRotations = new THREE.Quaternion().setFromEuler(preRotations);
    }

    var quaternion = new THREE.Quaternion();
    var euler = new THREE.Euler();

    var quaternionValues = [];

    for (var i = 0; i < values.length; i += 3) {

      euler.set(values[i], values[i + 1], values[i + 2], 'ZYX');

      quaternion.setFromEuler(euler);

      if (preRotations !== undefined) quaternion.premultiply(preRotations);

      quaternion.toArray(quaternionValues, i / 3 * 4);
    }

    return new THREE.QuaternionKeyframeTrack(modelName + '.quaternion', times, quaternionValues);
  }

  function getKeyframeTrackValues(times, curves, initialValue) {

    var prevValue = initialValue;

    var values = [];

    var xIndex = -1;
    var yIndex = -1;
    var zIndex = -1;

    times.forEach(function (time) {

      if (curves.x) xIndex = curves.x.times.indexOf(time);
      if (curves.y) yIndex = curves.y.times.indexOf(time);
      if (curves.z) zIndex = curves.z.times.indexOf(time);

      // if there is an x value defined for this frame, use that
      if (xIndex !== -1) {

        var xValue = curves.x.values[xIndex];
        values.push(xValue);
        prevValue[0] = xValue;
      } else {

        // otherwise use the x value from the previous frame
        values.push(prevValue[0]);
      }

      if (yIndex !== -1) {

        var yValue = curves.y.values[yIndex];
        values.push(yValue);
        prevValue[1] = yValue;
      } else {

        values.push(prevValue[1]);
      }

      if (zIndex !== -1) {

        var zValue = curves.z.values[zIndex];
        values.push(zValue);
        prevValue[2] = zValue;
      } else {

        values.push(prevValue[2]);
      }
    });

    return values;
  }

  // For all animated objects, times are defined separately for each axis
  // Here we'll combine the times into one sorted array without duplicates
  function getTimesForAllAxes(curves) {

    var times = [];

    // first join together the times for each axis, if defined
    if (curves.x !== undefined) times = times.concat(curves.x.times);
    if (curves.y !== undefined) times = times.concat(curves.y.times);
    if (curves.z !== undefined) times = times.concat(curves.z.times);

    // then sort them and remove duplicates
    times = times.sort(function (a, b) {

      return a - b;
    }).filter(function (elem, index, array) {

      return array.indexOf(elem) == index;
    });

    return times;
  }

  // parse an FBX file in ASCII format
  function TextParser() {}

  Object.assign(TextParser.prototype, {

    getPrevNode: function getPrevNode() {

      return this.nodeStack[this.currentIndent - 2];
    },

    getCurrentNode: function getCurrentNode() {

      return this.nodeStack[this.currentIndent - 1];
    },

    getCurrentProp: function getCurrentProp() {

      return this.currentProp;
    },

    pushStack: function pushStack(node) {

      this.nodeStack.push(node);
      this.currentIndent += 1;
    },

    popStack: function popStack() {

      this.nodeStack.pop();
      this.currentIndent -= 1;
    },

    setCurrentProp: function setCurrentProp(val, name) {

      this.currentProp = val;
      this.currentPropName = name;
    },

    parse: function parse(text) {

      this.currentIndent = 0;
      this.allNodes = new FBXTree();
      this.nodeStack = [];
      this.currentProp = [];
      this.currentPropName = '';

      var self = this;

      var split = text.split('\n');

      split.forEach(function (line, i) {

        var matchComment = line.match(/^[\s\t]*;/);
        var matchEmpty = line.match(/^[\s\t]*$/);

        if (matchComment || matchEmpty) return;

        var matchBeginning = line.match('^\\t{' + self.currentIndent + '}(\\w+):(.*){', '');
        var matchProperty = line.match('^\\t{' + self.currentIndent + '}(\\w+):[\\s\\t\\r\\n](.*)');
        var matchEnd = line.match('^\\t{' + (self.currentIndent - 1) + '}}');

        if (matchBeginning) {

          self.parseNodeBegin(line, matchBeginning);
        } else if (matchProperty) {

          self.parseNodeProperty(line, matchProperty, split[++i]);
        } else if (matchEnd) {

          self.popStack();
        } else if (line.match(/^[^\s\t}]/)) {

          // large arrays are split over multiple lines terminated with a ',' character
          // if this is encountered the line needs to be joined to the previous line
          self.parseNodePropertyContinued(line);
        }
      });

      return this.allNodes;
    },

    parseNodeBegin: function parseNodeBegin(line, property) {

      var nodeName = property[1].trim().replace(/^"/, '').replace(/"$/, '');

      var nodeAttrs = property[2].split(',').map(function (attr) {

        return attr.trim().replace(/^"/, '').replace(/"$/, '');
      });

      var node = { name: nodeName };
      var attrs = this.parseNodeAttr(nodeAttrs);

      var currentNode = this.getCurrentNode();

      // a top node
      if (this.currentIndent === 0) {

        this.allNodes.add(nodeName, node);
      } else {
        // a subnode

        // if the subnode already exists, append it
        if (nodeName in currentNode) {

          // special case Pose needs PoseNodes as an array
          if (nodeName === 'PoseNode') {

            currentNode.PoseNode.push(node);
          } else if (currentNode[nodeName].id !== undefined) {

            currentNode[nodeName] = {};
            currentNode[nodeName][currentNode[nodeName].id] = currentNode[nodeName];
          }

          if (attrs.id !== '') currentNode[nodeName][attrs.id] = node;
        } else if (typeof attrs.id === 'number') {

          currentNode[nodeName] = {};
          currentNode[nodeName][attrs.id] = node;
        } else if (nodeName !== 'Properties70') {

          if (nodeName === 'PoseNode') currentNode[nodeName] = [node];else currentNode[nodeName] = node;
        }
      }

      if (typeof attrs.id === 'number') node.id = attrs.id;
      if (attrs.name !== '') node.attrName = attrs.name;
      if (attrs.type !== '') node.attrType = attrs.type;

      this.pushStack(node);
    },

    parseNodeAttr: function parseNodeAttr(attrs) {

      var id = attrs[0];

      if (attrs[0] !== '') {

        id = parseInt(attrs[0]);

        if (isNaN(id)) {

          id = attrs[0];
        }
      }

      var name = '',
          type = '';

      if (attrs.length > 1) {

        name = attrs[1].replace(/^(\w+)::/, '');
        type = attrs[2];
      }

      return { id: id, name: name, type: type };
    },

    parseNodeProperty: function parseNodeProperty(line, property, contentLine) {

      var propName = property[1].replace(/^"/, '').replace(/"$/, '').trim();
      var propValue = property[2].replace(/^"/, '').replace(/"$/, '').trim();

      // for special case: base64 image data follows "Content: ," line
      //	Content: ,
      //	 "/9j/4RDaRXhpZgAATU0A..."
      if (propName === 'Content' && propValue === ',') {

        propValue = contentLine.replace(/"/g, '').replace(/,$/, '').trim();
      }

      var currentNode = this.getCurrentNode();
      var parentName = currentNode.name;

      if (parentName === 'Properties70') {

        this.parseNodeSpecialProperty(line, propName, propValue);
        return;
      }

      // Connections
      if (propName === 'C') {

        var connProps = propValue.split(',').slice(1);
        var from = parseInt(connProps[0]);
        var to = parseInt(connProps[1]);

        var rest = propValue.split(',').slice(3);

        rest = rest.map(function (elem) {

          return elem.trim().replace(/^"/, '');
        });

        propName = 'connections';
        propValue = [from, to];
        append(propValue, rest);

        if (currentNode[propName] === undefined) {

          currentNode[propName] = [];
        }
      }

      // Node
      if (propName === 'Node') currentNode.id = propValue;

      // connections
      if (propName in currentNode && Array.isArray(currentNode[propName])) {

        currentNode[propName].push(propValue);
      } else {

        if (propName !== 'a') currentNode[propName] = propValue;else currentNode.a = propValue;
      }

      this.setCurrentProp(currentNode, propName);

      // convert string to array, unless it ends in ',' in which case more will be added to it
      if (propName === 'a' && propValue.slice(-1) !== ',') {

        currentNode.a = parseNumberArray(propValue);
      }
    },

    parseNodePropertyContinued: function parseNodePropertyContinued(line) {

      var currentNode = this.getCurrentNode();

      currentNode.a += line;

      // if the line doesn't end in ',' we have reached the end of the property value
      // so convert the string to an array
      if (line.slice(-1) !== ',') {

        currentNode.a = parseNumberArray(currentNode.a);
      }
    },

    // parse "Property70"
    parseNodeSpecialProperty: function parseNodeSpecialProperty(line, propName, propValue) {

      // split this
      // P: "Lcl Scaling", "Lcl Scaling", "", "A",1,1,1
      // into array like below
      // ["Lcl Scaling", "Lcl Scaling", "", "A", "1,1,1" ]
      var props = propValue.split('",').map(function (prop) {

        return prop.trim().replace(/^\"/, '').replace(/\s/, '_');
      });

      var innerPropName = props[0];
      var innerPropType1 = props[1];
      var innerPropType2 = props[2];
      var innerPropFlag = props[3];
      var innerPropValue = props[4];

      // cast values where needed, otherwise leave as strings
      switch (innerPropType1) {

        case 'int':
        case 'enum':
        case 'bool':
        case 'ULongLong':
        case 'double':
        case 'Number':
        case 'FieldOfView':
          innerPropValue = parseFloat(innerPropValue);
          break;

        case 'Color':
        case 'ColorRGB':
        case 'Vector3D':
        case 'Lcl_Translation':
        case 'Lcl_Rotation':
        case 'Lcl_Scaling':
          innerPropValue = parseNumberArray(innerPropValue);
          break;

      }

      // CAUTION: these props must append to parent's parent
      this.getPrevNode()[innerPropName] = {

        'type': innerPropType1,
        'type2': innerPropType2,
        'flag': innerPropFlag,
        'value': innerPropValue

      };

      this.setCurrentProp(this.getPrevNode(), innerPropName);
    }

  });

  // Parse an FBX file in Binary format
  function BinaryParser() {}

  Object.assign(BinaryParser.prototype, {

    parse: function parse(buffer) {

      var reader = new BinaryReader(buffer);
      reader.skip(23); // skip magic 23 bytes

      var version = reader.getUint32();

      console.log('THREE.FBXLoader: FBX binary version: ' + version);

      var allNodes = new FBXTree();

      while (!this.endOfContent(reader)) {

        var node = this.parseNode(reader, version);
        if (node !== null) allNodes.add(node.name, node);
      }

      return allNodes;
    },

    // Check if reader has reached the end of content.
    endOfContent: function endOfContent(reader) {

      // footer size: 160bytes + 16-byte alignment padding
      // - 16bytes: magic
      // - padding til 16-byte alignment (at least 1byte?)
      //	(seems like some exporters embed fixed 15 or 16bytes?)
      // - 4bytes: magic
      // - 4bytes: version
      // - 120bytes: zero
      // - 16bytes: magic
      if (reader.size() % 16 === 0) {

        return (reader.getOffset() + 160 + 16 & ~0xf) >= reader.size();
      } else {

        return reader.getOffset() + 160 + 16 >= reader.size();
      }
    },

    // recursively parse nodes until the end of the file is reached
    parseNode: function parseNode(reader, version) {

      var node = {};

      // The first three data sizes depends on version.
      var endOffset = version >= 7500 ? reader.getUint64() : reader.getUint32();
      var numProperties = version >= 7500 ? reader.getUint64() : reader.getUint32();

      // note: do not remove this even if you get a linter warning as it moves the buffer forward
      var propertyListLen = version >= 7500 ? reader.getUint64() : reader.getUint32();

      var nameLen = reader.getUint8();
      var name = reader.getString(nameLen);

      // Regards this node as NULL-record if endOffset is zero
      if (endOffset === 0) return null;

      var propertyList = [];

      for (var i = 0; i < numProperties; i++) {

        propertyList.push(this.parseProperty(reader));
      }

      // Regards the first three elements in propertyList as id, attrName, and attrType
      var id = propertyList.length > 0 ? propertyList[0] : '';
      var attrName = propertyList.length > 1 ? propertyList[1] : '';
      var attrType = propertyList.length > 2 ? propertyList[2] : '';

      // check if this node represents just a single property
      // like (name, 0) set or (name2, [0, 1, 2]) set of {name: 0, name2: [0, 1, 2]}
      node.singleProperty = numProperties === 1 && reader.getOffset() === endOffset ? true : false;

      while (endOffset > reader.getOffset()) {

        var subNode = this.parseNode(reader, version);

        if (subNode !== null) this.parseSubNode(name, node, subNode);
      }

      node.propertyList = propertyList; // raw property list used by parent

      if (typeof id === 'number') node.id = id;
      if (attrName !== '') node.attrName = attrName;
      if (attrType !== '') node.attrType = attrType;
      if (name !== '') node.name = name;

      return node;
    },

    parseSubNode: function parseSubNode(name, node, subNode) {

      // special case: child node is single property
      if (subNode.singleProperty === true) {

        var value = subNode.propertyList[0];

        if (Array.isArray(value)) {

          node[subNode.name] = subNode;

          subNode.a = value;
        } else {

          node[subNode.name] = value;
        }
      } else if (name === 'Connections' && subNode.name === 'C') {

        var array = [];

        subNode.propertyList.forEach(function (property, i) {

          // first Connection is FBX type (OO, OP, etc.). We'll discard these
          if (i !== 0) array.push(property);
        });

        if (node.connections === undefined) {

          node.connections = [];
        }

        node.connections.push(array);
      } else if (subNode.name === 'Properties70') {

        var keys = Object.keys(subNode);

        keys.forEach(function (key) {

          node[key] = subNode[key];
        });
      } else if (name === 'Properties70' && subNode.name === 'P') {

        var innerPropName = subNode.propertyList[0];
        var innerPropType1 = subNode.propertyList[1];
        var innerPropType2 = subNode.propertyList[2];
        var innerPropFlag = subNode.propertyList[3];
        var innerPropValue;

        if (innerPropName.indexOf('Lcl ') === 0) innerPropName = innerPropName.replace('Lcl ', 'Lcl_');
        if (innerPropType1.indexOf('Lcl ') === 0) innerPropType1 = innerPropType1.replace('Lcl ', 'Lcl_');

        if (innerPropType1 === 'Color' || innerPropType1 === 'ColorRGB' || innerPropType1 === 'Vector' || innerPropType1 === 'Vector3D' || innerPropType1.indexOf('Lcl_') === 0) {

          innerPropValue = [subNode.propertyList[4], subNode.propertyList[5], subNode.propertyList[6]];
        } else {

          innerPropValue = subNode.propertyList[4];
        }

        // this will be copied to parent, see above
        node[innerPropName] = {

          'type': innerPropType1,
          'type2': innerPropType2,
          'flag': innerPropFlag,
          'value': innerPropValue

        };
      } else if (node[subNode.name] === undefined) {

        if (typeof subNode.id === 'number') {

          node[subNode.name] = {};
          node[subNode.name][subNode.id] = subNode;
        } else {

          node[subNode.name] = subNode;
        }
      } else {

        if (subNode.name === 'PoseNode') {

          if (!Array.isArray(node[subNode.name])) {

            node[subNode.name] = [node[subNode.name]];
          }

          node[subNode.name].push(subNode);
        } else if (node[subNode.name][subNode.id] === undefined) {

          node[subNode.name][subNode.id] = subNode;
        }
      }
    },

    parseProperty: function parseProperty(reader) {

      var type = reader.getString(1);

      switch (type) {

        case 'C':
          return reader.getBoolean();

        case 'D':
          return reader.getFloat64();

        case 'F':
          return reader.getFloat32();

        case 'I':
          return reader.getInt32();

        case 'L':
          return reader.getInt64();

        case 'R':
          var length = reader.getUint32();
          return reader.getArrayBuffer(length);

        case 'S':
          var length = reader.getUint32();
          return reader.getString(length);

        case 'Y':
          return reader.getInt16();

        case 'b':
        case 'c':
        case 'd':
        case 'f':
        case 'i':
        case 'l':

          var arrayLength = reader.getUint32();
          var encoding = reader.getUint32(); // 0: non-compressed, 1: compressed
          var compressedLength = reader.getUint32();

          if (encoding === 0) {

            switch (type) {

              case 'b':
              case 'c':
                return reader.getBooleanArray(arrayLength);

              case 'd':
                return reader.getFloat64Array(arrayLength);

              case 'f':
                return reader.getFloat32Array(arrayLength);

              case 'i':
                return reader.getInt32Array(arrayLength);

              case 'l':
                return reader.getInt64Array(arrayLength);

            }
          }

          if (window.Zlib === undefined) {

            console.error('THREE.FBXLoader: External library Inflate.min.js required, obtain or import from https://github.com/imaya/zlib.js');
          }

          var inflate = new Zlib.Inflate(new Uint8Array(reader.getArrayBuffer(compressedLength))); // eslint-disable-line no-undef
          var reader2 = new BinaryReader(inflate.decompress().buffer);

          switch (type) {

            case 'b':
            case 'c':
              return reader2.getBooleanArray(arrayLength);

            case 'd':
              return reader2.getFloat64Array(arrayLength);

            case 'f':
              return reader2.getFloat32Array(arrayLength);

            case 'i':
              return reader2.getInt32Array(arrayLength);

            case 'l':
              return reader2.getInt64Array(arrayLength);

          }

        default:
          throw new Error('THREE.FBXLoader: Unknown property type ' + type);

      }
    }

  });

  function BinaryReader(buffer, littleEndian) {

    this.dv = new DataView(buffer);
    this.offset = 0;
    this.littleEndian = littleEndian !== undefined ? littleEndian : true;
  }

  Object.assign(BinaryReader.prototype, {

    getOffset: function getOffset() {

      return this.offset;
    },

    size: function size() {

      return this.dv.buffer.byteLength;
    },

    skip: function skip(length) {

      this.offset += length;
    },

    // seems like true/false representation depends on exporter.
    // true: 1 or 'Y'(=0x59), false: 0 or 'T'(=0x54)
    // then sees LSB.
    getBoolean: function getBoolean() {

      return (this.getUint8() & 1) === 1;
    },

    getBooleanArray: function getBooleanArray(size) {

      var a = [];

      for (var i = 0; i < size; i++) {

        a.push(this.getBoolean());
      }

      return a;
    },

    getUint8: function getUint8() {

      var value = this.dv.getUint8(this.offset);
      this.offset += 1;
      return value;
    },

    getInt16: function getInt16() {

      var value = this.dv.getInt16(this.offset, this.littleEndian);
      this.offset += 2;
      return value;
    },

    getInt32: function getInt32() {

      var value = this.dv.getInt32(this.offset, this.littleEndian);
      this.offset += 4;
      return value;
    },

    getInt32Array: function getInt32Array(size) {

      var a = [];

      for (var i = 0; i < size; i++) {

        a.push(this.getInt32());
      }

      return a;
    },

    getUint32: function getUint32() {

      var value = this.dv.getUint32(this.offset, this.littleEndian);
      this.offset += 4;
      return value;
    },

    // JavaScript doesn't support 64-bit integer so calculate this here
    // 1 << 32 will return 1 so using multiply operation instead here.
    // There's a possibility that this method returns wrong value if the value
    // is out of the range between Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER.
    // TODO: safely handle 64-bit integer
    getInt64: function getInt64() {

      var low, high;

      if (this.littleEndian) {

        low = this.getUint32();
        high = this.getUint32();
      } else {

        high = this.getUint32();
        low = this.getUint32();
      }

      // calculate negative value
      if (high & 0x80000000) {

        high = ~high & 0xFFFFFFFF;
        low = ~low & 0xFFFFFFFF;

        if (low === 0xFFFFFFFF) high = high + 1 & 0xFFFFFFFF;

        low = low + 1 & 0xFFFFFFFF;

        return -(high * 0x100000000 + low);
      }

      return high * 0x100000000 + low;
    },

    getInt64Array: function getInt64Array(size) {

      var a = [];

      for (var i = 0; i < size; i++) {

        a.push(this.getInt64());
      }

      return a;
    },

    // Note: see getInt64() comment
    getUint64: function getUint64() {

      var low, high;

      if (this.littleEndian) {

        low = this.getUint32();
        high = this.getUint32();
      } else {

        high = this.getUint32();
        low = this.getUint32();
      }

      return high * 0x100000000 + low;
    },

    getFloat32: function getFloat32() {

      var value = this.dv.getFloat32(this.offset, this.littleEndian);
      this.offset += 4;
      return value;
    },

    getFloat32Array: function getFloat32Array(size) {

      var a = [];

      for (var i = 0; i < size; i++) {

        a.push(this.getFloat32());
      }

      return a;
    },

    getFloat64: function getFloat64() {

      var value = this.dv.getFloat64(this.offset, this.littleEndian);
      this.offset += 8;
      return value;
    },

    getFloat64Array: function getFloat64Array(size) {

      var a = [];

      for (var i = 0; i < size; i++) {

        a.push(this.getFloat64());
      }

      return a;
    },

    getArrayBuffer: function getArrayBuffer(size) {

      var value = this.dv.buffer.slice(this.offset, this.offset + size);
      this.offset += size;
      return value;
    },

    getString: function getString(size) {

      var a = new Uint8Array(size);

      for (var i = 0; i < size; i++) {

        a[i] = this.getUint8();
      }

      var nullByte = a.indexOf(0);
      if (nullByte >= 0) a = a.slice(0, nullByte);

      return THREE.LoaderUtils.decodeText(a);
    }

  });

  // FBXTree holds a representation of the FBX data, returned by the TextParser ( FBX ASCII format)
  // and BinaryParser( FBX Binary format)
  function FBXTree() {}

  Object.assign(FBXTree.prototype, {

    add: function add(key, val) {

      this[key] = val;
    }

  });

  function isFbxFormatBinary(buffer) {

    var CORRECT = 'Kaydara FBX Binary  \0';

    return buffer.byteLength >= CORRECT.length && CORRECT === convertArrayBufferToString(buffer, 0, CORRECT.length);
  }

  function isFbxFormatASCII(text) {

    var CORRECT = ['K', 'a', 'y', 'd', 'a', 'r', 'a', '\\', 'F', 'B', 'X', '\\', 'B', 'i', 'n', 'a', 'r', 'y', '\\', '\\'];

    var cursor = 0;

    function read(offset) {

      var result = text[offset - 1];
      text = text.slice(cursor + offset);
      cursor++;
      return result;
    }

    for (var i = 0; i < CORRECT.length; ++i) {

      var num = read(1);
      if (num === CORRECT[i]) {

        return false;
      }
    }

    return true;
  }

  function getFbxVersion(text) {

    var versionRegExp = /FBXVersion: (\d+)/;
    var match = text.match(versionRegExp);
    if (match) {

      var version = parseInt(match[1]);
      return version;
    }
    throw new Error('THREE.FBXLoader: Cannot find the version number for the file given.');
  }

  // Converts FBX ticks into real time seconds.
  function convertFBXTimeToSeconds(time) {

    return time / 46186158000;
  }

  // Parses comma separated list of numbers and returns them an array.
  // Used internally by the TextParser
  function parseNumberArray(value) {

    var array = value.split(',').map(function (val) {

      return parseFloat(val);
    });

    return array;
  }

  function convertArrayBufferToString(buffer, from, to) {

    if (from === undefined) from = 0;
    if (to === undefined) to = buffer.byteLength;

    return THREE.LoaderUtils.decodeText(new Uint8Array(buffer, from, to));
  }

  function append(a, b) {

    for (var i = 0, j = a.length, l = b.length; i < l; i++, j++) {

      a[j] = b[i];
    }
  }

  function slice(a, b, from, to) {

    for (var i = from, j = 0; i < to; i++, j++) {

      a[j] = b[i];
    }

    return a;
  }
})();

},{}],3:[function(require,module,exports){
'use strict';

/**
 * @author Wei Meng / http://about.me/menway
 *
 * Description: A THREE loader for PLY ASCII files (known as the Polygon File Format or the Stanford Triangle Format).
 *
 *
 * Limitations: ASCII decoding assumes file is UTF-8.
 *
 * Usage:
 *  var loader = new THREE.PLYLoader();
 *  loader.load('./models/ply/ascii/dolphins.ply', function (geometry) {
 *
 *    scene.add( new THREE.Mesh( geometry ) );
 *
 *  } );
 *
 * If the PLY file uses non standard property names, they can be mapped while
 * loading. For example, the following maps the properties
 * “diffuse_(red|green|blue)” in the file to standard color names.
 *
 * loader.setPropertyNameMapping( {
 *  diffuse_red: 'red',
 *  diffuse_green: 'green',
 *  diffuse_blue: 'blue'
 * } );
 *
 */

module.exports = THREE.PLYLoader = function (manager) {

  this.manager = manager !== undefined ? manager : THREE.DefaultLoadingManager;

  this.propertyNameMapping = {};
};

THREE.PLYLoader.prototype = {

  constructor: THREE.PLYLoader,

  load: function load(url, onLoad, onProgress, onError) {

    var scope = this;

    var loader = new THREE.XHRLoader(this.manager);
    loader.setResponseType('arraybuffer');
    loader.load(url, function (text) {

      onLoad(scope.parse(text));
    }, onProgress, onError);
  },

  setPropertyNameMapping: function setPropertyNameMapping(mapping) {

    this.propertyNameMapping = mapping;
  },

  bin2str: function bin2str(buf) {

    var array_buffer = new Uint8Array(buf);
    var str = '';
    for (var i = 0; i < buf.byteLength; i++) {

      str += String.fromCharCode(array_buffer[i]); // implicitly assumes little-endian
    }

    return str;
  },

  isASCII: function isASCII(data) {

    var header = this.parseHeader(this.bin2str(data));

    return header.format === "ascii";
  },

  parse: function parse(data) {

    if (data instanceof ArrayBuffer) {

      return this.isASCII(data) ? this.parseASCII(this.bin2str(data)) : this.parseBinary(data);
    } else {

      return this.parseASCII(data);
    }
  },

  parseHeader: function parseHeader(data) {

    var patternHeader = /ply([\s\S]*)end_header\s/;
    var headerText = "";
    var headerLength = 0;
    var result = patternHeader.exec(data);
    if (result !== null) {

      headerText = result[1];
      headerLength = result[0].length;
    }

    var header = {
      comments: [],
      elements: [],
      headerLength: headerLength
    };

    var lines = headerText.split('\n');
    var currentElement = undefined;
    var lineType, lineValues;

    function make_ply_element_property(propertValues, propertyNameMapping) {

      var property = {
        type: propertValues[0]
      };

      if (property.type === 'list') {

        property.name = propertValues[3];
        property.countType = propertValues[1];
        property.itemType = propertValues[2];
      } else {

        property.name = propertValues[1];
      }

      if (property.name in propertyNameMapping) {

        property.name = propertyNameMapping[property.name];
      }

      return property;
    }

    for (var i = 0; i < lines.length; i++) {

      var line = lines[i];
      line = line.trim();
      if (line === "") {

        continue;
      }
      lineValues = line.split(/\s+/);
      lineType = lineValues.shift();
      line = lineValues.join(" ");

      switch (lineType) {

        case "format":

          header.format = lineValues[0];
          header.version = lineValues[1];

          break;

        case "comment":

          header.comments.push(line);

          break;

        case "element":

          if (!(currentElement === undefined)) {

            header.elements.push(currentElement);
          }

          currentElement = Object();
          currentElement.name = lineValues[0];
          currentElement.count = parseInt(lineValues[1]);
          currentElement.properties = [];

          break;

        case "property":

          currentElement.properties.push(make_ply_element_property(lineValues, this.propertyNameMapping));

          break;

        default:

          console.log("unhandled", lineType, lineValues);

      }
    }

    if (!(currentElement === undefined)) {

      header.elements.push(currentElement);
    }

    return header;
  },

  parseASCIINumber: function parseASCIINumber(n, type) {

    switch (type) {

      case 'char':case 'uchar':case 'short':case 'ushort':case 'int':case 'uint':
      case 'int8':case 'uint8':case 'int16':case 'uint16':case 'int32':case 'uint32':

        return parseInt(n);

      case 'float':case 'double':case 'float32':case 'float64':

        return parseFloat(n);

    }
  },

  parseASCIIElement: function parseASCIIElement(properties, line) {

    var values = line.split(/\s+/);

    var element = Object();

    for (var i = 0; i < properties.length; i++) {

      if (properties[i].type === "list") {

        var list = [];
        var n = this.parseASCIINumber(values.shift(), properties[i].countType);

        for (var j = 0; j < n; j++) {

          list.push(this.parseASCIINumber(values.shift(), properties[i].itemType));
        }

        element[properties[i].name] = list;
      } else {

        element[properties[i].name] = this.parseASCIINumber(values.shift(), properties[i].type);
      }
    }

    return element;
  },

  parseASCII: function parseASCII(data) {

    // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)

    var geometry = new THREE.Geometry();

    var result;

    var header = this.parseHeader(data);

    var patternBody = /end_header\s([\s\S]*)$/;
    var body = "";
    if ((result = patternBody.exec(data)) !== null) {

      body = result[1];
    }

    var lines = body.split('\n');
    var currentElement = 0;
    var currentElementCount = 0;
    geometry.useColor = false;

    for (var i = 0; i < lines.length; i++) {

      var line = lines[i];
      line = line.trim();
      if (line === "") {

        continue;
      }

      if (currentElementCount >= header.elements[currentElement].count) {

        currentElement++;
        currentElementCount = 0;
      }

      var element = this.parseASCIIElement(header.elements[currentElement].properties, line);

      this.handleElement(geometry, header.elements[currentElement].name, element);

      currentElementCount++;
    }

    return this.postProcess(geometry);
  },

  postProcess: function postProcess(geometry) {

    if (geometry.useColor) {

      for (var i = 0; i < geometry.faces.length; i++) {

        geometry.faces[i].vertexColors = [geometry.colors[geometry.faces[i].a], geometry.colors[geometry.faces[i].b], geometry.colors[geometry.faces[i].c]];
      }

      geometry.elementsNeedUpdate = true;
    }

    geometry.computeBoundingSphere();

    return geometry;
  },

  handleElement: function handleElement(geometry, elementName, element) {

    if (elementName === "vertex") {

      geometry.vertices.push(new THREE.Vector3(element.x, element.y, element.z));

      if ('red' in element && 'green' in element && 'blue' in element) {

        geometry.useColor = true;

        var color = new THREE.Color();
        color.setRGB(element.red / 255.0, element.green / 255.0, element.blue / 255.0);
        geometry.colors.push(color);
      }
    } else if (elementName === "face") {

      // BEGIN: Edits by donmccurdy.
      var vertex_indices = element.vertex_indices || element.vertex_index;
      // END: Edits by donmccurdy.

      if (vertex_indices.length === 3) {

        geometry.faces.push(new THREE.Face3(vertex_indices[0], vertex_indices[1], vertex_indices[2]));
      } else if (vertex_indices.length === 4) {

        geometry.faces.push(new THREE.Face3(vertex_indices[0], vertex_indices[1], vertex_indices[3]), new THREE.Face3(vertex_indices[1], vertex_indices[2], vertex_indices[3]));
      }
    }
  },

  binaryRead: function binaryRead(dataview, at, type, little_endian) {

    switch (type) {

      // corespondences for non-specific length types here match rply:
      case 'int8':case 'char':
        return [dataview.getInt8(at), 1];

      case 'uint8':case 'uchar':
        return [dataview.getUint8(at), 1];

      case 'int16':case 'short':
        return [dataview.getInt16(at, little_endian), 2];

      case 'uint16':case 'ushort':
        return [dataview.getUint16(at, little_endian), 2];

      case 'int32':case 'int':
        return [dataview.getInt32(at, little_endian), 4];

      case 'uint32':case 'uint':
        return [dataview.getUint32(at, little_endian), 4];

      case 'float32':case 'float':
        return [dataview.getFloat32(at, little_endian), 4];

      case 'float64':case 'double':
        return [dataview.getFloat64(at, little_endian), 8];

    }
  },

  binaryReadElement: function binaryReadElement(dataview, at, properties, little_endian) {

    var element = Object();
    var result,
        read = 0;

    for (var i = 0; i < properties.length; i++) {

      if (properties[i].type === "list") {

        var list = [];

        result = this.binaryRead(dataview, at + read, properties[i].countType, little_endian);
        var n = result[0];
        read += result[1];

        for (var j = 0; j < n; j++) {

          result = this.binaryRead(dataview, at + read, properties[i].itemType, little_endian);
          list.push(result[0]);
          read += result[1];
        }

        element[properties[i].name] = list;
      } else {

        result = this.binaryRead(dataview, at + read, properties[i].type, little_endian);
        element[properties[i].name] = result[0];
        read += result[1];
      }
    }

    return [element, read];
  },

  parseBinary: function parseBinary(data) {

    var geometry = new THREE.Geometry();

    var header = this.parseHeader(this.bin2str(data));
    var little_endian = header.format === "binary_little_endian";
    var body = new DataView(data, header.headerLength);
    var result,
        loc = 0;

    for (var currentElement = 0; currentElement < header.elements.length; currentElement++) {

      for (var currentElementCount = 0; currentElementCount < header.elements[currentElement].count; currentElementCount++) {

        result = this.binaryReadElement(body, loc, header.elements[currentElement].properties, little_endian);
        loc += result[1];
        var element = result[0];

        this.handleElement(geometry, header.elements[currentElement].name, element);
      }
    }

    return this.postProcess(geometry);
  }

};

},{}],4:[function(require,module,exports){
'use strict';

/**
 * Source: https://github.com/Adobe-Marketing-Cloud/fetch-script
 */

function getScriptId() {
  return 'script_' + Date.now() + '_' + Math.ceil(Math.random() * 100000);
}

function createScript(url, id) {
  var script = document.createElement('script');
  script.type = 'text/javascript';
  script.async = true;
  script.id = id;
  script.src = url;

  return script;
}

function removeScript(id) {
  var script = document.getElementById(id);
  var parent = script.parentNode;

  try {
    parent && parent.removeChild(script);
  } catch (e) {
    // ignore
  }
}

function appendScript(script) {
  var firstScript = document.getElementsByTagName('script')[0];
  firstScript.parentNode.insertBefore(script, firstScript);
}

function fetchScriptInternal(url, options, Promise) {
  return new Promise(function (resolve, reject) {
    var timeout = options.timeout || 5000;
    var scriptId = getScriptId();
    var script = createScript(url, scriptId);

    var timeoutId = setTimeout(function () {
      reject(new Error('Script request to ' + url + ' timed out'));

      removeScript(scriptId);
    }, timeout);

    var disableTimeout = function disableTimeout(timeoutId) {
      clearTimeout(timeoutId);
    };

    script.addEventListener('load', function (e) {
      resolve({ ok: true });

      disableTimeout(timeoutId);
      removeScript(scriptId);
    });

    script.addEventListener('error', function (e) {
      reject(new Error('Script request to ' + url + ' failed ' + e));

      disableTimeout(timeoutId);
      removeScript(scriptId);
    });

    appendScript(script);
  });
}

function fetchScript(settings) {
  settings = settings || {};
  return function (url, options) {
    options = options || {};
    return fetchScriptInternal(url, options, settings.Promise || Promise);
  };
}

module.exports = fetchScript;

},{}],5:[function(require,module,exports){
'use strict';

var LoopMode = {
  once: THREE.LoopOnce,
  repeat: THREE.LoopRepeat,
  pingpong: THREE.LoopPingPong
};

/**
 * animation-mixer
 *
 * Player for animation clips. Intended to be compatible with any model format that supports
 * skeletal or morph animations through THREE.AnimationMixer.
 * See: https://threejs.org/docs/?q=animation#Reference/Animation/AnimationMixer
 */
module.exports = AFRAME.registerComponent('animation-mixer', {
  schema: {
    clip: { default: '*' },
    duration: { default: 0 },
    clampWhenFinished: { default: false, type: 'boolean' },
    crossFadeDuration: { default: 0 },
    loop: { default: 'repeat', oneOf: Object.keys(LoopMode) },
    repetitions: { default: Infinity, min: 0 }
  },

  init: function init() {
    var _this = this;

    /** @type {THREE.Mesh} */
    this.model = null;
    /** @type {THREE.AnimationMixer} */
    this.mixer = null;
    /** @type {Array<THREE.AnimationAction>} */
    this.activeActions = [];

    var model = this.el.getObject3D('mesh');

    if (model) {
      this.load(model);
    } else {
      this.el.addEventListener('model-loaded', function (e) {
        _this.load(e.detail.model);
      });
    }
  },

  load: function load(model) {
    var el = this.el;
    this.model = model;
    this.mixer = new THREE.AnimationMixer(model);
    this.mixer.addEventListener('loop', function (e) {
      el.emit('animation-loop', { action: e.action, loopDelta: e.loopDelta });
    });
    this.mixer.addEventListener('finished', function (e) {
      el.emit('animation-finished', { action: e.action, direction: e.direction });
    });
    if (this.data.clip) this.update({});
  },

  remove: function remove() {
    if (this.mixer) this.mixer.stopAllAction();
  },

  update: function update(previousData) {
    if (!previousData) return;

    this.stopAction();

    if (this.data.clip) {
      this.playAction();
    }
  },

  stopAction: function stopAction() {
    var data = this.data;
    for (var i = 0; i < this.activeActions.length; i++) {
      data.crossFadeDuration ? this.activeActions[i].fadeOut(data.crossFadeDuration) : this.activeActions[i].stop();
    }
    this.activeActions.length = 0;
  },

  playAction: function playAction() {
    if (!this.mixer) return;

    var model = this.model,
        data = this.data,
        clips = model.animations || (model.geometry || {}).animations || [];

    if (!clips.length) return;

    var re = wildcardToRegExp(data.clip);

    for (var clip, i = 0; clip = clips[i]; i++) {
      if (clip.name.match(re)) {
        var action = this.mixer.clipAction(clip, model);
        action.enabled = true;
        action.clampWhenFinished = data.clampWhenFinished;
        if (data.duration) action.setDuration(data.duration);
        action.setLoop(LoopMode[data.loop], data.repetitions).fadeIn(data.crossFadeDuration).play();
        this.activeActions.push(action);
      }
    }
  },

  tick: function tick(t, dt) {
    if (this.mixer && !isNaN(dt)) this.mixer.update(dt / 1000);
  }
});

/**
 * Creates a RegExp from the given string, converting asterisks to .* expressions,
 * and escaping all other characters.
 */
function wildcardToRegExp(s) {
  return new RegExp('^' + s.split(/\*+/).map(regExpEscape).join('.*') + '$');
}

/**
 * RegExp-escapes all characters in the given string.
 */
function regExpEscape(s) {
  return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
}

},{}],6:[function(require,module,exports){
'use strict';

THREE.FBXLoader = require('../../lib/FBXLoader');

/**
 * fbx-model
 *
 * Loader for FBX format. Supports ASCII, but *not* binary, models.
 */
module.exports = AFRAME.registerComponent('fbx-model', {
  schema: {
    src: { type: 'asset' },
    crossorigin: { default: '' }
  },

  init: function init() {
    this.model = null;
  },

  update: function update() {
    var data = this.data;
    if (!data.src) return;

    this.remove();
    var loader = new THREE.FBXLoader();
    if (data.crossorigin) loader.setCrossOrigin(data.crossorigin);
    loader.load(data.src, this.load.bind(this));
  },

  load: function load(model) {
    this.model = model;
    this.el.setObject3D('mesh', model);
    this.el.emit('model-loaded', { format: 'fbx', model: model });
  },

  remove: function remove() {
    if (this.model) this.el.removeObject3D('mesh');
  }
});

},{"../../lib/FBXLoader":2}],7:[function(require,module,exports){
'use strict';

var fetchScript = require('../../lib/fetch-script')();

var LOADER_SRC = 'https://rawgit.com/mrdoob/three.js/r86/examples/js/loaders/GLTFLoader.js';

var loadLoader = function () {
  var promise = void 0;
  return function () {
    promise = promise || fetchScript(LOADER_SRC);
    return promise;
  };
}();

/**
 * Legacy loader for glTF 1.0 models.
 * Asynchronously loads THREE.GLTFLoader from rawgit.
 */
module.exports = AFRAME.registerComponent('gltf-model-legacy', {
  schema: { type: 'model' },

  init: function init() {
    var _this = this;

    this.model = null;
    this.loader = null;
    this.loaderPromise = loadLoader().then(function () {
      _this.loader = new THREE.GLTFLoader();
      _this.loader.setCrossOrigin('Anonymous');
    });
  },

  update: function update() {
    var _this2 = this;

    var self = this;
    var el = this.el;
    var src = this.data;

    if (!src) {
      return;
    }

    this.remove();

    this.loaderPromise.then(function () {
      _this2.loader.load(src, function gltfLoaded(gltfModel) {
        self.model = gltfModel.scene;
        self.model.animations = gltfModel.animations;
        el.setObject3D('mesh', self.model);
        el.emit('model-loaded', { format: 'gltf', model: self.model });
      });
    });
  },

  remove: function remove() {
    if (!this.model) {
      return;
    }
    this.el.removeObject3D('mesh');
  }
});

},{"../../lib/fetch-script":4}],8:[function(require,module,exports){
'use strict';

require('./animation-mixer');
require('./fbx-model');
require('./gltf-model-legacy');
require('./json-model');
require('./object-model');
require('./ply-model');

},{"./animation-mixer":5,"./fbx-model":6,"./gltf-model-legacy":7,"./json-model":9,"./object-model":10,"./ply-model":11}],9:[function(require,module,exports){
'use strict';

/**
 * json-model
 *
 * Loader for THREE.js JSON format. Somewhat confusingly, there are two different THREE.js formats,
 * both having the .json extension. This loader supports only THREE.JsonLoader, which typically
 * includes only a single mesh.
 *
 * Check the console for errors, if in doubt. You may need to use `object-model` or
 * `blend-character-model` for some .js and .json files.
 *
 * See: https://clara.io/learn/user-guide/data_exchange/threejs_export
 */

module.exports = AFRAME.registerComponent('json-model', {
  schema: {
    src: { type: 'asset' },
    crossorigin: { default: '' }
  },

  init: function init() {
    this.model = null;
  },

  update: function update() {
    var _this = this;

    var loader = void 0;
    var data = this.data;
    if (!data.src) return;

    this.remove();
    loader = new THREE.JSONLoader();
    if (data.crossorigin) loader.crossOrigin = data.crossorigin;
    loader.load(data.src, function (geometry, materials) {

      // Attempt to automatically detect common material options.
      materials.forEach(function (mat) {
        mat.vertexColors = (geometry.faces[0] || {}).color ? THREE.FaceColors : THREE.NoColors;
        mat.skinning = !!(geometry.bones || []).length;
        mat.morphTargets = !!(geometry.morphTargets || []).length;
        mat.morphNormals = !!(geometry.morphNormals || []).length;
      });

      var model = (geometry.bones || []).length ? new THREE.SkinnedMesh(geometry, new THREE.MultiMaterial(materials)) : new THREE.Mesh(geometry, new THREE.MultiMaterial(materials));

      _this.load(model);
    });
  },

  load: function load(model) {
    this.model = model;
    this.el.setObject3D('mesh', model);
    this.el.emit('model-loaded', { format: 'json', model: model });
  },

  remove: function remove() {
    if (this.model) this.el.removeObject3D('mesh');
  }
});

},{}],10:[function(require,module,exports){
'use strict';

/**
 * object-model
 *
 * Loader for THREE.js JSON format. Somewhat confusingly, there are two different THREE.js formats,
 * both having the .json extension. This loader supports only THREE.ObjectLoader, which typically
 * includes multiple meshes or an entire scene.
 *
 * Check the console for errors, if in doubt. You may need to use `json-model` or
 * `blend-character-model` for some .js and .json files.
 *
 * See: https://clara.io/learn/user-guide/data_exchange/threejs_export
 */

module.exports = AFRAME.registerComponent('object-model', {
  schema: {
    src: { type: 'asset' },
    crossorigin: { default: '' }
  },

  init: function init() {
    this.model = null;
  },

  update: function update() {
    var _this = this;

    var loader = void 0;
    var data = this.data;
    if (!data.src) return;

    this.remove();
    loader = new THREE.ObjectLoader();
    if (data.crossorigin) loader.setCrossOrigin(data.crossorigin);
    loader.load(data.src, function (object) {

      // Enable skinning, if applicable.
      object.traverse(function (o) {
        if (o instanceof THREE.SkinnedMesh && o.material) {
          o.material.skinning = !!(o.geometry && o.geometry.bones || []).length;
        }
      });

      _this.load(object);
    });
  },

  load: function load(model) {
    this.model = model;
    this.el.setObject3D('mesh', model);
    this.el.emit('model-loaded', { format: 'json', model: model });
  },

  remove: function remove() {
    if (this.model) this.el.removeObject3D('mesh');
  }
});

},{}],11:[function(require,module,exports){
'use strict';

/**
 * ply-model
 *
 * Wraps THREE.PLYLoader.
 */

THREE.PLYLoader = require('../../lib/PLYLoader');

/**
 * Loads, caches, resolves geometries.
 *
 * @member cache - Promises that resolve geometries keyed by `src`.
 */
module.exports.System = AFRAME.registerSystem('ply-model', {
  init: function init() {
    this.cache = {};
  },

  /**
   * @returns {Promise}
   */
  getOrLoadGeometry: function getOrLoadGeometry(src, skipCache) {
    var cache = this.cache;
    var cacheItem = cache[src];

    if (!skipCache && cacheItem) {
      return cacheItem;
    }

    cache[src] = new Promise(function (resolve) {
      var loader = new THREE.PLYLoader();
      loader.load(src, function (geometry) {
        resolve(geometry);
      });
    });
    return cache[src];
  }
});

module.exports.Component = AFRAME.registerComponent('ply-model', {
  schema: {
    skipCache: { type: 'boolean', default: false },
    src: { type: 'asset' }
  },

  init: function init() {
    this.model = null;
  },

  update: function update() {
    var data = this.data;
    var el = this.el;

    if (!data.src) {
      console.warn('[%s] `src` property is required.', this.name);
      return;
    }

    // Get geometry from system, create and set mesh.
    this.system.getOrLoadGeometry(data.src, data.skipCache).then(function (geometry) {
      var model = createModel(geometry);
      el.setObject3D('mesh', model);
      el.emit('model-loaded', { format: 'ply', model: model });
    });
  },

  remove: function remove() {
    if (this.model) {
      this.el.removeObject3D('mesh');
    }
  }
});

function createModel(geometry) {
  return new THREE.Mesh(geometry, new THREE.MeshPhongMaterial({
    color: 0xFFFFFF,
    shading: THREE.FlatShading,
    vertexColors: THREE.VertexColors,
    shininess: 0
  }));
}

},{"../../lib/PLYLoader":3}]},{},[1]);