redhotmagma-visualization 1.41.0 → 1.42.0

package/Three/Loaders/ColladaLoader.js

@@ -1,21 +1,20 @@
 "use strict";
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = void 0;
-
 var THREE_imp = _interopRequireWildcard(require("three"));
-
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 /* eslint-disable */
+
 // original source: three/examples/js/loaders/ColladaLoader
-var THREE = THREE_imp; // important: update file from here if needed
+
+var THREE = THREE_imp;
+
+// important: update file from here if needed
 
 /**
  * @author mrdoob / http://mrdoob.com/
@@ -25,7 +24,6 @@ var THREE = THREE_imp; // important: update file from here if needed
 THREE.ColladaLoader = function (manager) {
   this.manager = manager !== undefined ? manager : THREE.DefaultLoadingManager;
 };
-
 THREE.ColladaLoader.prototype = {
   constructor: THREE.ColladaLoader,
   crossOrigin: "anonymous",
@@ -50,7 +48,6 @@ THREE.ColladaLoader.prototype = {
     set convertUpAxis(value) {
       console.warn("THREE.ColladaLoader: options.convertUpAxis() has been removed. Up axis is converted automatically.");
     }
-
   },
   setCrossOrigin: function setCrossOrigin(value) {
     this.crossOrigin = value;
@@ -59,68 +56,55 @@ THREE.ColladaLoader.prototype = {
   parse: 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
+    }
 
+    // asset
 
     function parseAsset(xml) {
       return {
@@ -128,7 +112,6 @@ THREE.ColladaLoader.prototype = {
         upAxis: parseAssetUpAxis(getElementsByTagName(xml, "up_axis")[0])
       };
     }
-
     function parseAssetUnit(xml) {
       if (xml !== undefined && xml.hasAttribute("meter") === true) {
         return parseFloat(xml.getAttribute("meter"));
@@ -139,35 +122,35 @@ THREE.ColladaLoader.prototype = {
 
     function parseAssetUpAxis(xml) {
       return xml !== undefined ? xml.textContent : "Y_UP";
-    } // library
+    }
 
+    // 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
+    }
 
+    // get
 
     function getBuild(data, builder) {
       if (data.build !== undefined) return data.build;
       data.build = builder(data);
       return data.build;
-    } // animation
+    }
 
+    // animation
 
     function parseAnimation(xml) {
       var data = {
@@ -175,45 +158,36 @@ THREE.ColladaLoader.prototype = {
         samplers: {},
         channels: {}
       };
-
       for (var i = 0, l = xml.childNodes.length; i < l; i++) {
         var child = xml.childNodes[i];
         if (child.nodeType !== 1) continue;
         var id;
-
         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;
-
           default:
             console.log(child);
         }
       }
-
       library.animations[xml.getAttribute("id")] = 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"));
@@ -222,38 +196,38 @@ THREE.ColladaLoader.prototype = {
             break;
         }
       }
-
       return data;
     }
-
     function parseAnimationChannel(xml) {
       var data = {};
-      var target = xml.getAttribute("target"); // parsing SID Addressing Syntax
+      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 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;
@@ -261,13 +235,11 @@ THREE.ColladaLoader.prototype = {
       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];
@@ -280,14 +252,11 @@ THREE.ColladaLoader.prototype = {
           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);
@@ -295,7 +264,9 @@ THREE.ColladaLoader.prototype = {
       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.
+      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) {
@@ -304,7 +275,6 @@ THREE.ColladaLoader.prototype = {
             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];
@@ -315,22 +285,17 @@ THREE.ColladaLoader.prototype = {
               }
             }
           }
-
           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,
@@ -338,35 +303,38 @@ THREE.ColladaLoader.prototype = {
       };
       return animation;
     }
-
     function prepareAnimationData(data, defaultMatrix) {
-      var keyframes = []; // transfer data into a sortable array
+      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
+      }
+
+      // ensure keyframes are sorted by time
 
+      keyframes.sort(ascending);
 
-      keyframes.sort(ascending); // now we clean up all animation data, so we can use them for keyframe tracks
+      // 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;
 
-      return keyframes; // array sort function
+      // 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;
@@ -374,7 +342,6 @@ THREE.ColladaLoader.prototype = {
       var positionData = [];
       var quaternionData = [];
       var scaleData = [];
-
       for (var i = 0, l = keyframes.length; i < l; i++) {
         var keyframe = keyframes[i];
         var time = keyframe.time;
@@ -386,94 +353,83 @@ THREE.ColladaLoader.prototype = {
         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
+      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
+    }
 
+    // animation clips
 
     function parseAnimationClip(xml) {
       var data = {
@@ -482,108 +438,87 @@ THREE.ColladaLoader.prototype = {
         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
+    }
 
+    // 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");
@@ -592,19 +527,15 @@ THREE.ColladaLoader.prototype = {
             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");
@@ -615,36 +546,31 @@ THREE.ColladaLoader.prototype = {
               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
+        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 = {
@@ -669,13 +595,13 @@ THREE.ColladaLoader.prototype = {
       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
+      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];
@@ -685,16 +611,18 @@ THREE.ColladaLoader.prototype = {
             weight: skinWeight
           });
           stride += 2;
-        } // we sort the joints in descending order based on the weights.
+        }
+
+        // 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);
 
-        vertexSkinData.sort(descending); // now we provide for each vertex a set of four index and weight values.
+        // 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);
@@ -703,15 +631,17 @@ THREE.ColladaLoader.prototype = {
             build.weights.array.push(0);
           }
         }
-      } // setup bind matrix
+      }
 
+      // 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
+      }
 
+      // process bones and inverse bind matrix data
 
       for (i = 0, l = jointSource.array.length; i < l; i++) {
         var name = jointSource.array[i];
@@ -721,18 +651,19 @@ THREE.ColladaLoader.prototype = {
           boneInverse: boneInverse
         });
       }
+      return build;
 
-      return build; // array sort function
+      // array sort function
 
       function descending(a, b) {
         return b.weight - a.weight;
       }
     }
-
     function getController(id) {
       return getBuild(library.controllers[id], buildController);
-    } // image
+    }
 
+    // image
 
     function parseImage(xml) {
       var data = {
@@ -740,129 +671,102 @@ THREE.ColladaLoader.prototype = {
       };
       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
+    }
 
+    // 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":
@@ -873,17 +777,13 @@ THREE.ColladaLoader.prototype = {
             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":
@@ -894,7 +794,6 @@ THREE.ColladaLoader.prototype = {
           case "transparency":
             data[child.nodeName] = parseEffectParameter(child);
             break;
-
           case "transparent":
             data[child.nodeName] = {
               opaque: child.getAttribute("opaque"),
@@ -903,26 +802,20 @@ THREE.ColladaLoader.prototype = {
             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"),
@@ -931,34 +824,27 @@ THREE.ColladaLoader.prototype = {
             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);
@@ -966,12 +852,10 @@ THREE.ColladaLoader.prototype = {
         }
       }
     }
-
     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":
@@ -979,10 +863,10 @@ THREE.ColladaLoader.prototype = {
           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") {
@@ -990,118 +874,96 @@ THREE.ColladaLoader.prototype = {
             } else {
               data.technique[child.nodeName] = parseInt(child.textContent);
             }
-
             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;
         }
       }
-
       return data;
     }
-
     function buildEffect(data) {
       return data;
     }
-
     function getEffect(id) {
       return getBuild(library.effects[id], buildEffect);
-    } // material
+    }
 
+    // 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 extra = effect.profile.extra;
       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
+        var image = null;
+
+        // get image
 
         if (sampler !== undefined) {
           var surface = effect.profile.surfaces[sampler.source];
@@ -1109,16 +971,15 @@ THREE.ColladaLoader.prototype = {
         } else {
           console.warn("THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530).");
           image = getImage(textureObject.id);
-        } // create texture if image is avaiable
+        }
 
+        // 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;
@@ -1129,7 +990,6 @@ THREE.ColladaLoader.prototype = {
               texture.wrapS = THREE.RepeatWrapping;
               texture.wrapT = THREE.RepeatWrapping;
             }
-
             return texture;
           } else {
             console.warn("THREE.ColladaLoader: Loader for texture %s not found.", image);
@@ -1140,52 +1000,48 @@ THREE.ColladaLoader.prototype = {
           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>
+      var transparency = parameters["transparency"];
+
+      // <transparency> does not exist but <transparent>
 
       if (transparency === undefined && transparent) {
         transparency = {
           "float": 1
         };
-      } // <transparent> does not exist but <transparency>
+      }
 
+      // <transparent> does not exist but <transparency>
 
       if (transparent === undefined && transparency) {
         transparent = {
@@ -1195,91 +1051,77 @@ THREE.ColladaLoader.prototype = {
           }
         };
       }
-
       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:
               console.warn('THREE.ColladaLoader: Invalid opaque type "%s" of transparent tag.', transparent.opaque);
           }
-
           if (material.opacity < 1) material.transparent = true;
         }
-      } //
+      }
 
+      //
 
       if (extra !== undefined && extra.technique !== undefined && extra.technique.double_sided === 1) {
         material.side = THREE.DoubleSide;
       }
-
       return material;
     }
-
     function getMaterial(id) {
       return getBuild(library.materials[id], buildMaterial);
-    } // camera
+    }
 
+    // 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":
@@ -1288,16 +1130,12 @@ THREE.ColladaLoader.prototype = {
             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":
@@ -1310,18 +1148,14 @@ THREE.ColladaLoader.prototype = {
             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;
@@ -1330,55 +1164,46 @@ THREE.ColladaLoader.prototype = {
           ymag = ymag === undefined ? xmag / aspectRatio : ymag;
           xmag *= 0.5;
           ymag *= 0.5;
-          camera = new THREE.OrthographicCamera(-xmag, xmag, ymag, -ymag, // left, right, top, bottom
+          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
+    }
 
+    // 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":
@@ -1388,74 +1213,59 @@ THREE.ColladaLoader.prototype = {
             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
+    }
 
+    // geometry
 
     function parseGeometry(xml) {
       var data = {
@@ -1464,89 +1274,71 @@ THREE.ColladaLoader.prototype = {
         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
+      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,
@@ -1556,11 +1348,9 @@ THREE.ColladaLoader.prototype = {
         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"));
@@ -1575,69 +1365,61 @@ THREE.ColladaLoader.prototype = {
             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
+      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)
+        var primitiveType = groupedPrimitives[type];
 
-        checkUVCoordinates(primitiveType); // third, create a buffer geometry for each type of primitives
+        // 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 = {
@@ -1671,140 +1453,120 @@ THREE.ColladaLoader.prototype = {
       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 inputs = primitive.inputs;
 
-        var count = 0;
+        // 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
+        start += count;
+
+        // material
 
         if (primitive.material) {
           materialKeys.push(primitive.material);
-        } // geometry data
+        }
 
+        // 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
+                    }
 
+                    // see #3803
 
                     if (primitive.hasUV === false && primitives.uvsNeedsFix === true) {
                       var count = (position.array.length - prevLength) / position.stride;
-
                       for (var i = 0; i < count; 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
+      }
 
+      // build geometry
 
       if (position.array.length > 0) geometry.addAttribute("position", new THREE.Float32BufferAttribute(position.array, position.stride));
       if (normal.array.length > 0) geometry.addAttribute("normal", new THREE.Float32BufferAttribute(normal.array, normal.stride));
@@ -1818,30 +1580,23 @@ THREE.ColladaLoader.prototype = {
       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 count = vcount[i];
-
           if (count === 4) {
             var a = index + stride * 0;
             var b = index + stride * 1;
@@ -1870,7 +1625,6 @@ THREE.ColladaLoader.prototype = {
               pushVector(c);
             }
           }
-
           index += stride * count;
         }
       } else {
@@ -1879,11 +1633,11 @@ THREE.ColladaLoader.prototype = {
         }
       }
     }
-
     function getGeometry(id) {
       return getBuild(library.geometries[id], buildGeometry);
-    } // kinematics
+    }
 
+    // kinematics
 
     function parseKinematicsModel(xml) {
       var data = {
@@ -1891,54 +1645,43 @@ THREE.ColladaLoader.prototype = {
         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":
@@ -1946,10 +1689,8 @@ THREE.ColladaLoader.prototype = {
             break;
         }
       }
-
       return data;
     }
-
     function parseKinematicsJointParameter(xml, data) {
       var data = {
         sid: xml.getAttribute("sid"),
@@ -1964,17 +1705,14 @@ THREE.ColladaLoader.prototype = {
         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];
@@ -1982,18 +1720,19 @@ THREE.ColladaLoader.prototype = {
             data.limits.min = parseFloat(min.textContent);
             break;
         }
-      } // if min is equal to or greater than max, consider the joint static
+      }
 
+      // 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
+      }
 
+      // calculate middle position
 
       data.middlePosition = (data.limits.min + data.limits.max) / 2.0;
       return data;
     }
-
     function parseKinematicsLink(xml) {
       var data = {
         sid: xml.getAttribute("sid"),
@@ -2001,16 +1740,13 @@ THREE.ColladaLoader.prototype = {
         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":
@@ -2018,26 +1754,21 @@ THREE.ColladaLoader.prototype = {
             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":
@@ -2045,48 +1776,41 @@ THREE.ColladaLoader.prototype = {
             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.Math.degToRad(array[3]);
           break;
       }
-
       return data;
-    } // physics
+    }
 
+    // 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")] = {};
@@ -2094,15 +1818,12 @@ THREE.ColladaLoader.prototype = {
             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);
@@ -2110,53 +1831,45 @@ THREE.ColladaLoader.prototype = {
         }
       }
     }
-
     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
+    }
 
+    // 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];
@@ -2166,19 +1879,15 @@ THREE.ColladaLoader.prototype = {
             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];
@@ -2189,20 +1898,22 @@ THREE.ColladaLoader.prototype = {
       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 axis = bindJointAxis[i];
 
-        var targetElement = collada.querySelector('[sid="' + axis.target + '"]');
+        // 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 transfrom element
-          var parentVisualElement = targetElement.parentElement; // connect the joint of the kinematics model with the element in the visual scene
+
+          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];
@@ -2217,13 +1928,11 @@ THREE.ColladaLoader.prototype = {
           }
         });
       }
-
       var m0 = new THREE.Matrix4();
       kinematics = {
         joints: kinematicsModel && kinematicsModel.joints,
         getJointValue: function getJointValue(jointIndex) {
           var jointData = jointMap[jointIndex];
-
           if (jointData) {
             return jointData.position;
           } else {
@@ -2232,10 +1941,8 @@ THREE.ColladaLoader.prototype = {
         },
         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"]) {
@@ -2244,21 +1951,23 @@ THREE.ColladaLoader.prototype = {
               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
+              matrix.identity();
+
+              // each update, we have to apply all transforms in the correct order
 
               for (var i = 0; i < transforms.length; i++) {
-                var transform = transforms[i]; // if there is a connection of the transform node with a joint, apply the joint value
+                var transform = transforms[i];
+
+                // 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.Math.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;
@@ -2268,22 +1977,18 @@ THREE.ColladaLoader.prototype = {
                     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;
@@ -2294,15 +1999,12 @@ THREE.ColladaLoader.prototype = {
         }
       };
     }
-
     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;
-
         switch (child.nodeName) {
           case "matrix":
             var array = parseFloats(child.textContent);
@@ -2313,7 +2015,6 @@ THREE.ColladaLoader.prototype = {
               obj: matrix
             });
             break;
-
           case "translate":
           case "scale":
             var array = parseFloats(child.textContent);
@@ -2324,7 +2025,6 @@ THREE.ColladaLoader.prototype = {
               obj: vector
             });
             break;
-
           case "rotate":
             var array = parseFloats(child.textContent);
             var vector = new THREE.Vector3().fromArray(array);
@@ -2338,26 +2038,25 @@ THREE.ColladaLoader.prototype = {
             break;
         }
       }
-
       return transforms;
-    } // nodes
+    }
 
+    // nodes
 
     function prepareNodes(xml) {
-      var elements = xml.getElementsByTagName("node"); // ensure all node elements have id attributes
+      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") || "",
@@ -2373,136 +2072,112 @@ THREE.ColladaLoader.prototype = {
         instanceNodes: [],
         transforms: {}
       };
-
       for (var i = 0; i < xml.childNodes.length; i++) {
         var child = xml.childNodes[i];
         if (child.nodeType !== 1) continue;
-
         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":
             var array = parseFloats(child.textContent);
             data.matrix.multiply(matrix.fromArray(array).transpose());
             data.transforms[child.getAttribute("sid")] = child.nodeName;
             break;
-
           case "translate":
             var 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":
             var array = parseFloats(child.textContent);
             var angle = THREE.Math.degToRad(array[3]);
             data.matrix.multiply(matrix.makeRotationAxis(vector.fromArray(array), angle));
             data.transforms[child.getAttribute("sid")] = child.nodeName;
             break;
-
           case "scale":
             var 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
+      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;
-
         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);
@@ -2511,68 +2186,67 @@ THREE.ColladaLoader.prototype = {
         } 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)
+      }
 
+      // 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
+      }
 
+      // 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
+      }
 
+      // 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
+          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,
@@ -2581,7 +2255,6 @@ THREE.ColladaLoader.prototype = {
         }
       });
     }
-
     function buildNode(data) {
       var objects = [];
       var matrix = data.matrix;
@@ -2591,21 +2264,24 @@ THREE.ColladaLoader.prototype = {
       var instanceControllers = data.instanceControllers;
       var instanceLights = data.instanceLights;
       var instanceGeometries = data.instanceGeometries;
-      var instanceNodes = data.instanceNodes; // nodes
+      var instanceNodes = data.instanceNodes;
+
+      // nodes
 
       for (var i = 0, l = nodes.length; i < l; i++) {
         objects.push(getNode(nodes[i]));
-      } // instance cameras
+      }
 
+      // instance cameras
 
       for (var i = 0, l = instanceCameras.length; i < l; i++) {
         var instanceCamera = getCamera(instanceCameras[i]);
-
         if (instanceCamera !== null) {
           objects.push(instanceCamera.clone());
         }
-      } // instance controllers
+      }
 
+      // instance controllers
 
       for (var i = 0, l = instanceControllers.length; i < l; i++) {
         var instance = instanceControllers[i];
@@ -2615,77 +2291,68 @@ THREE.ColladaLoader.prototype = {
         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
+      }
 
+      // instance lights
 
       for (var i = 0, l = instanceLights.length; i < l; i++) {
         var instanceLight = getLight(instanceLights[i]);
-
         if (instanceLight !== null) {
           objects.push(instanceLight.clone());
         }
-      } // instance geometries
+      }
 
+      // instance geometries
 
       for (var i = 0, l = instanceGeometries.length; i < l; i++) {
-        var instance = instanceGeometries[i]; // a single geometry instance in collada can lead to multiple object3Ds.
+        var instance = instanceGeometries[i];
+
+        // 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 j = 0, jl = newObjects.length; j < jl; j++) {
           objects.push(newObjects[j]);
         }
-      } // instance nodes
+      }
 
+      // instance nodes
 
       for (var i = 0, l = instanceNodes.length; i < l; i++) {
         objects.push(getNode(instanceNodes[i]).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 i = 0; i < objects.length; i++) {
           object.add(objects[i]);
         }
       }
-
       if (object.name === "") {
         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);
@@ -2693,16 +2360,15 @@ THREE.ColladaLoader.prototype = {
           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
+        var materials = resolveMaterialBinding(geometry.materialKeys, instanceMaterials);
+
+        // handle case if no materials are defined
 
         if (materials.length === 0) {
           if (type === "lines" || type === "linestrips") {
@@ -2710,31 +2376,31 @@ THREE.ColladaLoader.prototype = {
           } else {
             materials.push(new THREE.MeshPhongMaterial());
           }
-        } // regard skinning
+        }
 
+        // regard skinning
 
         var skinning = geometry.data.attributes.skinIndex !== undefined;
-
         if (skinning) {
           for (var i = 0, l = materials.length; i < l; i++) {
             materials[i].skinning = true;
           }
-        } // choose between a single or multi materials (material array)
+        }
 
+        // choose between a single or multi materials (material array)
 
-        var material = materials.length === 1 ? materials[0] : materials; // now create a specific 3D object
+        var material = materials.length === 1 ? materials[0] : materials;
 
-        var object;
+        // now create a specific 3D object
 
+        var object;
         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) {
@@ -2742,24 +2408,20 @@ THREE.ColladaLoader.prototype = {
             } 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
+    }
 
+    // visual scenes
 
     function parseVisualScene(xml) {
       var data = {
@@ -2768,57 +2430,47 @@ THREE.ColladaLoader.prototype = {
       };
       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
+    }
 
+    // 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 = [];
 
+          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 {
@@ -2827,15 +2479,15 @@ THREE.ColladaLoader.prototype = {
         }
       }
     }
-
     if (text.length === 0) {
       return {
         scene: new THREE.Scene()
       };
     }
-
     var xml = new DOMParser().parseFromString(text, "application/xml");
-    var collada = getElementsByTagName(xml, "COLLADA")[0]; // metadata
+    var collada = getElementsByTagName(xml, "COLLADA")[0];
+
+    // metadata
 
     var version = collada.getAttribute("version");
     console.log("THREE.ColladaLoader: File version", version);
@@ -2843,16 +2495,18 @@ THREE.ColladaLoader.prototype = {
     var textureLoader = new THREE.TextureLoader(this.manager);
     textureLoader.setPath(this.resourcePath || path).setCrossOrigin(this.crossOrigin);
     var tgaLoader;
-
     if (THREE.TGALoader) {
       tgaLoader = new THREE.TGALoader(this.manager);
       tgaLoader.setPath(this.resourcePath || path);
-    } //
+    }
 
+    //
 
     var animations = [];
     var kinematics = {};
-    var count = 0; //
+    var count = 0;
+
+    //
 
     var library = {
       animations: {},
@@ -2897,11 +2551,9 @@ THREE.ColladaLoader.prototype = {
     setupAnimations();
     setupKinematics();
     var scene = parseScene(getElementsByTagName(collada, "scene")[0]);
-
     if (asset.upAxis === "Z_UP") {
       scene.quaternion.setFromEuler(new THREE.Euler(-Math.PI / 2, 0, 0));
     }
-
     scene.scale.multiplyScalar(asset.unit);
     return {
       animations: animations,
@@ -2910,7 +2562,7 @@ THREE.ColladaLoader.prototype = {
       scene: scene
     };
   }
-}; // important: don't forget to export it
+};
 
-var _default = THREE.ColladaLoader;
-exports["default"] = _default;
+// important: don't forget to export it
+var _default = exports["default"] = THREE.ColladaLoader;