opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/ColladaLoader.js

@@ -0,0 +1,3046 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../loaders/TGALoader.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../loaders/TGALoader.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.TGALoader);
+    global.ColladaLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _TGALoader) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ColladaLoader = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var ColladaLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(ColladaLoader, _Loader);
+
+    var _super = _createSuper(ColladaLoader);
+
+    function ColladaLoader(manager) {
+      _classCallCheck(this, ColladaLoader);
+
+      return _super.call(this, manager);
+    }
+
+    _createClass(ColladaLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var path = scope.path === '' ? _three.LoaderUtils.extractUrlBase(url) : scope.path;
+        var loader = new _three.FileLoader(scope.manager);
+        loader.setPath(scope.path);
+        loader.setRequestHeader(scope.requestHeader);
+        loader.setWithCredentials(scope.withCredentials);
+        loader.load(url, function (text) {
+          try {
+            onLoad(scope.parse(text, path));
+          } catch (e) {
+            if (onError) {
+              onError(e);
+            } else {
+              console.error(e);
+            }
+
+            scope.manager.itemError(url);
+          }
+        }, onProgress, onError);
+      }
+    }, {
+      key: "parse",
+      value: function parse(text, path) {
+        function getElementsByTagName(xml, name) {
+          // Non recursive xml.getElementsByTagName() ...
+          var array = [];
+          var childNodes = xml.childNodes;
+
+          for (var i = 0, l = childNodes.length; i < l; i++) {
+            var child = childNodes[i];
+
+            if (child.nodeName === name) {
+              array.push(child);
+            }
+          }
+
+          return array;
+        }
+
+        function parseStrings(text) {
+          if (text.length === 0) return [];
+          var parts = text.trim().split(/\s+/);
+          var array = new Array(parts.length);
+
+          for (var i = 0, l = parts.length; i < l; i++) {
+            array[i] = parts[i];
+          }
+
+          return array;
+        }
+
+        function parseFloats(text) {
+          if (text.length === 0) return [];
+          var parts = text.trim().split(/\s+/);
+          var array = new Array(parts.length);
+
+          for (var i = 0, l = parts.length; i < l; i++) {
+            array[i] = parseFloat(parts[i]);
+          }
+
+          return array;
+        }
+
+        function parseInts(text) {
+          if (text.length === 0) return [];
+          var parts = text.trim().split(/\s+/);
+          var array = new Array(parts.length);
+
+          for (var i = 0, l = parts.length; i < l; i++) {
+            array[i] = parseInt(parts[i]);
+          }
+
+          return array;
+        }
+
+        function parseId(text) {
+          return text.substring(1);
+        }
+
+        function generateId() {
+          return 'three_default_' + count++;
+        }
+
+        function isEmpty(object) {
+          return Object.keys(object).length === 0;
+        } // asset
+
+
+        function parseAsset(xml) {
+          return {
+            unit: parseAssetUnit(getElementsByTagName(xml, 'unit')[0]),
+            upAxis: parseAssetUpAxis(getElementsByTagName(xml, 'up_axis')[0])
+          };
+        }
+
+        function parseAssetUnit(xml) {
+          if (xml !== undefined && xml.hasAttribute('meter') === true) {
+            return parseFloat(xml.getAttribute('meter'));
+          } else {
+            return 1; // default 1 meter
+          }
+        }
+
+        function parseAssetUpAxis(xml) {
+          return xml !== undefined ? xml.textContent : 'Y_UP';
+        } // library
+
+
+        function parseLibrary(xml, libraryName, nodeName, parser) {
+          var library = getElementsByTagName(xml, libraryName)[0];
+
+          if (library !== undefined) {
+            var elements = getElementsByTagName(library, nodeName);
+
+            for (var i = 0; i < elements.length; i++) {
+              parser(elements[i]);
+            }
+          }
+        }
+
+        function buildLibrary(data, builder) {
+          for (var name in data) {
+            var object = data[name];
+            object.build = builder(data[name]);
+          }
+        } // get
+
+
+        function getBuild(data, builder) {
+          if (data.build !== undefined) return data.build;
+          data.build = builder(data);
+          return data.build;
+        } // animation
+
+
+        function parseAnimation(xml) {
+          var data = {
+            sources: {},
+            samplers: {},
+            channels: {}
+          };
+          var hasChildren = false;
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+            var id = void 0;
+
+            switch (child.nodeName) {
+              case 'source':
+                id = child.getAttribute('id');
+                data.sources[id] = parseSource(child);
+                break;
+
+              case 'sampler':
+                id = child.getAttribute('id');
+                data.samplers[id] = parseAnimationSampler(child);
+                break;
+
+              case 'channel':
+                id = child.getAttribute('target');
+                data.channels[id] = parseAnimationChannel(child);
+                break;
+
+              case 'animation':
+                // hierarchy of related animations
+                parseAnimation(child);
+                hasChildren = true;
+                break;
+
+              default:
+                console.log(child);
+            }
+          }
+
+          if (hasChildren === false) {
+            // since 'id' attributes can be optional, it's necessary to generate a UUID for unqiue assignment
+            library.animations[xml.getAttribute('id') || _three.MathUtils.generateUUID()] = data;
+          }
+        }
+
+        function parseAnimationSampler(xml) {
+          var data = {
+            inputs: {}
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'input':
+                var id = parseId(child.getAttribute('source'));
+                var semantic = child.getAttribute('semantic');
+                data.inputs[semantic] = id;
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseAnimationChannel(xml) {
+          var data = {};
+          var target = xml.getAttribute('target'); // parsing SID Addressing Syntax
+
+          var parts = target.split('/');
+          var id = parts.shift();
+          var sid = parts.shift(); // check selection syntax
+
+          var arraySyntax = sid.indexOf('(') !== -1;
+          var memberSyntax = sid.indexOf('.') !== -1;
+
+          if (memberSyntax) {
+            //  member selection access
+            parts = sid.split('.');
+            sid = parts.shift();
+            data.member = parts.shift();
+          } else if (arraySyntax) {
+            // array-access syntax. can be used to express fields in one-dimensional vectors or two-dimensional matrices.
+            var indices = sid.split('(');
+            sid = indices.shift();
+
+            for (var i = 0; i < indices.length; i++) {
+              indices[i] = parseInt(indices[i].replace(/\)/, ''));
+            }
+
+            data.indices = indices;
+          }
+
+          data.id = id;
+          data.sid = sid;
+          data.arraySyntax = arraySyntax;
+          data.memberSyntax = memberSyntax;
+          data.sampler = parseId(xml.getAttribute('source'));
+          return data;
+        }
+
+        function buildAnimation(data) {
+          var tracks = [];
+          var channels = data.channels;
+          var samplers = data.samplers;
+          var sources = data.sources;
+
+          for (var target in channels) {
+            if (channels.hasOwnProperty(target)) {
+              var channel = channels[target];
+              var sampler = samplers[channel.sampler];
+              var inputId = sampler.inputs.INPUT;
+              var outputId = sampler.inputs.OUTPUT;
+              var inputSource = sources[inputId];
+              var outputSource = sources[outputId];
+              var animation = buildAnimationChannel(channel, inputSource, outputSource);
+              createKeyframeTracks(animation, tracks);
+            }
+          }
+
+          return tracks;
+        }
+
+        function getAnimation(id) {
+          return getBuild(library.animations[id], buildAnimation);
+        }
+
+        function buildAnimationChannel(channel, inputSource, outputSource) {
+          var node = library.nodes[channel.id];
+          var object3D = getNode(node.id);
+          var transform = node.transforms[channel.sid];
+          var defaultMatrix = node.matrix.clone().transpose();
+          var time, stride;
+          var i, il, j, jl;
+          var data = {}; // the collada spec allows the animation of data in various ways.
+          // depending on the transform type (matrix, translate, rotate, scale), we execute different logic
+
+          switch (transform) {
+            case 'matrix':
+              for (i = 0, il = inputSource.array.length; i < il; i++) {
+                time = inputSource.array[i];
+                stride = i * outputSource.stride;
+                if (data[time] === undefined) data[time] = {};
+
+                if (channel.arraySyntax === true) {
+                  var value = outputSource.array[stride];
+                  var index = channel.indices[0] + 4 * channel.indices[1];
+                  data[time][index] = value;
+                } else {
+                  for (j = 0, jl = outputSource.stride; j < jl; j++) {
+                    data[time][j] = outputSource.array[stride + j];
+                  }
+                }
+              }
+
+              break;
+
+            case 'translate':
+              console.warn('THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform);
+              break;
+
+            case 'rotate':
+              console.warn('THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform);
+              break;
+
+            case 'scale':
+              console.warn('THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform);
+              break;
+          }
+
+          var keyframes = prepareAnimationData(data, defaultMatrix);
+          var animation = {
+            name: object3D.uuid,
+            keyframes: keyframes
+          };
+          return animation;
+        }
+
+        function prepareAnimationData(data, defaultMatrix) {
+          var keyframes = []; // transfer data into a sortable array
+
+          for (var time in data) {
+            keyframes.push({
+              time: parseFloat(time),
+              value: data[time]
+            });
+          } // ensure keyframes are sorted by time
+
+
+          keyframes.sort(ascending); // now we clean up all animation data, so we can use them for keyframe tracks
+
+          for (var i = 0; i < 16; i++) {
+            transformAnimationData(keyframes, i, defaultMatrix.elements[i]);
+          }
+
+          return keyframes; // array sort function
+
+          function ascending(a, b) {
+            return a.time - b.time;
+          }
+        }
+
+        var position = new _three.Vector3();
+        var scale = new _three.Vector3();
+        var quaternion = new _three.Quaternion();
+
+        function createKeyframeTracks(animation, tracks) {
+          var keyframes = animation.keyframes;
+          var name = animation.name;
+          var times = [];
+          var positionData = [];
+          var quaternionData = [];
+          var scaleData = [];
+
+          for (var i = 0, l = keyframes.length; i < l; i++) {
+            var keyframe = keyframes[i];
+            var time = keyframe.time;
+            var value = keyframe.value;
+            matrix.fromArray(value).transpose();
+            matrix.decompose(position, quaternion, scale);
+            times.push(time);
+            positionData.push(position.x, position.y, position.z);
+            quaternionData.push(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+            scaleData.push(scale.x, scale.y, scale.z);
+          }
+
+          if (positionData.length > 0) tracks.push(new _three.VectorKeyframeTrack(name + '.position', times, positionData));
+          if (quaternionData.length > 0) tracks.push(new _three.QuaternionKeyframeTrack(name + '.quaternion', times, quaternionData));
+          if (scaleData.length > 0) tracks.push(new _three.VectorKeyframeTrack(name + '.scale', times, scaleData));
+          return tracks;
+        }
+
+        function transformAnimationData(keyframes, property, defaultValue) {
+          var keyframe;
+          var empty = true;
+          var i, l; // check, if values of a property are missing in our keyframes
+
+          for (i = 0, l = keyframes.length; i < l; i++) {
+            keyframe = keyframes[i];
+
+            if (keyframe.value[property] === undefined) {
+              keyframe.value[property] = null; // mark as missing
+            } else {
+              empty = false;
+            }
+          }
+
+          if (empty === true) {
+            // no values at all, so we set a default value
+            for (i = 0, l = keyframes.length; i < l; i++) {
+              keyframe = keyframes[i];
+              keyframe.value[property] = defaultValue;
+            }
+          } else {
+            // filling gaps
+            createMissingKeyframes(keyframes, property);
+          }
+        }
+
+        function createMissingKeyframes(keyframes, property) {
+          var prev, next;
+
+          for (var i = 0, l = keyframes.length; i < l; i++) {
+            var keyframe = keyframes[i];
+
+            if (keyframe.value[property] === null) {
+              prev = getPrev(keyframes, i, property);
+              next = getNext(keyframes, i, property);
+
+              if (prev === null) {
+                keyframe.value[property] = next.value[property];
+                continue;
+              }
+
+              if (next === null) {
+                keyframe.value[property] = prev.value[property];
+                continue;
+              }
+
+              interpolate(keyframe, prev, next, property);
+            }
+          }
+        }
+
+        function getPrev(keyframes, i, property) {
+          while (i >= 0) {
+            var keyframe = keyframes[i];
+            if (keyframe.value[property] !== null) return keyframe;
+            i--;
+          }
+
+          return null;
+        }
+
+        function getNext(keyframes, i, property) {
+          while (i < keyframes.length) {
+            var keyframe = keyframes[i];
+            if (keyframe.value[property] !== null) return keyframe;
+            i++;
+          }
+
+          return null;
+        }
+
+        function interpolate(key, prev, next, property) {
+          if (next.time - prev.time === 0) {
+            key.value[property] = prev.value[property];
+            return;
+          }
+
+          key.value[property] = (key.time - prev.time) * (next.value[property] - prev.value[property]) / (next.time - prev.time) + prev.value[property];
+        } // animation clips
+
+
+        function parseAnimationClip(xml) {
+          var data = {
+            name: xml.getAttribute('id') || 'default',
+            start: parseFloat(xml.getAttribute('start') || 0),
+            end: parseFloat(xml.getAttribute('end') || 0),
+            animations: []
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'instance_animation':
+                data.animations.push(parseId(child.getAttribute('url')));
+                break;
+            }
+          }
+
+          library.clips[xml.getAttribute('id')] = data;
+        }
+
+        function buildAnimationClip(data) {
+          var tracks = [];
+          var name = data.name;
+          var duration = data.end - data.start || -1;
+          var animations = data.animations;
+
+          for (var i = 0, il = animations.length; i < il; i++) {
+            var animationTracks = getAnimation(animations[i]);
+
+            for (var j = 0, jl = animationTracks.length; j < jl; j++) {
+              tracks.push(animationTracks[j]);
+            }
+          }
+
+          return new _three.AnimationClip(name, duration, tracks);
+        }
+
+        function getAnimationClip(id) {
+          return getBuild(library.clips[id], buildAnimationClip);
+        } // controller
+
+
+        function parseController(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'skin':
+                // there is exactly one skin per controller
+                data.id = parseId(child.getAttribute('source'));
+                data.skin = parseSkin(child);
+                break;
+
+              case 'morph':
+                data.id = parseId(child.getAttribute('source'));
+                console.warn('THREE.ColladaLoader: Morph target animation not supported yet.');
+                break;
+            }
+          }
+
+          library.controllers[xml.getAttribute('id')] = data;
+        }
+
+        function parseSkin(xml) {
+          var data = {
+            sources: {}
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'bind_shape_matrix':
+                data.bindShapeMatrix = parseFloats(child.textContent);
+                break;
+
+              case 'source':
+                var id = child.getAttribute('id');
+                data.sources[id] = parseSource(child);
+                break;
+
+              case 'joints':
+                data.joints = parseJoints(child);
+                break;
+
+              case 'vertex_weights':
+                data.vertexWeights = parseVertexWeights(child);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseJoints(xml) {
+          var data = {
+            inputs: {}
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'input':
+                var semantic = child.getAttribute('semantic');
+                var id = parseId(child.getAttribute('source'));
+                data.inputs[semantic] = id;
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseVertexWeights(xml) {
+          var data = {
+            inputs: {}
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'input':
+                var semantic = child.getAttribute('semantic');
+                var id = parseId(child.getAttribute('source'));
+                var offset = parseInt(child.getAttribute('offset'));
+                data.inputs[semantic] = {
+                  id: id,
+                  offset: offset
+                };
+                break;
+
+              case 'vcount':
+                data.vcount = parseInts(child.textContent);
+                break;
+
+              case 'v':
+                data.v = parseInts(child.textContent);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function buildController(data) {
+          var build = {
+            id: data.id
+          };
+          var geometry = library.geometries[build.id];
+
+          if (data.skin !== undefined) {
+            build.skin = buildSkin(data.skin); // we enhance the 'sources' property of the corresponding geometry with our skin data
+
+            geometry.sources.skinIndices = build.skin.indices;
+            geometry.sources.skinWeights = build.skin.weights;
+          }
+
+          return build;
+        }
+
+        function buildSkin(data) {
+          var BONE_LIMIT = 4;
+          var build = {
+            joints: [],
+            // this must be an array to preserve the joint order
+            indices: {
+              array: [],
+              stride: BONE_LIMIT
+            },
+            weights: {
+              array: [],
+              stride: BONE_LIMIT
+            }
+          };
+          var sources = data.sources;
+          var vertexWeights = data.vertexWeights;
+          var vcount = vertexWeights.vcount;
+          var v = vertexWeights.v;
+          var jointOffset = vertexWeights.inputs.JOINT.offset;
+          var weightOffset = vertexWeights.inputs.WEIGHT.offset;
+          var jointSource = data.sources[data.joints.inputs.JOINT];
+          var inverseSource = data.sources[data.joints.inputs.INV_BIND_MATRIX];
+          var weights = sources[vertexWeights.inputs.WEIGHT.id].array;
+          var stride = 0;
+          var i, j, l; // procces skin data for each vertex
+
+          for (i = 0, l = vcount.length; i < l; i++) {
+            var jointCount = vcount[i]; // this is the amount of joints that affect a single vertex
+
+            var vertexSkinData = [];
+
+            for (j = 0; j < jointCount; j++) {
+              var skinIndex = v[stride + jointOffset];
+              var weightId = v[stride + weightOffset];
+              var skinWeight = weights[weightId];
+              vertexSkinData.push({
+                index: skinIndex,
+                weight: skinWeight
+              });
+              stride += 2;
+            } // we sort the joints in descending order based on the weights.
+            // this ensures, we only procced the most important joints of the vertex
+
+
+            vertexSkinData.sort(descending); // now we provide for each vertex a set of four index and weight values.
+            // the order of the skin data matches the order of vertices
+
+            for (j = 0; j < BONE_LIMIT; j++) {
+              var d = vertexSkinData[j];
+
+              if (d !== undefined) {
+                build.indices.array.push(d.index);
+                build.weights.array.push(d.weight);
+              } else {
+                build.indices.array.push(0);
+                build.weights.array.push(0);
+              }
+            }
+          } // setup bind matrix
+
+
+          if (data.bindShapeMatrix) {
+            build.bindMatrix = new _three.Matrix4().fromArray(data.bindShapeMatrix).transpose();
+          } else {
+            build.bindMatrix = new _three.Matrix4().identity();
+          } // process bones and inverse bind matrix data
+
+
+          for (i = 0, l = jointSource.array.length; i < l; i++) {
+            var name = jointSource.array[i];
+            var boneInverse = new _three.Matrix4().fromArray(inverseSource.array, i * inverseSource.stride).transpose();
+            build.joints.push({
+              name: name,
+              boneInverse: boneInverse
+            });
+          }
+
+          return build; // array sort function
+
+          function descending(a, b) {
+            return b.weight - a.weight;
+          }
+        }
+
+        function getController(id) {
+          return getBuild(library.controllers[id], buildController);
+        } // image
+
+
+        function parseImage(xml) {
+          var data = {
+            init_from: getElementsByTagName(xml, 'init_from')[0].textContent
+          };
+          library.images[xml.getAttribute('id')] = data;
+        }
+
+        function buildImage(data) {
+          if (data.build !== undefined) return data.build;
+          return data.init_from;
+        }
+
+        function getImage(id) {
+          var data = library.images[id];
+
+          if (data !== undefined) {
+            return getBuild(data, buildImage);
+          }
+
+          console.warn('THREE.ColladaLoader: Couldn\'t find image with ID:', id);
+          return null;
+        } // effect
+
+
+        function parseEffect(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'profile_COMMON':
+                data.profile = parseEffectProfileCOMMON(child);
+                break;
+            }
+          }
+
+          library.effects[xml.getAttribute('id')] = data;
+        }
+
+        function parseEffectProfileCOMMON(xml) {
+          var data = {
+            surfaces: {},
+            samplers: {}
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'newparam':
+                parseEffectNewparam(child, data);
+                break;
+
+              case 'technique':
+                data.technique = parseEffectTechnique(child);
+                break;
+
+              case 'extra':
+                data.extra = parseEffectExtra(child);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectNewparam(xml, data) {
+          var sid = xml.getAttribute('sid');
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'surface':
+                data.surfaces[sid] = parseEffectSurface(child);
+                break;
+
+              case 'sampler2D':
+                data.samplers[sid] = parseEffectSampler(child);
+                break;
+            }
+          }
+        }
+
+        function parseEffectSurface(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'init_from':
+                data.init_from = child.textContent;
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectSampler(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'source':
+                data.source = child.textContent;
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectTechnique(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'constant':
+              case 'lambert':
+              case 'blinn':
+              case 'phong':
+                data.type = child.nodeName;
+                data.parameters = parseEffectParameters(child);
+                break;
+
+              case 'extra':
+                data.extra = parseEffectExtra(child);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectParameters(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'emission':
+              case 'diffuse':
+              case 'specular':
+              case 'bump':
+              case 'ambient':
+              case 'shininess':
+              case 'transparency':
+                data[child.nodeName] = parseEffectParameter(child);
+                break;
+
+              case 'transparent':
+                data[child.nodeName] = {
+                  opaque: child.getAttribute('opaque'),
+                  data: parseEffectParameter(child)
+                };
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectParameter(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'color':
+                data[child.nodeName] = parseFloats(child.textContent);
+                break;
+
+              case 'float':
+                data[child.nodeName] = parseFloat(child.textContent);
+                break;
+
+              case 'texture':
+                data[child.nodeName] = {
+                  id: child.getAttribute('texture'),
+                  extra: parseEffectParameterTexture(child)
+                };
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectParameterTexture(xml) {
+          var data = {
+            technique: {}
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'extra':
+                parseEffectParameterTextureExtra(child, data);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectParameterTextureExtra(xml, data) {
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'technique':
+                parseEffectParameterTextureExtraTechnique(child, data);
+                break;
+            }
+          }
+        }
+
+        function parseEffectParameterTextureExtraTechnique(xml, data) {
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'repeatU':
+              case 'repeatV':
+              case 'offsetU':
+              case 'offsetV':
+                data.technique[child.nodeName] = parseFloat(child.textContent);
+                break;
+
+              case 'wrapU':
+              case 'wrapV':
+                // some files have values for wrapU/wrapV which become NaN via parseInt
+                if (child.textContent.toUpperCase() === 'TRUE') {
+                  data.technique[child.nodeName] = 1;
+                } else if (child.textContent.toUpperCase() === 'FALSE') {
+                  data.technique[child.nodeName] = 0;
+                } else {
+                  data.technique[child.nodeName] = parseInt(child.textContent);
+                }
+
+                break;
+
+              case 'bump':
+                data[child.nodeName] = parseEffectExtraTechniqueBump(child);
+                break;
+            }
+          }
+        }
+
+        function parseEffectExtra(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'technique':
+                data.technique = parseEffectExtraTechnique(child);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectExtraTechnique(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'double_sided':
+                data[child.nodeName] = parseInt(child.textContent);
+                break;
+
+              case 'bump':
+                data[child.nodeName] = parseEffectExtraTechniqueBump(child);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseEffectExtraTechniqueBump(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'texture':
+                data[child.nodeName] = {
+                  id: child.getAttribute('texture'),
+                  texcoord: child.getAttribute('texcoord'),
+                  extra: parseEffectParameterTexture(child)
+                };
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function buildEffect(data) {
+          return data;
+        }
+
+        function getEffect(id) {
+          return getBuild(library.effects[id], buildEffect);
+        } // material
+
+
+        function parseMaterial(xml) {
+          var data = {
+            name: xml.getAttribute('name')
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'instance_effect':
+                data.url = parseId(child.getAttribute('url'));
+                break;
+            }
+          }
+
+          library.materials[xml.getAttribute('id')] = data;
+        }
+
+        function getTextureLoader(image) {
+          var loader;
+          var extension = image.slice((image.lastIndexOf('.') - 1 >>> 0) + 2); // http://www.jstips.co/en/javascript/get-file-extension/
+
+          extension = extension.toLowerCase();
+
+          switch (extension) {
+            case 'tga':
+              loader = tgaLoader;
+              break;
+
+            default:
+              loader = textureLoader;
+          }
+
+          return loader;
+        }
+
+        function buildMaterial(data) {
+          var effect = getEffect(data.url);
+          var technique = effect.profile.technique;
+          var material;
+
+          switch (technique.type) {
+            case 'phong':
+            case 'blinn':
+              material = new _three.MeshPhongMaterial();
+              break;
+
+            case 'lambert':
+              material = new _three.MeshLambertMaterial();
+              break;
+
+            default:
+              material = new _three.MeshBasicMaterial();
+              break;
+          }
+
+          material.name = data.name || '';
+
+          function getTexture(textureObject) {
+            var sampler = effect.profile.samplers[textureObject.id];
+            var image = null; // get image
+
+            if (sampler !== undefined) {
+              var surface = effect.profile.surfaces[sampler.source];
+              image = getImage(surface.init_from);
+            } else {
+              console.warn('THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530).');
+              image = getImage(textureObject.id);
+            } // create texture if image is avaiable
+
+
+            if (image !== null) {
+              var loader = getTextureLoader(image);
+
+              if (loader !== undefined) {
+                var texture = loader.load(image);
+                var extra = textureObject.extra;
+
+                if (extra !== undefined && extra.technique !== undefined && isEmpty(extra.technique) === false) {
+                  var _technique = extra.technique;
+                  texture.wrapS = _technique.wrapU ? _three.RepeatWrapping : _three.ClampToEdgeWrapping;
+                  texture.wrapT = _technique.wrapV ? _three.RepeatWrapping : _three.ClampToEdgeWrapping;
+                  texture.offset.set(_technique.offsetU || 0, _technique.offsetV || 0);
+                  texture.repeat.set(_technique.repeatU || 1, _technique.repeatV || 1);
+                } else {
+                  texture.wrapS = _three.RepeatWrapping;
+                  texture.wrapT = _three.RepeatWrapping;
+                }
+
+                return texture;
+              } else {
+                console.warn('THREE.ColladaLoader: Loader for texture %s not found.', image);
+                return null;
+              }
+            } else {
+              console.warn('THREE.ColladaLoader: Couldn\'t create texture with ID:', textureObject.id);
+              return null;
+            }
+          }
+
+          var parameters = technique.parameters;
+
+          for (var key in parameters) {
+            var parameter = parameters[key];
+
+            switch (key) {
+              case 'diffuse':
+                if (parameter.color) material.color.fromArray(parameter.color);
+                if (parameter.texture) material.map = getTexture(parameter.texture);
+                break;
+
+              case 'specular':
+                if (parameter.color && material.specular) material.specular.fromArray(parameter.color);
+                if (parameter.texture) material.specularMap = getTexture(parameter.texture);
+                break;
+
+              case 'bump':
+                if (parameter.texture) material.normalMap = getTexture(parameter.texture);
+                break;
+
+              case 'ambient':
+                if (parameter.texture) material.lightMap = getTexture(parameter.texture);
+                break;
+
+              case 'shininess':
+                if (parameter.float && material.shininess) material.shininess = parameter.float;
+                break;
+
+              case 'emission':
+                if (parameter.color && material.emissive) material.emissive.fromArray(parameter.color);
+                if (parameter.texture) material.emissiveMap = getTexture(parameter.texture);
+                break;
+            }
+          } //
+
+
+          var transparent = parameters['transparent'];
+          var transparency = parameters['transparency']; // <transparency> does not exist but <transparent>
+
+          if (transparency === undefined && transparent) {
+            transparency = {
+              float: 1
+            };
+          } // <transparent> does not exist but <transparency>
+
+
+          if (transparent === undefined && transparency) {
+            transparent = {
+              opaque: 'A_ONE',
+              data: {
+                color: [1, 1, 1, 1]
+              }
+            };
+          }
+
+          if (transparent && transparency) {
+            // handle case if a texture exists but no color
+            if (transparent.data.texture) {
+              // we do not set an alpha map (see #13792)
+              material.transparent = true;
+            } else {
+              var color = transparent.data.color;
+
+              switch (transparent.opaque) {
+                case 'A_ONE':
+                  material.opacity = color[3] * transparency.float;
+                  break;
+
+                case 'RGB_ZERO':
+                  material.opacity = 1 - color[0] * transparency.float;
+                  break;
+
+                case 'A_ZERO':
+                  material.opacity = 1 - color[3] * transparency.float;
+                  break;
+
+                case 'RGB_ONE':
+                  material.opacity = color[0] * transparency.float;
+                  break;
+
+                default:
+                  material.opacity = 1 - transparency.float;
+                  console.warn('THREE.ColladaLoader: Invalid opaque type "%s" of transparent tag.', transparent.opaque);
+              }
+
+              if (material.opacity < 1) material.transparent = true;
+            }
+          } //
+
+
+          if (technique.extra !== undefined && technique.extra.technique !== undefined) {
+            var techniques = technique.extra.technique;
+
+            for (var k in techniques) {
+              var v = techniques[k];
+
+              switch (k) {
+                case 'double_sided':
+                  material.side = v === 1 ? _three.DoubleSide : _three.FrontSide;
+                  break;
+
+                case 'bump':
+                  material.normalMap = getTexture(v.texture);
+                  material.normalScale = new _three.Vector2(1, 1);
+                  break;
+              }
+            }
+          }
+
+          return material;
+        }
+
+        function getMaterial(id) {
+          return getBuild(library.materials[id], buildMaterial);
+        } // camera
+
+
+        function parseCamera(xml) {
+          var data = {
+            name: xml.getAttribute('name')
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'optics':
+                data.optics = parseCameraOptics(child);
+                break;
+            }
+          }
+
+          library.cameras[xml.getAttribute('id')] = data;
+        }
+
+        function parseCameraOptics(xml) {
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+
+            switch (child.nodeName) {
+              case 'technique_common':
+                return parseCameraTechnique(child);
+            }
+          }
+
+          return {};
+        }
+
+        function parseCameraTechnique(xml) {
+          var data = {};
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+
+            switch (child.nodeName) {
+              case 'perspective':
+              case 'orthographic':
+                data.technique = child.nodeName;
+                data.parameters = parseCameraParameters(child);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseCameraParameters(xml) {
+          var data = {};
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+
+            switch (child.nodeName) {
+              case 'xfov':
+              case 'yfov':
+              case 'xmag':
+              case 'ymag':
+              case 'znear':
+              case 'zfar':
+              case 'aspect_ratio':
+                data[child.nodeName] = parseFloat(child.textContent);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function buildCamera(data) {
+          var camera;
+
+          switch (data.optics.technique) {
+            case 'perspective':
+              camera = new _three.PerspectiveCamera(data.optics.parameters.yfov, data.optics.parameters.aspect_ratio, data.optics.parameters.znear, data.optics.parameters.zfar);
+              break;
+
+            case 'orthographic':
+              var ymag = data.optics.parameters.ymag;
+              var xmag = data.optics.parameters.xmag;
+              var aspectRatio = data.optics.parameters.aspect_ratio;
+              xmag = xmag === undefined ? ymag * aspectRatio : xmag;
+              ymag = ymag === undefined ? xmag / aspectRatio : ymag;
+              xmag *= 0.5;
+              ymag *= 0.5;
+              camera = new _three.OrthographicCamera(-xmag, xmag, ymag, -ymag, // left, right, top, bottom
+              data.optics.parameters.znear, data.optics.parameters.zfar);
+              break;
+
+            default:
+              camera = new _three.PerspectiveCamera();
+              break;
+          }
+
+          camera.name = data.name || '';
+          return camera;
+        }
+
+        function getCamera(id) {
+          var data = library.cameras[id];
+
+          if (data !== undefined) {
+            return getBuild(data, buildCamera);
+          }
+
+          console.warn('THREE.ColladaLoader: Couldn\'t find camera with ID:', id);
+          return null;
+        } // light
+
+
+        function parseLight(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'technique_common':
+                data = parseLightTechnique(child);
+                break;
+            }
+          }
+
+          library.lights[xml.getAttribute('id')] = data;
+        }
+
+        function parseLightTechnique(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'directional':
+              case 'point':
+              case 'spot':
+              case 'ambient':
+                data.technique = child.nodeName;
+                data.parameters = parseLightParameters(child);
+            }
+          }
+
+          return data;
+        }
+
+        function parseLightParameters(xml) {
+          var data = {};
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'color':
+                var array = parseFloats(child.textContent);
+                data.color = new _three.Color().fromArray(array);
+                break;
+
+              case 'falloff_angle':
+                data.falloffAngle = parseFloat(child.textContent);
+                break;
+
+              case 'quadratic_attenuation':
+                var f = parseFloat(child.textContent);
+                data.distance = f ? Math.sqrt(1 / f) : 0;
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function buildLight(data) {
+          var light;
+
+          switch (data.technique) {
+            case 'directional':
+              light = new _three.DirectionalLight();
+              break;
+
+            case 'point':
+              light = new _three.PointLight();
+              break;
+
+            case 'spot':
+              light = new _three.SpotLight();
+              break;
+
+            case 'ambient':
+              light = new _three.AmbientLight();
+              break;
+          }
+
+          if (data.parameters.color) light.color.copy(data.parameters.color);
+          if (data.parameters.distance) light.distance = data.parameters.distance;
+          return light;
+        }
+
+        function getLight(id) {
+          var data = library.lights[id];
+
+          if (data !== undefined) {
+            return getBuild(data, buildLight);
+          }
+
+          console.warn('THREE.ColladaLoader: Couldn\'t find light with ID:', id);
+          return null;
+        } // geometry
+
+
+        function parseGeometry(xml) {
+          var data = {
+            name: xml.getAttribute('name'),
+            sources: {},
+            vertices: {},
+            primitives: []
+          };
+          var mesh = getElementsByTagName(xml, 'mesh')[0]; // the following tags inside geometry are not supported yet (see https://github.com/mrdoob/three.js/pull/12606): convex_mesh, spline, brep
+
+          if (mesh === undefined) return;
+
+          for (var i = 0; i < mesh.childNodes.length; i++) {
+            var child = mesh.childNodes[i];
+            if (child.nodeType !== 1) continue;
+            var id = child.getAttribute('id');
+
+            switch (child.nodeName) {
+              case 'source':
+                data.sources[id] = parseSource(child);
+                break;
+
+              case 'vertices':
+                // data.sources[ id ] = data.sources[ parseId( getElementsByTagName( child, 'input' )[ 0 ].getAttribute( 'source' ) ) ];
+                data.vertices = parseGeometryVertices(child);
+                break;
+
+              case 'polygons':
+                console.warn('THREE.ColladaLoader: Unsupported primitive type: ', child.nodeName);
+                break;
+
+              case 'lines':
+              case 'linestrips':
+              case 'polylist':
+              case 'triangles':
+                data.primitives.push(parseGeometryPrimitive(child));
+                break;
+
+              default:
+                console.log(child);
+            }
+          }
+
+          library.geometries[xml.getAttribute('id')] = data;
+        }
+
+        function parseSource(xml) {
+          var data = {
+            array: [],
+            stride: 3
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'float_array':
+                data.array = parseFloats(child.textContent);
+                break;
+
+              case 'Name_array':
+                data.array = parseStrings(child.textContent);
+                break;
+
+              case 'technique_common':
+                var accessor = getElementsByTagName(child, 'accessor')[0];
+
+                if (accessor !== undefined) {
+                  data.stride = parseInt(accessor.getAttribute('stride'));
+                }
+
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseGeometryVertices(xml) {
+          var data = {};
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+            data[child.getAttribute('semantic')] = parseId(child.getAttribute('source'));
+          }
+
+          return data;
+        }
+
+        function parseGeometryPrimitive(xml) {
+          var primitive = {
+            type: xml.nodeName,
+            material: xml.getAttribute('material'),
+            count: parseInt(xml.getAttribute('count')),
+            inputs: {},
+            stride: 0,
+            hasUV: false
+          };
+
+          for (var i = 0, l = xml.childNodes.length; i < l; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'input':
+                var id = parseId(child.getAttribute('source'));
+                var semantic = child.getAttribute('semantic');
+                var offset = parseInt(child.getAttribute('offset'));
+                var set = parseInt(child.getAttribute('set'));
+                var inputname = set > 0 ? semantic + set : semantic;
+                primitive.inputs[inputname] = {
+                  id: id,
+                  offset: offset
+                };
+                primitive.stride = Math.max(primitive.stride, offset + 1);
+                if (semantic === 'TEXCOORD') primitive.hasUV = true;
+                break;
+
+              case 'vcount':
+                primitive.vcount = parseInts(child.textContent);
+                break;
+
+              case 'p':
+                primitive.p = parseInts(child.textContent);
+                break;
+            }
+          }
+
+          return primitive;
+        }
+
+        function groupPrimitives(primitives) {
+          var build = {};
+
+          for (var i = 0; i < primitives.length; i++) {
+            var primitive = primitives[i];
+            if (build[primitive.type] === undefined) build[primitive.type] = [];
+            build[primitive.type].push(primitive);
+          }
+
+          return build;
+        }
+
+        function checkUVCoordinates(primitives) {
+          var count = 0;
+
+          for (var i = 0, l = primitives.length; i < l; i++) {
+            var primitive = primitives[i];
+
+            if (primitive.hasUV === true) {
+              count++;
+            }
+          }
+
+          if (count > 0 && count < primitives.length) {
+            primitives.uvsNeedsFix = true;
+          }
+        }
+
+        function buildGeometry(data) {
+          var build = {};
+          var sources = data.sources;
+          var vertices = data.vertices;
+          var primitives = data.primitives;
+          if (primitives.length === 0) return {}; // our goal is to create one buffer geometry for a single type of primitives
+          // first, we group all primitives by their type
+
+          var groupedPrimitives = groupPrimitives(primitives);
+
+          for (var type in groupedPrimitives) {
+            var primitiveType = groupedPrimitives[type]; // second, ensure consistent uv coordinates for each type of primitives (polylist,triangles or lines)
+
+            checkUVCoordinates(primitiveType); // third, create a buffer geometry for each type of primitives
+
+            build[type] = buildGeometryType(primitiveType, sources, vertices);
+          }
+
+          return build;
+        }
+
+        function buildGeometryType(primitives, sources, vertices) {
+          var build = {};
+          var position = {
+            array: [],
+            stride: 0
+          };
+          var normal = {
+            array: [],
+            stride: 0
+          };
+          var uv = {
+            array: [],
+            stride: 0
+          };
+          var uv2 = {
+            array: [],
+            stride: 0
+          };
+          var color = {
+            array: [],
+            stride: 0
+          };
+          var skinIndex = {
+            array: [],
+            stride: 4
+          };
+          var skinWeight = {
+            array: [],
+            stride: 4
+          };
+          var geometry = new _three.BufferGeometry();
+          var materialKeys = [];
+          var start = 0;
+
+          for (var p = 0; p < primitives.length; p++) {
+            var primitive = primitives[p];
+            var inputs = primitive.inputs; // groups
+
+            var _count = 0;
+
+            switch (primitive.type) {
+              case 'lines':
+              case 'linestrips':
+                _count = primitive.count * 2;
+                break;
+
+              case 'triangles':
+                _count = primitive.count * 3;
+                break;
+
+              case 'polylist':
+                for (var g = 0; g < primitive.count; g++) {
+                  var vc = primitive.vcount[g];
+
+                  switch (vc) {
+                    case 3:
+                      _count += 3; // single triangle
+
+                      break;
+
+                    case 4:
+                      _count += 6; // quad, subdivided into two triangles
+
+                      break;
+
+                    default:
+                      _count += (vc - 2) * 3; // polylist with more than four vertices
+
+                      break;
+                  }
+                }
+
+                break;
+
+              default:
+                console.warn('THREE.ColladaLoader: Unknow primitive type:', primitive.type);
+            }
+
+            geometry.addGroup(start, _count, p);
+            start += _count; // material
+
+            if (primitive.material) {
+              materialKeys.push(primitive.material);
+            } // geometry data
+
+
+            for (var name in inputs) {
+              var input = inputs[name];
+
+              switch (name) {
+                case 'VERTEX':
+                  for (var key in vertices) {
+                    var id = vertices[key];
+
+                    switch (key) {
+                      case 'POSITION':
+                        var prevLength = position.array.length;
+                        buildGeometryData(primitive, sources[id], input.offset, position.array);
+                        position.stride = sources[id].stride;
+
+                        if (sources.skinWeights && sources.skinIndices) {
+                          buildGeometryData(primitive, sources.skinIndices, input.offset, skinIndex.array);
+                          buildGeometryData(primitive, sources.skinWeights, input.offset, skinWeight.array);
+                        } // see #3803
+
+
+                        if (primitive.hasUV === false && primitives.uvsNeedsFix === true) {
+                          var _count2 = (position.array.length - prevLength) / position.stride;
+
+                          for (var i = 0; i < _count2; i++) {
+                            // fill missing uv coordinates
+                            uv.array.push(0, 0);
+                          }
+                        }
+
+                        break;
+
+                      case 'NORMAL':
+                        buildGeometryData(primitive, sources[id], input.offset, normal.array);
+                        normal.stride = sources[id].stride;
+                        break;
+
+                      case 'COLOR':
+                        buildGeometryData(primitive, sources[id], input.offset, color.array);
+                        color.stride = sources[id].stride;
+                        break;
+
+                      case 'TEXCOORD':
+                        buildGeometryData(primitive, sources[id], input.offset, uv.array);
+                        uv.stride = sources[id].stride;
+                        break;
+
+                      case 'TEXCOORD1':
+                        buildGeometryData(primitive, sources[id], input.offset, uv2.array);
+                        uv.stride = sources[id].stride;
+                        break;
+
+                      default:
+                        console.warn('THREE.ColladaLoader: Semantic "%s" not handled in geometry build process.', key);
+                    }
+                  }
+
+                  break;
+
+                case 'NORMAL':
+                  buildGeometryData(primitive, sources[input.id], input.offset, normal.array);
+                  normal.stride = sources[input.id].stride;
+                  break;
+
+                case 'COLOR':
+                  buildGeometryData(primitive, sources[input.id], input.offset, color.array);
+                  color.stride = sources[input.id].stride;
+                  break;
+
+                case 'TEXCOORD':
+                  buildGeometryData(primitive, sources[input.id], input.offset, uv.array);
+                  uv.stride = sources[input.id].stride;
+                  break;
+
+                case 'TEXCOORD1':
+                  buildGeometryData(primitive, sources[input.id], input.offset, uv2.array);
+                  uv2.stride = sources[input.id].stride;
+                  break;
+              }
+            }
+          } // build geometry
+
+
+          if (position.array.length > 0) geometry.setAttribute('position', new _three.Float32BufferAttribute(position.array, position.stride));
+          if (normal.array.length > 0) geometry.setAttribute('normal', new _three.Float32BufferAttribute(normal.array, normal.stride));
+          if (color.array.length > 0) geometry.setAttribute('color', new _three.Float32BufferAttribute(color.array, color.stride));
+          if (uv.array.length > 0) geometry.setAttribute('uv', new _three.Float32BufferAttribute(uv.array, uv.stride));
+          if (uv2.array.length > 0) geometry.setAttribute('uv2', new _three.Float32BufferAttribute(uv2.array, uv2.stride));
+          if (skinIndex.array.length > 0) geometry.setAttribute('skinIndex', new _three.Float32BufferAttribute(skinIndex.array, skinIndex.stride));
+          if (skinWeight.array.length > 0) geometry.setAttribute('skinWeight', new _three.Float32BufferAttribute(skinWeight.array, skinWeight.stride));
+          build.data = geometry;
+          build.type = primitives[0].type;
+          build.materialKeys = materialKeys;
+          return build;
+        }
+
+        function buildGeometryData(primitive, source, offset, array) {
+          var indices = primitive.p;
+          var stride = primitive.stride;
+          var vcount = primitive.vcount;
+
+          function pushVector(i) {
+            var index = indices[i + offset] * sourceStride;
+            var length = index + sourceStride;
+
+            for (; index < length; index++) {
+              array.push(sourceArray[index]);
+            }
+          }
+
+          var sourceArray = source.array;
+          var sourceStride = source.stride;
+
+          if (primitive.vcount !== undefined) {
+            var index = 0;
+
+            for (var i = 0, l = vcount.length; i < l; i++) {
+              var _count3 = vcount[i];
+
+              if (_count3 === 4) {
+                var a = index + stride * 0;
+                var b = index + stride * 1;
+                var c = index + stride * 2;
+                var d = index + stride * 3;
+                pushVector(a);
+                pushVector(b);
+                pushVector(d);
+                pushVector(b);
+                pushVector(c);
+                pushVector(d);
+              } else if (_count3 === 3) {
+                var _a = index + stride * 0;
+
+                var _b = index + stride * 1;
+
+                var _c = index + stride * 2;
+
+                pushVector(_a);
+                pushVector(_b);
+                pushVector(_c);
+              } else if (_count3 > 4) {
+                for (var k = 1, kl = _count3 - 2; k <= kl; k++) {
+                  var _a2 = index + stride * 0;
+
+                  var _b2 = index + stride * k;
+
+                  var _c2 = index + stride * (k + 1);
+
+                  pushVector(_a2);
+                  pushVector(_b2);
+                  pushVector(_c2);
+                }
+              }
+
+              index += stride * _count3;
+            }
+          } else {
+            for (var _i = 0, _l = indices.length; _i < _l; _i += stride) {
+              pushVector(_i);
+            }
+          }
+        }
+
+        function getGeometry(id) {
+          return getBuild(library.geometries[id], buildGeometry);
+        } // kinematics
+
+
+        function parseKinematicsModel(xml) {
+          var data = {
+            name: xml.getAttribute('name') || '',
+            joints: {},
+            links: []
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'technique_common':
+                parseKinematicsTechniqueCommon(child, data);
+                break;
+            }
+          }
+
+          library.kinematicsModels[xml.getAttribute('id')] = data;
+        }
+
+        function buildKinematicsModel(data) {
+          if (data.build !== undefined) return data.build;
+          return data;
+        }
+
+        function getKinematicsModel(id) {
+          return getBuild(library.kinematicsModels[id], buildKinematicsModel);
+        }
+
+        function parseKinematicsTechniqueCommon(xml, data) {
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'joint':
+                data.joints[child.getAttribute('sid')] = parseKinematicsJoint(child);
+                break;
+
+              case 'link':
+                data.links.push(parseKinematicsLink(child));
+                break;
+            }
+          }
+        }
+
+        function parseKinematicsJoint(xml) {
+          var data;
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'prismatic':
+              case 'revolute':
+                data = parseKinematicsJointParameter(child);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseKinematicsJointParameter(xml) {
+          var data = {
+            sid: xml.getAttribute('sid'),
+            name: xml.getAttribute('name') || '',
+            axis: new _three.Vector3(),
+            limits: {
+              min: 0,
+              max: 0
+            },
+            type: xml.nodeName,
+            static: false,
+            zeroPosition: 0,
+            middlePosition: 0
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'axis':
+                var array = parseFloats(child.textContent);
+                data.axis.fromArray(array);
+                break;
+
+              case 'limits':
+                var max = child.getElementsByTagName('max')[0];
+                var min = child.getElementsByTagName('min')[0];
+                data.limits.max = parseFloat(max.textContent);
+                data.limits.min = parseFloat(min.textContent);
+                break;
+            }
+          } // if min is equal to or greater than max, consider the joint static
+
+
+          if (data.limits.min >= data.limits.max) {
+            data.static = true;
+          } // calculate middle position
+
+
+          data.middlePosition = (data.limits.min + data.limits.max) / 2.0;
+          return data;
+        }
+
+        function parseKinematicsLink(xml) {
+          var data = {
+            sid: xml.getAttribute('sid'),
+            name: xml.getAttribute('name') || '',
+            attachments: [],
+            transforms: []
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'attachment_full':
+                data.attachments.push(parseKinematicsAttachment(child));
+                break;
+
+              case 'matrix':
+              case 'translate':
+              case 'rotate':
+                data.transforms.push(parseKinematicsTransform(child));
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseKinematicsAttachment(xml) {
+          var data = {
+            joint: xml.getAttribute('joint').split('/').pop(),
+            transforms: [],
+            links: []
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'link':
+                data.links.push(parseKinematicsLink(child));
+                break;
+
+              case 'matrix':
+              case 'translate':
+              case 'rotate':
+                data.transforms.push(parseKinematicsTransform(child));
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function parseKinematicsTransform(xml) {
+          var data = {
+            type: xml.nodeName
+          };
+          var array = parseFloats(xml.textContent);
+
+          switch (data.type) {
+            case 'matrix':
+              data.obj = new _three.Matrix4();
+              data.obj.fromArray(array).transpose();
+              break;
+
+            case 'translate':
+              data.obj = new _three.Vector3();
+              data.obj.fromArray(array);
+              break;
+
+            case 'rotate':
+              data.obj = new _three.Vector3();
+              data.obj.fromArray(array);
+              data.angle = _three.MathUtils.degToRad(array[3]);
+              break;
+          }
+
+          return data;
+        } // physics
+
+
+        function parsePhysicsModel(xml) {
+          var data = {
+            name: xml.getAttribute('name') || '',
+            rigidBodies: {}
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'rigid_body':
+                data.rigidBodies[child.getAttribute('name')] = {};
+                parsePhysicsRigidBody(child, data.rigidBodies[child.getAttribute('name')]);
+                break;
+            }
+          }
+
+          library.physicsModels[xml.getAttribute('id')] = data;
+        }
+
+        function parsePhysicsRigidBody(xml, data) {
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'technique_common':
+                parsePhysicsTechniqueCommon(child, data);
+                break;
+            }
+          }
+        }
+
+        function parsePhysicsTechniqueCommon(xml, data) {
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'inertia':
+                data.inertia = parseFloats(child.textContent);
+                break;
+
+              case 'mass':
+                data.mass = parseFloats(child.textContent)[0];
+                break;
+            }
+          }
+        } // scene
+
+
+        function parseKinematicsScene(xml) {
+          var data = {
+            bindJointAxis: []
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'bind_joint_axis':
+                data.bindJointAxis.push(parseKinematicsBindJointAxis(child));
+                break;
+            }
+          }
+
+          library.kinematicsScenes[parseId(xml.getAttribute('url'))] = data;
+        }
+
+        function parseKinematicsBindJointAxis(xml) {
+          var data = {
+            target: xml.getAttribute('target').split('/').pop()
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            switch (child.nodeName) {
+              case 'axis':
+                var param = child.getElementsByTagName('param')[0];
+                data.axis = param.textContent;
+                var tmpJointIndex = data.axis.split('inst_').pop().split('axis')[0];
+                data.jointIndex = tmpJointIndex.substr(0, tmpJointIndex.length - 1);
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function buildKinematicsScene(data) {
+          if (data.build !== undefined) return data.build;
+          return data;
+        }
+
+        function getKinematicsScene(id) {
+          return getBuild(library.kinematicsScenes[id], buildKinematicsScene);
+        }
+
+        function setupKinematics() {
+          var kinematicsModelId = Object.keys(library.kinematicsModels)[0];
+          var kinematicsSceneId = Object.keys(library.kinematicsScenes)[0];
+          var visualSceneId = Object.keys(library.visualScenes)[0];
+          if (kinematicsModelId === undefined || kinematicsSceneId === undefined) return;
+          var kinematicsModel = getKinematicsModel(kinematicsModelId);
+          var kinematicsScene = getKinematicsScene(kinematicsSceneId);
+          var visualScene = getVisualScene(visualSceneId);
+          var bindJointAxis = kinematicsScene.bindJointAxis;
+          var jointMap = {};
+
+          for (var i = 0, l = bindJointAxis.length; i < l; i++) {
+            var axis = bindJointAxis[i]; // the result of the following query is an element of type 'translate', 'rotate','scale' or 'matrix'
+
+            var targetElement = collada.querySelector('[sid="' + axis.target + '"]');
+
+            if (targetElement) {
+              // get the parent of the transform element
+              var parentVisualElement = targetElement.parentElement; // connect the joint of the kinematics model with the element in the visual scene
+
+              connect(axis.jointIndex, parentVisualElement);
+            }
+          }
+
+          function connect(jointIndex, visualElement) {
+            var visualElementName = visualElement.getAttribute('name');
+            var joint = kinematicsModel.joints[jointIndex];
+            visualScene.traverse(function (object) {
+              if (object.name === visualElementName) {
+                jointMap[jointIndex] = {
+                  object: object,
+                  transforms: buildTransformList(visualElement),
+                  joint: joint,
+                  position: joint.zeroPosition
+                };
+              }
+            });
+          }
+
+          var m0 = new _three.Matrix4();
+          kinematics = {
+            joints: kinematicsModel && kinematicsModel.joints,
+            getJointValue: function getJointValue(jointIndex) {
+              var jointData = jointMap[jointIndex];
+
+              if (jointData) {
+                return jointData.position;
+              } else {
+                console.warn('THREE.ColladaLoader: Joint ' + jointIndex + ' doesn\'t exist.');
+              }
+            },
+            setJointValue: function setJointValue(jointIndex, value) {
+              var jointData = jointMap[jointIndex];
+
+              if (jointData) {
+                var joint = jointData.joint;
+
+                if (value > joint.limits.max || value < joint.limits.min) {
+                  console.warn('THREE.ColladaLoader: Joint ' + jointIndex + ' value ' + value + ' outside of limits (min: ' + joint.limits.min + ', max: ' + joint.limits.max + ').');
+                } else if (joint.static) {
+                  console.warn('THREE.ColladaLoader: Joint ' + jointIndex + ' is static.');
+                } else {
+                  var object = jointData.object;
+                  var _axis = joint.axis;
+                  var transforms = jointData.transforms;
+                  matrix.identity(); // each update, we have to apply all transforms in the correct order
+
+                  for (var _i2 = 0; _i2 < transforms.length; _i2++) {
+                    var transform = transforms[_i2]; // if there is a connection of the transform node with a joint, apply the joint value
+
+                    if (transform.sid && transform.sid.indexOf(jointIndex) !== -1) {
+                      switch (joint.type) {
+                        case 'revolute':
+                          matrix.multiply(m0.makeRotationAxis(_axis, _three.MathUtils.degToRad(value)));
+                          break;
+
+                        case 'prismatic':
+                          matrix.multiply(m0.makeTranslation(_axis.x * value, _axis.y * value, _axis.z * value));
+                          break;
+
+                        default:
+                          console.warn('THREE.ColladaLoader: Unknown joint type: ' + joint.type);
+                          break;
+                      }
+                    } else {
+                      switch (transform.type) {
+                        case 'matrix':
+                          matrix.multiply(transform.obj);
+                          break;
+
+                        case 'translate':
+                          matrix.multiply(m0.makeTranslation(transform.obj.x, transform.obj.y, transform.obj.z));
+                          break;
+
+                        case 'scale':
+                          matrix.scale(transform.obj);
+                          break;
+
+                        case 'rotate':
+                          matrix.multiply(m0.makeRotationAxis(transform.obj, transform.angle));
+                          break;
+                      }
+                    }
+                  }
+
+                  object.matrix.copy(matrix);
+                  object.matrix.decompose(object.position, object.quaternion, object.scale);
+                  jointMap[jointIndex].position = value;
+                }
+              } else {
+                console.log('THREE.ColladaLoader: ' + jointIndex + ' does not exist.');
+              }
+            }
+          };
+        }
+
+        function buildTransformList(node) {
+          var transforms = [];
+          var xml = collada.querySelector('[id="' + node.id + '"]');
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+
+            var array = void 0,
+                _vector = void 0;
+
+            switch (child.nodeName) {
+              case 'matrix':
+                array = parseFloats(child.textContent);
+
+                var _matrix = new _three.Matrix4().fromArray(array).transpose();
+
+                transforms.push({
+                  sid: child.getAttribute('sid'),
+                  type: child.nodeName,
+                  obj: _matrix
+                });
+                break;
+
+              case 'translate':
+              case 'scale':
+                array = parseFloats(child.textContent);
+                _vector = new _three.Vector3().fromArray(array);
+                transforms.push({
+                  sid: child.getAttribute('sid'),
+                  type: child.nodeName,
+                  obj: _vector
+                });
+                break;
+
+              case 'rotate':
+                array = parseFloats(child.textContent);
+                _vector = new _three.Vector3().fromArray(array);
+
+                var angle = _three.MathUtils.degToRad(array[3]);
+
+                transforms.push({
+                  sid: child.getAttribute('sid'),
+                  type: child.nodeName,
+                  obj: _vector,
+                  angle: angle
+                });
+                break;
+            }
+          }
+
+          return transforms;
+        } // nodes
+
+
+        function prepareNodes(xml) {
+          var elements = xml.getElementsByTagName('node'); // ensure all node elements have id attributes
+
+          for (var i = 0; i < elements.length; i++) {
+            var element = elements[i];
+
+            if (element.hasAttribute('id') === false) {
+              element.setAttribute('id', generateId());
+            }
+          }
+        }
+
+        var matrix = new _three.Matrix4();
+        var vector = new _three.Vector3();
+
+        function parseNode(xml) {
+          var data = {
+            name: xml.getAttribute('name') || '',
+            type: xml.getAttribute('type'),
+            id: xml.getAttribute('id'),
+            sid: xml.getAttribute('sid'),
+            matrix: new _three.Matrix4(),
+            nodes: [],
+            instanceCameras: [],
+            instanceControllers: [],
+            instanceLights: [],
+            instanceGeometries: [],
+            instanceNodes: [],
+            transforms: {}
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+            if (child.nodeType !== 1) continue;
+            var array = void 0;
+
+            switch (child.nodeName) {
+              case 'node':
+                data.nodes.push(child.getAttribute('id'));
+                parseNode(child);
+                break;
+
+              case 'instance_camera':
+                data.instanceCameras.push(parseId(child.getAttribute('url')));
+                break;
+
+              case 'instance_controller':
+                data.instanceControllers.push(parseNodeInstance(child));
+                break;
+
+              case 'instance_light':
+                data.instanceLights.push(parseId(child.getAttribute('url')));
+                break;
+
+              case 'instance_geometry':
+                data.instanceGeometries.push(parseNodeInstance(child));
+                break;
+
+              case 'instance_node':
+                data.instanceNodes.push(parseId(child.getAttribute('url')));
+                break;
+
+              case 'matrix':
+                array = parseFloats(child.textContent);
+                data.matrix.multiply(matrix.fromArray(array).transpose());
+                data.transforms[child.getAttribute('sid')] = child.nodeName;
+                break;
+
+              case 'translate':
+                array = parseFloats(child.textContent);
+                vector.fromArray(array);
+                data.matrix.multiply(matrix.makeTranslation(vector.x, vector.y, vector.z));
+                data.transforms[child.getAttribute('sid')] = child.nodeName;
+                break;
+
+              case 'rotate':
+                array = parseFloats(child.textContent);
+
+                var angle = _three.MathUtils.degToRad(array[3]);
+
+                data.matrix.multiply(matrix.makeRotationAxis(vector.fromArray(array), angle));
+                data.transforms[child.getAttribute('sid')] = child.nodeName;
+                break;
+
+              case 'scale':
+                array = parseFloats(child.textContent);
+                data.matrix.scale(vector.fromArray(array));
+                data.transforms[child.getAttribute('sid')] = child.nodeName;
+                break;
+
+              case 'extra':
+                break;
+
+              default:
+                console.log(child);
+            }
+          }
+
+          if (hasNode(data.id)) {
+            console.warn('THREE.ColladaLoader: There is already a node with ID %s. Exclude current node from further processing.', data.id);
+          } else {
+            library.nodes[data.id] = data;
+          }
+
+          return data;
+        }
+
+        function parseNodeInstance(xml) {
+          var data = {
+            id: parseId(xml.getAttribute('url')),
+            materials: {},
+            skeletons: []
+          };
+
+          for (var i = 0; i < xml.childNodes.length; i++) {
+            var child = xml.childNodes[i];
+
+            switch (child.nodeName) {
+              case 'bind_material':
+                var instances = child.getElementsByTagName('instance_material');
+
+                for (var j = 0; j < instances.length; j++) {
+                  var instance = instances[j];
+                  var symbol = instance.getAttribute('symbol');
+                  var target = instance.getAttribute('target');
+                  data.materials[symbol] = parseId(target);
+                }
+
+                break;
+
+              case 'skeleton':
+                data.skeletons.push(parseId(child.textContent));
+                break;
+
+              default:
+                break;
+            }
+          }
+
+          return data;
+        }
+
+        function buildSkeleton(skeletons, joints) {
+          var boneData = [];
+          var sortedBoneData = [];
+          var i, j, data; // a skeleton can have multiple root bones. collada expresses this
+          // situtation with multiple "skeleton" tags per controller instance
+
+          for (i = 0; i < skeletons.length; i++) {
+            var skeleton = skeletons[i];
+            var root = void 0;
+
+            if (hasNode(skeleton)) {
+              root = getNode(skeleton);
+              buildBoneHierarchy(root, joints, boneData);
+            } else if (hasVisualScene(skeleton)) {
+              // handle case where the skeleton refers to the visual scene (#13335)
+              var visualScene = library.visualScenes[skeleton];
+              var children = visualScene.children;
+
+              for (var _j = 0; _j < children.length; _j++) {
+                var child = children[_j];
+
+                if (child.type === 'JOINT') {
+                  var _root = getNode(child.id);
+
+                  buildBoneHierarchy(_root, joints, boneData);
+                }
+              }
+            } else {
+              console.error('THREE.ColladaLoader: Unable to find root bone of skeleton with ID:', skeleton);
+            }
+          } // sort bone data (the order is defined in the corresponding controller)
+
+
+          for (i = 0; i < joints.length; i++) {
+            for (j = 0; j < boneData.length; j++) {
+              data = boneData[j];
+
+              if (data.bone.name === joints[i].name) {
+                sortedBoneData[i] = data;
+                data.processed = true;
+                break;
+              }
+            }
+          } // add unprocessed bone data at the end of the list
+
+
+          for (i = 0; i < boneData.length; i++) {
+            data = boneData[i];
+
+            if (data.processed === false) {
+              sortedBoneData.push(data);
+              data.processed = true;
+            }
+          } // setup arrays for skeleton creation
+
+
+          var bones = [];
+          var boneInverses = [];
+
+          for (i = 0; i < sortedBoneData.length; i++) {
+            data = sortedBoneData[i];
+            bones.push(data.bone);
+            boneInverses.push(data.boneInverse);
+          }
+
+          return new _three.Skeleton(bones, boneInverses);
+        }
+
+        function buildBoneHierarchy(root, joints, boneData) {
+          // setup bone data from visual scene
+          root.traverse(function (object) {
+            if (object.isBone === true) {
+              var boneInverse; // retrieve the boneInverse from the controller data
+
+              for (var i = 0; i < joints.length; i++) {
+                var joint = joints[i];
+
+                if (joint.name === object.name) {
+                  boneInverse = joint.boneInverse;
+                  break;
+                }
+              }
+
+              if (boneInverse === undefined) {
+                // Unfortunately, there can be joints in the visual scene that are not part of the
+                // corresponding controller. In this case, we have to create a dummy boneInverse matrix
+                // for the respective bone. This bone won't affect any vertices, because there are no skin indices
+                // and weights defined for it. But we still have to add the bone to the sorted bone list in order to
+                // ensure a correct animation of the model.
+                boneInverse = new _three.Matrix4();
+              }
+
+              boneData.push({
+                bone: object,
+                boneInverse: boneInverse,
+                processed: false
+              });
+            }
+          });
+        }
+
+        function buildNode(data) {
+          var objects = [];
+          var matrix = data.matrix;
+          var nodes = data.nodes;
+          var type = data.type;
+          var instanceCameras = data.instanceCameras;
+          var instanceControllers = data.instanceControllers;
+          var instanceLights = data.instanceLights;
+          var instanceGeometries = data.instanceGeometries;
+          var instanceNodes = data.instanceNodes; // nodes
+
+          for (var i = 0, l = nodes.length; i < l; i++) {
+            objects.push(getNode(nodes[i]));
+          } // instance cameras
+
+
+          for (var _i3 = 0, _l2 = instanceCameras.length; _i3 < _l2; _i3++) {
+            var instanceCamera = getCamera(instanceCameras[_i3]);
+
+            if (instanceCamera !== null) {
+              objects.push(instanceCamera.clone());
+            }
+          } // instance controllers
+
+
+          for (var _i4 = 0, _l3 = instanceControllers.length; _i4 < _l3; _i4++) {
+            var instance = instanceControllers[_i4];
+            var controller = getController(instance.id);
+            var geometries = getGeometry(controller.id);
+            var newObjects = buildObjects(geometries, instance.materials);
+            var skeletons = instance.skeletons;
+            var joints = controller.skin.joints;
+            var skeleton = buildSkeleton(skeletons, joints);
+
+            for (var j = 0, jl = newObjects.length; j < jl; j++) {
+              var _object = newObjects[j];
+
+              if (_object.isSkinnedMesh) {
+                _object.bind(skeleton, controller.skin.bindMatrix);
+
+                _object.normalizeSkinWeights();
+              }
+
+              objects.push(_object);
+            }
+          } // instance lights
+
+
+          for (var _i5 = 0, _l4 = instanceLights.length; _i5 < _l4; _i5++) {
+            var instanceLight = getLight(instanceLights[_i5]);
+
+            if (instanceLight !== null) {
+              objects.push(instanceLight.clone());
+            }
+          } // instance geometries
+
+
+          for (var _i6 = 0, _l5 = instanceGeometries.length; _i6 < _l5; _i6++) {
+            var _instance = instanceGeometries[_i6]; // a single geometry instance in collada can lead to multiple object3Ds.
+            // this is the case when primitives are combined like triangles and lines
+
+            var _geometries = getGeometry(_instance.id);
+
+            var _newObjects = buildObjects(_geometries, _instance.materials);
+
+            for (var _j2 = 0, _jl = _newObjects.length; _j2 < _jl; _j2++) {
+              objects.push(_newObjects[_j2]);
+            }
+          } // instance nodes
+
+
+          for (var _i7 = 0, _l6 = instanceNodes.length; _i7 < _l6; _i7++) {
+            objects.push(getNode(instanceNodes[_i7]).clone());
+          }
+
+          var object;
+
+          if (nodes.length === 0 && objects.length === 1) {
+            object = objects[0];
+          } else {
+            object = type === 'JOINT' ? new _three.Bone() : new _three.Group();
+
+            for (var _i8 = 0; _i8 < objects.length; _i8++) {
+              object.add(objects[_i8]);
+            }
+          }
+
+          object.name = type === 'JOINT' ? data.sid : data.name;
+          object.matrix.copy(matrix);
+          object.matrix.decompose(object.position, object.quaternion, object.scale);
+          return object;
+        }
+
+        var fallbackMaterial = new _three.MeshBasicMaterial({
+          color: 0xff00ff
+        });
+
+        function resolveMaterialBinding(keys, instanceMaterials) {
+          var materials = [];
+
+          for (var i = 0, l = keys.length; i < l; i++) {
+            var id = instanceMaterials[keys[i]];
+
+            if (id === undefined) {
+              console.warn('THREE.ColladaLoader: Material with key %s not found. Apply fallback material.', keys[i]);
+              materials.push(fallbackMaterial);
+            } else {
+              materials.push(getMaterial(id));
+            }
+          }
+
+          return materials;
+        }
+
+        function buildObjects(geometries, instanceMaterials) {
+          var objects = [];
+
+          for (var type in geometries) {
+            var geometry = geometries[type];
+            var materials = resolveMaterialBinding(geometry.materialKeys, instanceMaterials); // handle case if no materials are defined
+
+            if (materials.length === 0) {
+              if (type === 'lines' || type === 'linestrips') {
+                materials.push(new _three.LineBasicMaterial());
+              } else {
+                materials.push(new _three.MeshPhongMaterial());
+              }
+            } // regard skinning
+
+
+            var skinning = geometry.data.attributes.skinIndex !== undefined; // choose between a single or multi materials (material array)
+
+            var material = materials.length === 1 ? materials[0] : materials; // now create a specific 3D object
+
+            var object = void 0;
+
+            switch (type) {
+              case 'lines':
+                object = new _three.LineSegments(geometry.data, material);
+                break;
+
+              case 'linestrips':
+                object = new _three.Line(geometry.data, material);
+                break;
+
+              case 'triangles':
+              case 'polylist':
+                if (skinning) {
+                  object = new _three.SkinnedMesh(geometry.data, material);
+                } else {
+                  object = new _three.Mesh(geometry.data, material);
+                }
+
+                break;
+            }
+
+            objects.push(object);
+          }
+
+          return objects;
+        }
+
+        function hasNode(id) {
+          return library.nodes[id] !== undefined;
+        }
+
+        function getNode(id) {
+          return getBuild(library.nodes[id], buildNode);
+        } // visual scenes
+
+
+        function parseVisualScene(xml) {
+          var data = {
+            name: xml.getAttribute('name'),
+            children: []
+          };
+          prepareNodes(xml);
+          var elements = getElementsByTagName(xml, 'node');
+
+          for (var i = 0; i < elements.length; i++) {
+            data.children.push(parseNode(elements[i]));
+          }
+
+          library.visualScenes[xml.getAttribute('id')] = data;
+        }
+
+        function buildVisualScene(data) {
+          var group = new _three.Group();
+          group.name = data.name;
+          var children = data.children;
+
+          for (var i = 0; i < children.length; i++) {
+            var child = children[i];
+            group.add(getNode(child.id));
+          }
+
+          return group;
+        }
+
+        function hasVisualScene(id) {
+          return library.visualScenes[id] !== undefined;
+        }
+
+        function getVisualScene(id) {
+          return getBuild(library.visualScenes[id], buildVisualScene);
+        } // scenes
+
+
+        function parseScene(xml) {
+          var instance = getElementsByTagName(xml, 'instance_visual_scene')[0];
+          return getVisualScene(parseId(instance.getAttribute('url')));
+        }
+
+        function setupAnimations() {
+          var clips = library.clips;
+
+          if (isEmpty(clips) === true) {
+            if (isEmpty(library.animations) === false) {
+              // if there are animations but no clips, we create a default clip for playback
+              var tracks = [];
+
+              for (var id in library.animations) {
+                var animationTracks = getAnimation(id);
+
+                for (var i = 0, l = animationTracks.length; i < l; i++) {
+                  tracks.push(animationTracks[i]);
+                }
+              }
+
+              animations.push(new _three.AnimationClip('default', -1, tracks));
+            }
+          } else {
+            for (var _id in clips) {
+              animations.push(getAnimationClip(_id));
+            }
+          }
+        } // convert the parser error element into text with each child elements text
+        // separated by new lines.
+
+
+        function parserErrorToText(parserError) {
+          var result = '';
+          var stack = [parserError];
+
+          while (stack.length) {
+            var node = stack.shift();
+
+            if (node.nodeType === Node.TEXT_NODE) {
+              result += node.textContent;
+            } else {
+              result += '\n';
+              stack.push.apply(stack, node.childNodes);
+            }
+          }
+
+          return result.trim();
+        }
+
+        if (text.length === 0) {
+          return {
+            scene: new _three.Scene()
+          };
+        }
+
+        var xml = new DOMParser().parseFromString(text, 'application/xml');
+        var collada = getElementsByTagName(xml, 'COLLADA')[0];
+        var parserError = xml.getElementsByTagName('parsererror')[0];
+
+        if (parserError !== undefined) {
+          // Chrome will return parser error with a div in it
+          var errorElement = getElementsByTagName(parserError, 'div')[0];
+          var errorText;
+
+          if (errorElement) {
+            errorText = errorElement.textContent;
+          } else {
+            errorText = parserErrorToText(parserError);
+          }
+
+          console.error('THREE.ColladaLoader: Failed to parse collada file.\n', errorText);
+          return null;
+        } // metadata
+
+
+        var version = collada.getAttribute('version');
+        console.log('THREE.ColladaLoader: File version', version);
+        var asset = parseAsset(getElementsByTagName(collada, 'asset')[0]);
+        var textureLoader = new _three.TextureLoader(this.manager);
+        textureLoader.setPath(this.resourcePath || path).setCrossOrigin(this.crossOrigin);
+        var tgaLoader;
+
+        if (_TGALoader.TGALoader) {
+          tgaLoader = new _TGALoader.TGALoader(this.manager);
+          tgaLoader.setPath(this.resourcePath || path);
+        } //
+
+
+        var animations = [];
+        var kinematics = {};
+        var count = 0; //
+
+        var library = {
+          animations: {},
+          clips: {},
+          controllers: {},
+          images: {},
+          effects: {},
+          materials: {},
+          cameras: {},
+          lights: {},
+          geometries: {},
+          nodes: {},
+          visualScenes: {},
+          kinematicsModels: {},
+          physicsModels: {},
+          kinematicsScenes: {}
+        };
+        parseLibrary(collada, 'library_animations', 'animation', parseAnimation);
+        parseLibrary(collada, 'library_animation_clips', 'animation_clip', parseAnimationClip);
+        parseLibrary(collada, 'library_controllers', 'controller', parseController);
+        parseLibrary(collada, 'library_images', 'image', parseImage);
+        parseLibrary(collada, 'library_effects', 'effect', parseEffect);
+        parseLibrary(collada, 'library_materials', 'material', parseMaterial);
+        parseLibrary(collada, 'library_cameras', 'camera', parseCamera);
+        parseLibrary(collada, 'library_lights', 'light', parseLight);
+        parseLibrary(collada, 'library_geometries', 'geometry', parseGeometry);
+        parseLibrary(collada, 'library_nodes', 'node', parseNode);
+        parseLibrary(collada, 'library_visual_scenes', 'visual_scene', parseVisualScene);
+        parseLibrary(collada, 'library_kinematics_models', 'kinematics_model', parseKinematicsModel);
+        parseLibrary(collada, 'library_physics_models', 'physics_model', parsePhysicsModel);
+        parseLibrary(collada, 'scene', 'instance_kinematics_scene', parseKinematicsScene);
+        buildLibrary(library.animations, buildAnimation);
+        buildLibrary(library.clips, buildAnimationClip);
+        buildLibrary(library.controllers, buildController);
+        buildLibrary(library.images, buildImage);
+        buildLibrary(library.effects, buildEffect);
+        buildLibrary(library.materials, buildMaterial);
+        buildLibrary(library.cameras, buildCamera);
+        buildLibrary(library.lights, buildLight);
+        buildLibrary(library.geometries, buildGeometry);
+        buildLibrary(library.visualScenes, buildVisualScene);
+        setupAnimations();
+        setupKinematics();
+        var scene = parseScene(getElementsByTagName(collada, 'scene')[0]);
+        scene.animations = animations;
+
+        if (asset.upAxis === 'Z_UP') {
+          scene.quaternion.setFromEuler(new _three.Euler(-Math.PI / 2, 0, 0));
+        }
+
+        scene.scale.multiplyScalar(asset.unit);
+        return {
+          get animations() {
+            console.warn('THREE.ColladaLoader: Please access animations over scene.animations now.');
+            return animations;
+          },
+
+          kinematics: kinematics,
+          library: library,
+          scene: scene
+        };
+      }
+    }]);
+
+    return ColladaLoader;
+  }(_three.Loader);
+
+  _exports.ColladaLoader = ColladaLoader;
+});