GitBucket
Newer
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 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 (Array.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;