Cesium-Prequel/Source/ThirdParty/GltfPipeline/ForEach.js

import hasExtension from './hasExtension.js'
import defined from '../../Core/defined.js'

    /**
     * Contains traversal functions for processing elements of the glTF hierarchy.
     * @constructor
     *
     * @private
     */
    function ForEach() {
    }

    /**
     * Fallback for glTF 1.0
     * @private
     */
    ForEach.objectLegacy = function(objects, handler) {
        if (defined(objects)) {
            for (var objectId in objects) {
                if (Object.prototype.hasOwnProperty.call(objects, objectId)) {
                    var object = objects[objectId];
                    var value = handler(object, objectId);

                    if (defined(value)) {
                        return value;
                    }
                }
            }
        }
    };

    /**
     * @private
     */
    ForEach.object = function(arrayOfObjects, handler) {
        if (defined(arrayOfObjects)) {
            var length = arrayOfObjects.length;
            for (var i = 0; i < length; i++) {
                var object = arrayOfObjects[i];
                var value = handler(object, i);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    /**
     * Supports glTF 1.0 and 2.0
     * @private
     */
    ForEach.topLevel = function(gltf, name, handler) {
        var gltfProperty = gltf[name];
        if (defined(gltfProperty) && !Array.isArray(gltfProperty)) {
            return ForEach.objectLegacy(gltfProperty, handler);
        }

        return ForEach.object(gltfProperty, handler);
    };

    ForEach.accessor = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'accessors', handler);
    };

    ForEach.accessorWithSemantic = function(gltf, semantic, handler) {
        var visited = {};
        return ForEach.mesh(gltf, function(mesh) {
            return ForEach.meshPrimitive(mesh, function(primitive) {
                var valueForEach = ForEach.meshPrimitiveAttribute(primitive, function(accessorId, attributeSemantic) {
                    if (attributeSemantic.indexOf(semantic) === 0 && !defined(visited[accessorId])) {
                        visited[accessorId] = true;
                        var value = handler(accessorId);

                        if (defined(value)) {
                            return value;
                        }
                    }
                });

                if (defined(valueForEach)) {
                    return valueForEach;
                }

                return ForEach.meshPrimitiveTarget(primitive, function(target) {
                    return ForEach.meshPrimitiveTargetAttribute(target, function(accessorId, attributeSemantic) {
                        if (attributeSemantic.indexOf(semantic) === 0 && !defined(visited[accessorId])) {
                            visited[accessorId] = true;
                            var value = handler(accessorId);

                            if (defined(value)) {
                                return value;
                            }
                        }
                    });
                });
            });
        });
    };

    ForEach.accessorContainingVertexAttributeData = function(gltf, handler) {
        var visited = {};
        return ForEach.mesh(gltf, function(mesh) {
            return ForEach.meshPrimitive(mesh, function(primitive) {
                var valueForEach = ForEach.meshPrimitiveAttribute(primitive, function(accessorId) {
                    if (!defined(visited[accessorId])) {
                        visited[accessorId] = true;
                        var value = handler(accessorId);

                        if (defined(value)) {
                            return value;
                        }
                    }
                });

                if (defined(valueForEach)) {
                    return valueForEach;
                }

                return ForEach.meshPrimitiveTarget(primitive, function(target) {
                    return ForEach.meshPrimitiveTargetAttribute(target, function(accessorId) {
                        if (!defined(visited[accessorId])) {
                            visited[accessorId] = true;
                            var value = handler(accessorId);

                            if (defined(value)) {
                                return value;
                            }
                        }
                    });
                });
            });
        });
    };

    ForEach.accessorContainingIndexData = function(gltf, handler) {
        var visited = {};
        return ForEach.mesh(gltf, function(mesh) {
            return ForEach.meshPrimitive(mesh, function(primitive) {
                var indices = primitive.indices;
                if (defined(indices) && !defined(visited[indices])) {
                    visited[indices] = true;
                    var value = handler(indices);

                    if (defined(value)) {
                        return value;
                    }
                }
            });
        });
    };

    ForEach.animation = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'animations', handler);
    };

    ForEach.animationChannel = function(animation, handler) {
        var channels = animation.channels;
        return ForEach.object(channels, handler);
    };

    ForEach.animationSampler = function(animation, handler) {
        var samplers = animation.samplers;
        return ForEach.object(samplers, handler);
    };

    ForEach.buffer = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'buffers', handler);
    };

    ForEach.bufferView = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'bufferViews', handler);
    };

    ForEach.camera = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'cameras', handler);
    };

    ForEach.image = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'images', handler);
    };

    ForEach.compressedImage = function(image, handler) {
        if (defined(image.extras)) {
            var compressedImages = image.extras.compressedImage3DTiles;
            for (var type in compressedImages) {
                if (Object.prototype.hasOwnProperty.call(compressedImages, type)) {
                    var compressedImage = compressedImages[type];
                    var value = handler(compressedImage, type);

                    if (defined(value)) {
                        return value;
                    }
                }
            }
        }
    };

    ForEach.material = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'materials', handler);
    };

    ForEach.materialValue = function(material, handler) {
        var values = material.values;
        if (defined(material.extensions) && defined(material.extensions.KHR_techniques_webgl)) {
            values = material.extensions.KHR_techniques_webgl.values;
        }

        for (var name in values) {
            if (Object.prototype.hasOwnProperty.call(values, name)) {
                var value = handler(values[name], name);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.mesh = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'meshes', handler);
    };

    ForEach.meshPrimitive = function(mesh, handler) {
        var primitives = mesh.primitives;
        if (defined(primitives)) {
            var primitivesLength = primitives.length;
            for (var i = 0; i < primitivesLength; i++) {
                var primitive = primitives[i];
                var value = handler(primitive, i);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.meshPrimitiveAttribute = function(primitive, handler) {
        var attributes = primitive.attributes;
        for (var semantic in attributes) {
            if (Object.prototype.hasOwnProperty.call(attributes, semantic)) {
                var value = handler(attributes[semantic], semantic);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.meshPrimitiveTarget = function(primitive, handler) {
        var targets = primitive.targets;
        if (defined(targets)) {
            var length = targets.length;
            for (var i = 0; i < length; ++i) {
                var value = handler(targets[i], i);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.meshPrimitiveTargetAttribute = function(target, handler) {
        for (var semantic in target) {
            if (Object.prototype.hasOwnProperty.call(target, semantic)) {
                var accessorId = target[semantic];
                var value = handler(accessorId, semantic);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.node = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'nodes', handler);
    };

    ForEach.nodeInTree = function(gltf, nodeIds, handler) {
        var nodes = gltf.nodes;
        if (defined(nodes)) {
            var length = nodeIds.length;
            for (var i = 0; i < length; i++) {
                var nodeId = nodeIds[i];
                var node = nodes[nodeId];
                if (defined(node)) {
                    var value = handler(node, nodeId);

                    if (defined(value)) {
                        return value;
                    }

                    var children = node.children;
                    if (defined(children)) {
                        value = ForEach.nodeInTree(gltf, children, handler);

                        if (defined(value)) {
                            return value;
                        }
                    }
                }
            }
        }
    };

    ForEach.nodeInScene = function(gltf, scene, handler) {
        var sceneNodeIds = scene.nodes;
        if (defined(sceneNodeIds)) {
            return ForEach.nodeInTree(gltf, sceneNodeIds, handler);
        }
    };

    ForEach.program = function(gltf, handler) {
        if (hasExtension(gltf, 'KHR_techniques_webgl')) {
            return ForEach.object(gltf.extensions.KHR_techniques_webgl.programs, handler);
        }

        return ForEach.topLevel(gltf, 'programs', handler);
    };

    ForEach.sampler = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'samplers', handler);
    };

    ForEach.scene = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'scenes', handler);
    };

    ForEach.shader = function(gltf, handler) {
        if (hasExtension(gltf, 'KHR_techniques_webgl')) {
            return ForEach.object(gltf.extensions.KHR_techniques_webgl.shaders, handler);
        }

        return ForEach.topLevel(gltf, 'shaders', handler);
    };

    ForEach.skin = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'skins', handler);
    };

    ForEach.skinJoint = function(skin, handler) {
        var joints = skin.joints;
        if (defined(joints)) {
            var jointsLength = joints.length;
            for (var i = 0; i < jointsLength; i++) {
                var joint = joints[i];
                var value = handler(joint);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.techniqueAttribute = function(technique, handler) {
        var attributes = technique.attributes;
        for (var attributeName in attributes) {
            if (Object.prototype.hasOwnProperty.call(attributes, attributeName)) {
                var value = handler(attributes[attributeName], attributeName);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.techniqueUniform = function(technique, handler) {
        var uniforms = technique.uniforms;
        for (var uniformName in uniforms) {
            if (Object.prototype.hasOwnProperty.call(uniforms, uniformName)) {
                var value = handler(uniforms[uniformName], uniformName);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.techniqueParameter = function(technique, handler) {
        var parameters = technique.parameters;
        for (var parameterName in parameters) {
            if (Object.prototype.hasOwnProperty.call(parameters, parameterName)) {
                var value = handler(parameters[parameterName], parameterName);

                if (defined(value)) {
                    return value;
                }
            }
        }
    };

    ForEach.technique = function(gltf, handler) {
        if (hasExtension(gltf, 'KHR_techniques_webgl')) {
            return ForEach.object(gltf.extensions.KHR_techniques_webgl.techniques, handler);
        }

        return ForEach.topLevel(gltf, 'techniques', handler);
    };

    ForEach.texture = function(gltf, handler) {
        return ForEach.topLevel(gltf, 'textures', handler);
    };

    export default ForEach;