﻿/**
 * @author mrdoob / http://mrdoob.com/
 * @author Mugen87 / https://github.com/Mugen87
 */

THREE.ColladaLoader = function (manager) {

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

};

THREE.ColladaLoader.prototype = {

    constructor: THREE.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.load(url, function (text) {

            onLoad(scope.parse(text, path));

        }, onProgress, onError);

    },

    setPath: function (value) {

        this.path = 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 '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.MeshLambertMaterial();
                    break;

                default:
                    material = new THREE.MeshBasicMaterial();
                    break;

            }

            material.name = data.name;

            function getTexture(textureObject) {

                var sampler = effect.profile.samplers[textureObject.id];
                var image = null;

                // get image

                if (sampler !== undefined) {

                    var surface = effect.profile.surfaces[sampler.source];
                    image = getImage(surface.init_from);

                } else {

                    console.warn('THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530).');
                    image = getImage(textureObject.id);

                }

                // create texture if image is avaiable

                if (image !== null) {

                    var loader = getTextureLoader(image);

                    if (loader !== undefined) {

                        var texture = loader.load(image);

                        var extra = textureObject.extra;

                        if (extra !== undefined && extra.technique !== undefined && isEmpty(extra.technique) === false) {

                            var technique = extra.technique;

                            texture.wrapS = technique.wrapU ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
                            texture.wrapT = technique.wrapV ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;

                            texture.offset.set(technique.offsetU || 0, technique.offsetV || 0);
                            texture.repeat.set(technique.repeatU || 1, technique.repeatV || 1);

                        } else {

                            texture.wrapS = THREE.RepeatWrapping;
                            texture.wrapT = THREE.RepeatWrapping;

                        }

                        return texture;

                    } else {

                        console.warn('THREE.ColladaLoader: Loader for texture %s not found.', image);

                        return null;

                    }

                } else {

                    console.warn('THREE.ColladaLoader: Couldn\'t create texture with ID:', textureObject.id);

                    return null;

                }

            }

            var parameters = technique.parameters;

            for (var key in parameters) {

                var parameter = parameters[key];

                switch (key) {

                    case 'diffuse':
                        if (parameter.color) material.color.fromArray(parameter.color);
                        if (parameter.texture) material.map = getTexture(parameter.texture);
                        break;
                    case 'specular':
                        if (parameter.color && material.specular) material.specular.fromArray(parameter.color);
                        if (parameter.texture) material.specularMap = getTexture(parameter.texture);
                        break;
                    case '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'));
                        primitive.inputs[semantic] = { 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 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;

                                    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;

                    }

                }

            }

            // 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 (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.MeshBasicMaterial({ color: 0xff00ff });

        function resolveMaterialBinding(keys, instanceMaterials) {

            var materials = [];

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

                var id = instanceMaterials[keys[i]];

                if (id === undefined) {

                    console.warn('THREE.ColladaLoader: Material with key %s not found. Apply fallback material.', keys[i]);
                    materials.push(fallbackMaterial);

                } else {

                    materials.push(getMaterial(id));

                }

            }

            return materials;

        }

        function buildObjects(geometries, instanceMaterials) {

            var objects = [];

            for (var type in geometries) {

                var geometry = geometries[type];

                var materials = resolveMaterialBinding(geometry.materialKeys, instanceMaterials);

                // handle case if no materials are defined

                if (materials.length === 0) {

                    if (type === 'lines' || type === 'linestrips') {

                        materials.push(new THREE.LineBasicMaterial());

                    } else {

                        materials.push(new THREE.MeshPhongMaterial());

                    }

                }

                // regard skinning

                var skinning = (geometry.data.attributes.skinIndex !== undefined);

                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(path).setCrossOrigin(this.crossOrigin);

        var tgaLoader;

        if (THREE.TGALoader) {

            tgaLoader = new THREE.TGALoader(this.manager);
            tgaLoader.setPath(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
        };

    }

};