cesiumDemo/Source/ThirdParty/GltfPipeline/updateVersion.js

import addExtensionsUsed from './addExtensionsUsed.js'
import addToArray from './addToArray.js'
import findAccessorMinMax from './findAccessorMinMax.js'
import ForEach from './ForEach.js'
import getAccessorByteStride from './getAccessorByteStride.js'
import numberOfComponentsForType from './numberOfComponentsForType.js'
import moveTechniqueRenderStates from './moveTechniqueRenderStates.js'
import moveTechniquesToExtension from './moveTechniquesToExtension.js'
import removeUnusedElements from './removeUnusedElements.js'
import updateAccessorComponentTypes from './updateAccessorComponentTypes.js'
import Cartesian3 from '../../Core/Cartesian3.js'
import Cartesian4 from '../../Core/Cartesian4.js'
import clone from '../../Core/clone.js'
import ComponentDatatype from '../../Core/ComponentDatatype.js'
import defaultValue from '../../Core/defaultValue.js'
import defined from '../../Core/defined.js'
import isArray from '../../Core/isArray.js'
import Matrix4 from '../../Core/Matrix4.js'
import Quaternion from '../../Core/Quaternion.js'
import WebGLConstants from '../../Core/WebGLConstants.js'

    var updateFunctions = {
        '0.8': glTF08to10,
        '1.0': glTF10to20,
        '2.0': undefined
    };

    /**
     * Update the glTF version to the latest version (2.0), or targetVersion if specified.
     * Applies changes made to the glTF spec between revisions so that the core library
     * only has to handle the latest version.
     *
     * @param {Object} gltf A javascript object containing a glTF asset.
     * @param {Object} [options] Options for updating the glTF.
     * @param {String} [options.targetVersion] The glTF will be upgraded until it hits the specified version.
     * @returns {Object} The updated glTF asset.
     *
     * @private
     */
    function updateVersion(gltf, options) {
        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
        var targetVersion = options.targetVersion;
        var version = gltf.version;

        gltf.asset = defaultValue(gltf.asset, {
            version: '1.0'
        });

        gltf.asset.version = defaultValue(gltf.asset.version, '1.0');
        version = defaultValue(version, gltf.asset.version).toString();

        // Invalid version
        if (!Object.prototype.hasOwnProperty.call(updateFunctions, version)) {
            // Try truncating trailing version numbers, could be a number as well if it is 0.8
            if (defined(version)) {
                version = version.substring(0, 3);
            }
            // Default to 1.0 if it cannot be determined
            if (!Object.prototype.hasOwnProperty.call(updateFunctions, version)) {
                version = '1.0';
            }
        }

        var updateFunction = updateFunctions[version];

        while (defined(updateFunction)) {
            if (version === targetVersion) {
                break;
            }
            updateFunction(gltf, options);
            version = gltf.asset.version;
            updateFunction = updateFunctions[version];
        }
        return gltf;
    }

    function updateInstanceTechniques(gltf) {
        var materials = gltf.materials;
        for (var materialId in materials) {
            if (Object.prototype.hasOwnProperty.call(materials, materialId)) {
                var material = materials[materialId];
                var instanceTechnique = material.instanceTechnique;
                if (defined(instanceTechnique)) {
                    material.technique = instanceTechnique.technique;
                    material.values = instanceTechnique.values;
                    delete material.instanceTechnique;
                }
            }
        }
    }

    function setPrimitiveModes(gltf) {
        var meshes = gltf.meshes;
        for (var meshId in meshes) {
            if (Object.prototype.hasOwnProperty.call(meshes, meshId)) {
                var mesh = meshes[meshId];
                var primitives = mesh.primitives;
                if (defined(primitives)) {
                    var primitivesLength = primitives.length;
                    for (var i = 0; i < primitivesLength; ++i) {
                        var primitive = primitives[i];
                        var defaultMode = defaultValue(primitive.primitive, WebGLConstants.TRIANGLES);
                        primitive.mode = defaultValue(primitive.mode, defaultMode);
                        delete primitive.primitive;
                    }
                }
            }
        }
    }

    function updateNodes(gltf) {
        var nodes = gltf.nodes;
        var axis = new Cartesian3();
        var quat = new Quaternion();
        for (var nodeId in nodes) {
            if (Object.prototype.hasOwnProperty.call(nodes, nodeId)) {
                var node = nodes[nodeId];
                if (defined(node.rotation)) {
                    var rotation = node.rotation;
                    Cartesian3.fromArray(rotation, 0, axis);
                    Quaternion.fromAxisAngle(axis, rotation[3], quat);
                    node.rotation = [quat.x, quat.y, quat.z, quat.w];
                }
                var instanceSkin = node.instanceSkin;
                if (defined(instanceSkin)) {
                    node.skeletons = instanceSkin.skeletons;
                    node.skin = instanceSkin.skin;
                    node.meshes = instanceSkin.meshes;
                    delete node.instanceSkin;
                }
            }
        }
    }

    function updateAnimations(gltf) {
        var animations = gltf.animations;
        var accessors = gltf.accessors;
        var bufferViews = gltf.bufferViews;
        var buffers = gltf.buffers;
        var updatedAccessors = {};
        var axis = new Cartesian3();
        var quat = new Quaternion();
        for (var animationId in animations) {
            if (Object.prototype.hasOwnProperty.call(animations, animationId)) {
                var animation = animations[animationId];
                var channels = animation.channels;
                var parameters = animation.parameters;
                var samplers = animation.samplers;
                if (defined(channels)) {
                    var channelsLength = channels.length;
                    for (var i = 0; i < channelsLength; ++i) {
                        var channel = channels[i];
                        if (channel.target.path === 'rotation') {
                            var accessorId = parameters[samplers[channel.sampler].output];
                            if (defined(updatedAccessors[accessorId])) {
                                continue;
                            }
                            updatedAccessors[accessorId] = true;
                            var accessor = accessors[accessorId];
                            var bufferView = bufferViews[accessor.bufferView];
                            var buffer = buffers[bufferView.buffer];
                            var source = buffer.extras._pipeline.source;
                            var byteOffset = source.byteOffset + bufferView.byteOffset + accessor.byteOffset;
                            var componentType = accessor.componentType;
                            var count = accessor.count;
                            var componentsLength = numberOfComponentsForType(accessor.type);
                            var length = accessor.count * componentsLength;
                            var typedArray = ComponentDatatype.createArrayBufferView(componentType, source.buffer, byteOffset, length);

                            for (var j = 0; j < count; j++) {
                                var offset = j * componentsLength;
                                Cartesian3.unpack(typedArray, offset, axis);
                                var angle = typedArray[offset + 3];
                                Quaternion.fromAxisAngle(axis, angle, quat);
                                Quaternion.pack(quat, typedArray, offset);
                            }
                        }
                    }
                }
            }
        }
    }

    function removeTechniquePasses(gltf) {
        var techniques = gltf.techniques;
        for (var techniqueId in techniques) {
            if (Object.prototype.hasOwnProperty.call(techniques, techniqueId)) {
                var technique = techniques[techniqueId];
                var passes = technique.passes;
                if (defined(passes)) {
                    var passName = defaultValue(technique.pass, 'defaultPass');
                    if (Object.prototype.hasOwnProperty.call(passes, passName)) {
                        var pass = passes[passName];
                        var instanceProgram = pass.instanceProgram;
                        technique.attributes = defaultValue(technique.attributes, instanceProgram.attributes);
                        technique.program = defaultValue(technique.program, instanceProgram.program);
                        technique.uniforms = defaultValue(technique.uniforms, instanceProgram.uniforms);
                        technique.states = defaultValue(technique.states, pass.states);
                    }
                    delete technique.passes;
                    delete technique.pass;
                }
            }
        }
    }

    function glTF08to10(gltf) {
        if (!defined(gltf.asset)) {
            gltf.asset = {};
        }
        var asset = gltf.asset;
        asset.version = '1.0';
        // Profile should be an object, not a string
        if (typeof asset.profile === 'string') {
            var split = asset.profile.split(' ');
            asset.profile = {
                api: split[0],
                version: split[1]
            };
        } else {
            asset.profile = {};
        }

        // Version property should be in asset, not on the root element
        if (defined(gltf.version)) {
            delete gltf.version;
        }
        // material.instanceTechnique properties should be directly on the material
        updateInstanceTechniques(gltf);
        // primitive.primitive should be primitive.mode
        setPrimitiveModes(gltf);
        // Node rotation should be quaternion, not axis-angle
        // node.instanceSkin is deprecated
        updateNodes(gltf);
        // Animations that target rotations should be quaternion, not axis-angle
        updateAnimations(gltf);
        // technique.pass and techniques.passes are deprecated
        removeTechniquePasses(gltf);
        // gltf.allExtensions -> extensionsUsed
        if (defined(gltf.allExtensions)) {
            gltf.extensionsUsed = gltf.allExtensions;
            delete gltf.allExtensions;
        }
        // gltf.lights -> khrMaterialsCommon.lights
        if (defined(gltf.lights)) {
            var extensions = defaultValue(gltf.extensions, {});
            gltf.extensions = extensions;
            var materialsCommon = defaultValue(extensions.KHR_materials_common, {});
            extensions.KHR_materials_common = materialsCommon;
            materialsCommon.lights = gltf.lights;
            delete gltf.lights;
            addExtensionsUsed(gltf, 'KHR_materials_common');
        }
    }

    function removeAnimationSamplersIndirection(gltf) {
        var animations = gltf.animations;
        for (var animationId in animations) {
            if (Object.prototype.hasOwnProperty.call(animations, animationId)) {
                var animation = animations[animationId];
                var parameters = animation.parameters;
                if (defined(parameters)) {
                    var samplers = animation.samplers;
                    for (var samplerId in samplers) {
                        if (Object.prototype.hasOwnProperty.call(samplers, samplerId)) {
                            var sampler = samplers[samplerId];
                            sampler.input = parameters[sampler.input];
                            sampler.output = parameters[sampler.output];
                        }
                    }
                    delete animation.parameters;
                }
            }
        }
    }

    function objectToArray(object, mapping) {
        var array = [];
        for (var id in object) {
            if (Object.prototype.hasOwnProperty.call(object, id)) {
                var value = object[id];
                mapping[id] = array.length;
                array.push(value);
                if (!defined(value.name)) {
                    value.name = id;
                }
            }
        }
        return array;
    }

    function objectsToArrays(gltf) {
        var i;
        var globalMapping = {
            accessors: {},
            animations: {},
            buffers: {},
            bufferViews: {},
            cameras: {},
            images: {},
            materials: {},
            meshes: {},
            nodes: {},
            programs: {},
            samplers: {},
            scenes: {},
            shaders: {},
            skins: {},
            textures: {},
            techniques: {}
        };

        // Map joint names to id names
        var jointName;
        var jointNameToId = {};
        var nodes = gltf.nodes;
        for (var id in nodes) {
            if (Object.prototype.hasOwnProperty.call(nodes, id)) {
                jointName = nodes[id].jointName;
                if (defined(jointName)) {
                    jointNameToId[jointName] = id;
                }
            }
        }

        // Convert top level objects to arrays
        for (var topLevelId in gltf) {
            if (Object.prototype.hasOwnProperty.call(gltf, topLevelId) && defined(globalMapping[topLevelId])) {
                var objectMapping = {};
                var object = gltf[topLevelId];
                gltf[topLevelId] = objectToArray(object, objectMapping);
                globalMapping[topLevelId] = objectMapping;
            }
        }

        // Remap joint names to array indexes
        for (jointName in jointNameToId) {
            if (Object.prototype.hasOwnProperty.call(jointNameToId, jointName)) {
                jointNameToId[jointName] = globalMapping.nodes[jointNameToId[jointName]];
            }
        }

        // Fix references
        if (defined(gltf.scene)) {
            gltf.scene = globalMapping.scenes[gltf.scene];
        }
        ForEach.bufferView(gltf, function(bufferView) {
            if (defined(bufferView.buffer)) {
                bufferView.buffer = globalMapping.buffers[bufferView.buffer];
            }
        });
        ForEach.accessor(gltf, function(accessor) {
            if (defined(accessor.bufferView)) {
                accessor.bufferView = globalMapping.bufferViews[accessor.bufferView];
            }
        });
        ForEach.shader(gltf, function(shader) {
            var extensions = shader.extensions;
            if (defined(extensions)) {
                var binaryGltf = extensions.KHR_binary_glTF;
                if (defined(binaryGltf)) {
                    shader.bufferView = globalMapping.bufferViews[binaryGltf.bufferView];
                    delete extensions.KHR_binary_glTF;
                }
                if (Object.keys(extensions).length === 0) {
                    delete shader.extensions;
                }
            }
        });
        ForEach.program(gltf, function(program) {
            if (defined(program.vertexShader)) {
                program.vertexShader = globalMapping.shaders[program.vertexShader];
            }
            if (defined(program.fragmentShader)) {
                program.fragmentShader = globalMapping.shaders[program.fragmentShader];
            }
        });
        ForEach.technique(gltf, function(technique) {
            if (defined(technique.program)) {
                technique.program = globalMapping.programs[technique.program];
            }
            ForEach.techniqueParameter(technique, function(parameter) {
                if (defined(parameter.node)) {
                    parameter.node = globalMapping.nodes[parameter.node];
                }
                var value = parameter.value;
                if (typeof value === 'string') {
                    parameter.value = {
                        index: globalMapping.textures[value]
                    };
                }
            });
        });
        ForEach.mesh(gltf, function(mesh) {
            ForEach.meshPrimitive(mesh, function(primitive) {
                if (defined(primitive.indices)) {
                    primitive.indices = globalMapping.accessors[primitive.indices];
                }
                ForEach.meshPrimitiveAttribute(primitive, function(accessorId, semantic) {
                    primitive.attributes[semantic] = globalMapping.accessors[accessorId];
                });
                if (defined(primitive.material)) {
                    primitive.material = globalMapping.materials[primitive.material];
                }
            });
        });
        ForEach.node(gltf, function(node) {
            var children = node.children;
            if (defined(children)) {
                var childrenLength = children.length;
                for (i = 0; i < childrenLength; ++i) {
                    children[i] = globalMapping.nodes[children[i]];
                }
            }
            if (defined(node.meshes)) {
                // Split out meshes on nodes
                var meshes = node.meshes;
                var meshesLength = meshes.length;
                if (meshesLength > 0) {
                    node.mesh = globalMapping.meshes[meshes[0]];
                    for (i = 1; i < meshesLength; ++i) {
                        var meshNode = {
                            mesh: globalMapping.meshes[meshes[i]]
                        };
                        var meshNodeId = addToArray(gltf.nodes, meshNode);
                        if (!defined(children)) {
                            children = [];
                            node.children = children;
                        }
                        children.push(meshNodeId);
                    }
                }
                delete node.meshes;
            }
            if (defined(node.camera)) {
                node.camera = globalMapping.cameras[node.camera];
            }
            if (defined(node.skin)) {
                node.skin = globalMapping.skins[node.skin];
            }
            if (defined(node.skeletons)) {
                // Assign skeletons to skins
                var skeletons = node.skeletons;
                var skeletonsLength = skeletons.length;
                if ((skeletonsLength > 0) && defined(node.skin)) {
                    var skin = gltf.skins[node.skin];
                    skin.skeleton = globalMapping.nodes[skeletons[0]];
                }
                delete node.skeletons;
            }
            if (defined(node.jointName)) {
                delete node.jointName;
            }
        });
        ForEach.skin(gltf, function(skin) {
            if (defined(skin.inverseBindMatrices)) {
                skin.inverseBindMatrices = globalMapping.accessors[skin.inverseBindMatrices];
            }
            var jointNames = skin.jointNames;
            if (defined(jointNames)) {
                var joints = [];
                var jointNamesLength = jointNames.length;
                for (i = 0; i < jointNamesLength; ++i) {
                    joints[i] = jointNameToId[jointNames[i]];
                }
                skin.joints = joints;
                delete skin.jointNames;
            }
        });
        ForEach.scene(gltf, function(scene) {
            var sceneNodes = scene.nodes;
            if (defined(sceneNodes)) {
                var sceneNodesLength = sceneNodes.length;
                for (i = 0; i < sceneNodesLength; ++i) {
                    sceneNodes[i] = globalMapping.nodes[sceneNodes[i]];
                }
            }
        });
        ForEach.animation(gltf, function(animation) {
            var samplerMapping = {};
            animation.samplers = objectToArray(animation.samplers, samplerMapping);
            ForEach.animationSampler(animation, function(sampler) {
                sampler.input = globalMapping.accessors[sampler.input];
                sampler.output = globalMapping.accessors[sampler.output];
            });
            ForEach.animationChannel(animation, function(channel) {
                channel.sampler = samplerMapping[channel.sampler];
                var target = channel.target;
                if (defined(target)) {
                    target.node = globalMapping.nodes[target.id];
                    delete target.id;
                }
            });
        });
        ForEach.material(gltf, function(material) {
            if (defined(material.technique)) {
                material.technique = globalMapping.techniques[material.technique];
            }
            ForEach.materialValue(material, function(value, name) {
                if (typeof value === 'string') {
                    material.values[name] = {
                        index: globalMapping.textures[value]
                    };
                }
            });
            var extensions = material.extensions;
            if (defined(extensions)) {
                var materialsCommon = extensions.KHR_materials_common;
                if (defined(materialsCommon)) {
                    ForEach.materialValue(materialsCommon, function(value, name) {
                        if (typeof value === 'string') {
                            materialsCommon.values[name] = {
                                index: globalMapping.textures[value]
                            };
                        }
                    });
                }
            }
        });
        ForEach.image(gltf, function(image) {
            var extensions = image.extensions;
            if (defined(extensions)) {
                var binaryGltf = extensions.KHR_binary_glTF;
                if (defined(binaryGltf)) {
                    image.bufferView = globalMapping.bufferViews[binaryGltf.bufferView];
                    image.mimeType = binaryGltf.mimeType;
                    delete extensions.KHR_binary_glTF;
                }
                if (Object.keys(extensions).length === 0) {
                    delete image.extensions;
                }
            }
            ForEach.compressedImage(image, function(compressedImage) {
                var compressedExtensions = compressedImage.extensions;
                if (defined(compressedExtensions)) {
                    var compressedBinaryGltf = compressedExtensions.KHR_binary_glTF;
                    if (defined(compressedBinaryGltf)) {
                        compressedImage.bufferView = globalMapping.bufferViews[compressedBinaryGltf.bufferView];
                        compressedImage.mimeType = compressedBinaryGltf.mimeType;
                        delete compressedExtensions.KHR_binary_glTF;
                    }
                    if (Object.keys(extensions).length === 0) {
                        delete compressedImage.extensions;
                    }
                }
            });
        });
        ForEach.texture(gltf, function(texture) {
            if (defined(texture.sampler)) {
                texture.sampler = globalMapping.samplers[texture.sampler];
            }
            if (defined(texture.source)) {
                texture.source = globalMapping.images[texture.source];
            }
        });
    }

    function removeAnimationSamplerNames(gltf) {
        ForEach.animation(gltf, function(animation) {
            ForEach.animationSampler(animation, function(sampler) {
                delete sampler.name;
            });
        });
    }

    function removeEmptyArrays(gltf) {
        for (var topLevelId in gltf) {
            if (Object.prototype.hasOwnProperty.call(gltf, topLevelId)) {
                var array = gltf[topLevelId];
                if (isArray(array) && array.length === 0) {
                    delete gltf[topLevelId];
                }
            }
        }
        ForEach.node(gltf, function(node) {
            if (defined(node.children) && node.children.length === 0) {
                delete node.children;
            }
        });
    }

    function stripAsset(gltf) {
        var asset = gltf.asset;
        delete asset.profile;
        delete asset.premultipliedAlpha;
    }

    var knownExtensions = {
        CESIUM_RTC: true,
        KHR_materials_common: true,
        WEB3D_quantized_attributes: true
    };
    function requireKnownExtensions(gltf) {
        var extensionsUsed = gltf.extensionsUsed;
        gltf.extensionsRequired = defaultValue(gltf.extensionsRequired, []);
        if (defined(extensionsUsed)) {
            var extensionsUsedLength = extensionsUsed.length;
            for (var i = 0; i < extensionsUsedLength; ++i) {
                var extension = extensionsUsed[i];
                if (defined(knownExtensions[extension])) {
                    gltf.extensionsRequired.push(extension);
                }
            }
        }
    }

    function removeBufferType(gltf) {
        ForEach.buffer(gltf, function(buffer) {
            delete buffer.type;
        });
    }

    function removeTextureProperties(gltf) {
        ForEach.texture(gltf, function(texture) {
            delete texture.format;
            delete texture.internalFormat;
            delete texture.target;
            delete texture.type;
        });
    }

    function requireAttributeSetIndex(gltf) {
        ForEach.mesh(gltf, function(mesh) {
            ForEach.meshPrimitive(mesh, function(primitive) {
                ForEach.meshPrimitiveAttribute(primitive, function(accessorId, semantic) {
                    if (semantic === 'TEXCOORD') {
                        primitive.attributes.TEXCOORD_0 = accessorId;
                    } else if (semantic === 'COLOR') {
                        primitive.attributes.COLOR_0 = accessorId;
                    }
                });
                delete primitive.attributes.TEXCOORD;
                delete primitive.attributes.COLOR;
            });
        });
        ForEach.technique(gltf, function(technique) {
            ForEach.techniqueParameter(technique, function(parameter) {
                var semantic = parameter.semantic;
                if (defined(semantic)) {
                    if (semantic === 'TEXCOORD') {
                        parameter.semantic = 'TEXCOORD_0';
                    } else if (semantic === 'COLOR') {
                        parameter.semantic = 'COLOR_0';
                    }
                }
            });
        });
    }

    var knownSemantics = {
        POSITION: true,
        NORMAL: true,
        TANGENT: true
    };
    var indexedSemantics = {
        COLOR: 'COLOR',
        JOINT : 'JOINTS',
        JOINTS: 'JOINTS',
        TEXCOORD: 'TEXCOORD',
        WEIGHT: 'WEIGHTS',
        WEIGHTS: 'WEIGHTS'
    };
    function underscoreApplicationSpecificSemantics(gltf) {
        var mappedSemantics = {};
        ForEach.mesh(gltf, function(mesh) {
            ForEach.meshPrimitive(mesh, function(primitive) {
                /*eslint-disable no-unused-vars*/
                ForEach.meshPrimitiveAttribute(primitive, function(accessorId, semantic) {
                    if (semantic.charAt(0) !== '_') {
                        var setIndex = semantic.search(/_[0-9]+/g);
                        var strippedSemantic = semantic;
                        var suffix = '_0';
                        if (setIndex >= 0) {
                            strippedSemantic = semantic.substring(0, setIndex);
                            suffix = semantic.substring(setIndex);
                        }
                        var newSemantic;
                        var indexedSemantic = indexedSemantics[strippedSemantic];
                        if (defined(indexedSemantic)) {
                            newSemantic = indexedSemantic + suffix;
                            mappedSemantics[semantic] = newSemantic;
                        } else if (!defined(knownSemantics[strippedSemantic])) {
                            newSemantic = '_' + semantic;
                            mappedSemantics[semantic] = newSemantic;
                        }
                    }
                });
                for (var semantic in mappedSemantics) {
                    if (Object.prototype.hasOwnProperty.call(mappedSemantics, semantic)) {
                        var mappedSemantic = mappedSemantics[semantic];
                        var accessorId = primitive.attributes[semantic];
                        if (defined(accessorId)) {
                            delete primitive.attributes[semantic];
                            primitive.attributes[mappedSemantic] = accessorId;
                        }
                    }
                }
            });
        });
        ForEach.technique(gltf, function(technique) {
            ForEach.techniqueParameter(technique, function(parameter) {
                var mappedSemantic = mappedSemantics[parameter.semantic];
                if (defined(mappedSemantic)) {
                    parameter.semantic = mappedSemantic;
                }
            });
        });
    }

    function clampCameraParameters(gltf) {
        ForEach.camera(gltf, function(camera) {
            var perspective = camera.perspective;
            if (defined(perspective)) {
                var aspectRatio = perspective.aspectRatio;
                if (defined(aspectRatio) && aspectRatio === 0.0) {
                    delete perspective.aspectRatio;
                }
                var yfov = perspective.yfov;
                if (defined(yfov) && yfov === 0.0) {
                    perspective.yfov = 1.0;
                }
            }
        });
    }

    function computeAccessorByteStride(gltf, accessor) {
        return (defined(accessor.byteStride) && accessor.byteStride !== 0) ? accessor.byteStride : getAccessorByteStride(gltf, accessor);
    }

    function requireByteLength(gltf) {
        ForEach.buffer(gltf, function(buffer) {
            if (!defined(buffer.byteLength)) {
                buffer.byteLength = buffer.extras._pipeline.source.length;
            }
        });
        ForEach.accessor(gltf, function(accessor) {
            var bufferViewId = accessor.bufferView;
            if (defined(bufferViewId)) {
                var bufferView = gltf.bufferViews[bufferViewId];
                var accessorByteStride = computeAccessorByteStride(gltf, accessor);
                var accessorByteEnd = accessor.byteOffset + accessor.count * accessorByteStride;
                bufferView.byteLength = Math.max(defaultValue(bufferView.byteLength, 0), accessorByteEnd);
            }
        });
    }

    function moveByteStrideToBufferView(gltf) {
        var i;
        var j;
        var bufferView;
        var bufferViews = gltf.bufferViews;

        var bufferViewHasVertexAttributes = {};
        ForEach.accessorContainingVertexAttributeData(gltf, function(accessorId) {
            var accessor = gltf.accessors[accessorId];
            if (defined(accessor.bufferView)) {
                bufferViewHasVertexAttributes[accessor.bufferView] = true;
            }
        });

        // Map buffer views to a list of accessors
        var bufferViewMap = {};
        ForEach.accessor(gltf, function(accessor) {
            if (defined(accessor.bufferView)) {
                bufferViewMap[accessor.bufferView] = defaultValue(bufferViewMap[accessor.bufferView], []);
                bufferViewMap[accessor.bufferView].push(accessor);
            }
        });

        // Split accessors with different byte strides
        for (var bufferViewId in bufferViewMap) {
            if (Object.prototype.hasOwnProperty.call(bufferViewMap, bufferViewId)) {
                bufferView = bufferViews[bufferViewId];
                var accessors = bufferViewMap[bufferViewId];
                accessors.sort(function(a, b) {
                    return a.byteOffset - b.byteOffset;
                });
                var currentByteOffset = 0;
                var currentIndex = 0;
                var accessorsLength = accessors.length;
                for (i = 0; i < accessorsLength; ++i) {
                    var accessor = accessors[i];
                    var accessorByteStride = computeAccessorByteStride(gltf, accessor);
                    var accessorByteOffset = accessor.byteOffset;
                    var accessorByteLength = accessor.count * accessorByteStride;
                    delete accessor.byteStride;

                    var hasNextAccessor = (i < accessorsLength - 1);
                    var nextAccessorByteStride = hasNextAccessor ? computeAccessorByteStride(gltf, accessors[i + 1]) : undefined;
                    if (accessorByteStride !== nextAccessorByteStride) {
                        var newBufferView = clone(bufferView, true);
                        if (bufferViewHasVertexAttributes[bufferViewId]) {
                            newBufferView.byteStride = accessorByteStride;
                        }
                        newBufferView.byteOffset += currentByteOffset;
                        newBufferView.byteLength = accessorByteOffset + accessorByteLength - currentByteOffset;
                        var newBufferViewId = addToArray(bufferViews, newBufferView);
                        for (j = currentIndex; j <= i; ++j) {
                            accessor = accessors[j];
                            accessor.bufferView = newBufferViewId;
                            accessor.byteOffset = accessor.byteOffset - currentByteOffset;
                        }
                        // Set current byte offset to next accessor's byte offset
                        currentByteOffset = hasNextAccessor ? accessors[i + 1].byteOffset : undefined;
                        currentIndex = i + 1;
                    }
                }
            }
        }

        // Remove unused buffer views
        removeUnusedElements(gltf, ['accessor', 'bufferView', 'buffer']);
    }

    function requirePositionAccessorMinMax(gltf) {
        ForEach.accessorWithSemantic(gltf, 'POSITION', function(accessorId) {
            var accessor = gltf.accessors[accessorId];
            if (!defined(accessor.min) || !defined(accessor.max)) {
                var minMax = findAccessorMinMax(gltf, accessor);
                accessor.min = minMax.min;
                accessor.max = minMax.max;
            }
        });
    }

    function isNodeEmpty(node) {
        return (!defined(node.children) || node.children.length === 0) &&
            (!defined(node.meshes) || node.meshes.length === 0) &&
            !defined(node.camera) && !defined(node.skin) && !defined(node.skeletons) && !defined(node.jointName) &&
            (!defined(node.translation) || Cartesian3.fromArray(node.translation).equals(Cartesian3.ZERO)) &&
            (!defined(node.scale) || Cartesian3.fromArray(node.scale).equals(new Cartesian3(1.0, 1.0, 1.0))) &&
            (!defined(node.rotation) || Cartesian4.fromArray(node.rotation).equals(new Cartesian4(0.0, 0.0, 0.0, 1.0))) &&
            (!defined(node.matrix) || Matrix4.fromColumnMajorArray(node.matrix).equals(Matrix4.IDENTITY)) &&
            !defined(node.extensions) && !defined(node.extras);
    }

    function deleteNode(gltf, nodeId) {
        // Remove from list of nodes in scene
        ForEach.scene(gltf, function(scene) {
            var sceneNodes = scene.nodes;
            if (defined(sceneNodes)) {
                var sceneNodesLength = sceneNodes.length;
                for (var i = sceneNodesLength; i >= 0; --i) {
                    if (sceneNodes[i] === nodeId) {
                        sceneNodes.splice(i, 1);
                        return;
                    }
                }
            }
        });

        // Remove parent node's reference to this node, and delete the parent if also empty
        ForEach.node(gltf, function(parentNode, parentNodeId) {
            if (defined(parentNode.children)) {
                var index = parentNode.children.indexOf(nodeId);
                if (index > -1) {
                    parentNode.children.splice(index, 1);

                    if (isNodeEmpty(parentNode)) {
                        deleteNode(gltf, parentNodeId);
                    }
                }
            }
        });

        delete gltf.nodes[nodeId];
    }

    function removeEmptyNodes(gltf) {
        ForEach.node(gltf, function(node, nodeId) {
            if (isNodeEmpty(node)) {
                deleteNode(gltf, nodeId);
            }
        });

        return gltf;
    }

    function requireAnimationAccessorMinMax(gltf) {
        ForEach.animation(gltf, function(animation) {
            ForEach.animationSampler(animation, function(sampler) {
                var accessor = gltf.accessors[sampler.input];
                if (!defined(accessor.min) || !defined(accessor.max)) {
                    var minMax = findAccessorMinMax(gltf, accessor);
                    accessor.min = minMax.min;
                    accessor.max = minMax.max;
                }
            });
        });
    }

    function glTF10to20(gltf) {
        gltf.asset = defaultValue(gltf.asset, {});
        gltf.asset.version = '2.0';
        // material.instanceTechnique properties should be directly on the material. instanceTechnique is a gltf 0.8 property but is seen in some 1.0 models.
        updateInstanceTechniques(gltf);
        // animation.samplers now refers directly to accessors and animation.parameters should be removed
        removeAnimationSamplersIndirection(gltf);
        // Remove empty nodes and re-assign referencing indices
        removeEmptyNodes(gltf);
        // Top-level objects are now arrays referenced by index instead of id
        objectsToArrays(gltf);
        // Animation.sampler objects cannot have names
        removeAnimationSamplerNames(gltf);
        // asset.profile no longer exists
        stripAsset(gltf);
        // Move known extensions from extensionsUsed to extensionsRequired
        requireKnownExtensions(gltf);
        // bufferView.byteLength and buffer.byteLength are required
        requireByteLength(gltf);
        // byteStride moved from accessor to bufferView
        moveByteStrideToBufferView(gltf);
        // accessor.min and accessor.max must be defined for accessors containing POSITION attributes
        requirePositionAccessorMinMax(gltf);
        // An animation sampler's input accessor must have min and max properties defined
        requireAnimationAccessorMinMax(gltf);
        // buffer.type is unnecessary and should be removed
        removeBufferType(gltf);
        // Remove format, internalFormat, target, and type
        removeTextureProperties(gltf);
        // TEXCOORD and COLOR attributes must be written with a set index (TEXCOORD_#)
        requireAttributeSetIndex(gltf);
        // Add underscores to application-specific parameters
        underscoreApplicationSpecificSemantics(gltf);
        // Accessors referenced by JOINTS_0 and WEIGHTS_0 attributes must have correct component types
        updateAccessorComponentTypes(gltf);
        // Clamp camera parameters
        clampCameraParameters(gltf);
        // Move legacy technique render states to material properties and add KHR_blend extension blending functions
        moveTechniqueRenderStates(gltf);
        // Add material techniques to KHR_techniques_webgl extension, removing shaders, programs, and techniques
        moveTechniquesToExtension(gltf);
        // Remove empty arrays
        removeEmptyArrays(gltf);
    }

    export default updateVersion;