@things-factory/scene-visualizer 6.0.1 → 6.0.5

package/src/loaders/ColladaLoader.js

@@ -1,3166 +0,0 @@
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author Mugen87 / https://github.com/Mugen87
- */
-
-import * as THREE from 'three'
-import TGALoader from './TGALoader'
-
-function ColladaLoader(manager) {
-  this.manager = manager !== undefined ? manager : THREE.DefaultLoadingManager
-}
-
-ColladaLoader.prototype = {
-  constructor: ColladaLoader,
-
-  crossOrigin: 'anonymous',
-
-  load: function(url, onLoad, onProgress, onError) {
-    var scope = this
-
-    var path = scope.path === undefined ? THREE.LoaderUtils.extractUrlBase(url) : scope.path
-
-    var loader = new THREE.FileLoader(scope.manager)
-    loader.setPath(scope.path)
-    loader.load(
-      url,
-      function(text) {
-        onLoad(scope.parse(text, path))
-      },
-      onProgress,
-      onError
-    )
-  },
-
-  setPath: function(value) {
-    this.path = value
-    return this
-  },
-
-  setResourcePath: function(value) {
-    this.resourcePath = value
-    return this
-  },
-
-  options: {
-    set convertUpAxis(value) {
-      console.warn('THREE.ColladaLoader: options.convertUpAxis() has been removed. Up axis is converted automatically.')
-    }
-  },
-
-  setCrossOrigin: function(value) {
-    this.crossOrigin = value
-    return this
-  },
-
-  parse: function(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: {}
-      }
-
-      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'))
-            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
-        }
-      }
-
-      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
-        }
-      }
-    }
-
-    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
-
-    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.MeshStandardMaterial()
-          break
-
-        default:
-          material = new THREE.MeshStandardMaterial()
-          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:
-              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
-
-    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 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
-
-      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))
-      if (color.array.length > 0)
-        geometry.addAttribute('color', new THREE.Float32BufferAttribute(color.array, color.stride))
-      if (uv.array.length > 0) geometry.addAttribute('uv', new THREE.Float32BufferAttribute(uv.array, uv.stride))
-      if (uv2.array.length > 0) geometry.addAttribute('uv2', new THREE.Float32BufferAttribute(uv2.array, uv2.stride))
-
-      if (skinIndex.array.length > 0)
-        geometry.addAttribute('skinIndex', new THREE.Float32BufferAttribute(skinIndex.array, skinIndex.stride))
-      if (skinWeight.array.length > 0)
-        geometry.addAttribute('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 count = vcount[i]
-
-          if (count === 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 (count === 3) {
-            var a = index + stride * 0
-            var b = index + stride * 1
-            var c = index + stride * 2
-
-            pushVector(a)
-            pushVector(b)
-            pushVector(c)
-          } else if (count > 4) {
-            for (var k = 1, kl = count - 2; k <= kl; k++) {
-              var a = index + stride * 0
-              var b = index + stride * k
-              var c = index + stride * (k + 1)
-
-              pushVector(a)
-              pushVector(b)
-              pushVector(c)
-            }
-          }
-
-          index += stride * count
-        }
-      } 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, data) {
-      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.Math.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 transfrom 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(jointIndex) {
-          var jointData = jointMap[jointIndex]
-
-          if (jointData) {
-            return jointData.position
-          } else {
-            console.warn('THREE.ColladaLoader: Joint ' + jointIndex + " doesn't exist.")
-          }
-        },
-
-        setJointValue: function(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 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
-
-                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
-                  }
-                } 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
-
-        switch (child.nodeName) {
-          case 'matrix':
-            var 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':
-            var array = parseFloats(child.textContent)
-            var vector = new THREE.Vector3().fromArray(array)
-            transforms.push({
-              sid: child.getAttribute('sid'),
-              type: child.nodeName,
-              obj: vector
-            })
-            break
-
-          case 'rotate':
-            var array = parseFloats(child.textContent)
-            var vector = new THREE.Vector3().fromArray(array)
-            var angle = THREE.Math.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
-
-        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
-      // 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)
-            }
-          }
-        } 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 i = 0, l = instanceCameras.length; i < l; i++) {
-        var instanceCamera = getCamera(instanceCameras[i])
-
-        if (instanceCamera !== null) {
-          objects.push(instanceCamera.clone())
-        }
-      }
-
-      // instance controllers
-
-      for (var i = 0, l = instanceControllers.length; i < l; i++) {
-        var instance = instanceControllers[i]
-        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 i = 0, l = instanceLights.length; i < l; i++) {
-        var instanceLight = getLight(instanceLights[i])
-
-        if (instanceLight !== null) {
-          objects.push(instanceLight.clone())
-        }
-      }
-
-      // 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.
-        // 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
-
-      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.MeshStandardMaterial({ 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
-
-        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)
-
-        var material = materials.length === 1 ? materials[0] : materials
-
-        // 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) {
-              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))
-        }
-      }
-    }
-
-    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 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 = new 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])
-
-    if (asset.upAxis === 'Z_UP') {
-      scene.quaternion.setFromEuler(new THREE.Euler(-Math.PI / 2, 0, 0))
-    }
-
-    scene.scale.multiplyScalar(asset.unit)
-
-    return {
-      animations: animations,
-      kinematics: kinematics,
-      library: library,
-      scene: scene
-    }
-  }
-}
-
-export default ColladaLoader