Nightly

dist/preview release/babylon.max.js

@@ -32495,8 +32495,8 @@ var BABYLON;
             if (this._emissiveTexture) {
                 activeTextures.push(this._emissiveTexture);
             }
-            if (this._reflectionTexture) {
-                activeTextures.push(this._reflectionTexture);
+            if (this._reflectivityTexture) {
+                activeTextures.push(this._reflectivityTexture);
             }
             if (this._metallicTexture) {
                 activeTextures.push(this._metallicTexture);
@@ -32531,6 +32531,9 @@ var BABYLON;
             if (this._reflectionTexture === texture) {
                 return true;
             }
+            if (this._reflectivityTexture === texture) {
+                return true;
+            }
             if (this._metallicTexture === texture) {
                 return true;
             }
@@ -47131,7 +47134,6 @@ var BABYLON;
             return null;
         };
         var isDescendantOf = function (mesh, names, hierarchyIds) {
-            names = (names instanceof Array) ? names : [names];
             for (var i in names) {
                 if (mesh.name === names[i]) {
                     hierarchyIds.push(mesh.id);
@@ -47166,141 +47168,149 @@ var BABYLON;
                     var parsedData = JSON.parse(data);
                     log = "";
                     var fullDetails = BABYLON.SceneLoader.loggingLevel === BABYLON.SceneLoader.DETAILED_LOGGING;
-                    var loadedSkeletonsIds = [];
-                    var loadedMaterialsIds = [];
-                    var hierarchyIds = [];
-                    var index;
-                    var cache;
-                    for (index = 0, cache = parsedData.meshes.length; index < cache; index++) {
-                        var parsedMesh = parsedData.meshes[index];
-                        if (!meshesNames || isDescendantOf(parsedMesh, meshesNames, hierarchyIds)) {
-                            if (meshesNames instanceof Array) {
-                                // Remove found mesh name from list.
-                                delete meshesNames[meshesNames.indexOf(parsedMesh.name)];
-                            }
-                            //Geometry?
-                            if (parsedMesh.geometryId) {
-                                //does the file contain geometries?
-                                if (parsedData.geometries) {
-                                    //find the correct geometry and add it to the scene
-                                    var found = false;
-                                    ["boxes", "spheres", "cylinders", "toruses", "grounds", "planes", "torusKnots", "vertexData"].forEach(function (geometryType) {
-                                        if (found || !parsedData.geometries[geometryType] || !(parsedData.geometries[geometryType] instanceof Array)) {
-                                            return;
-                                        }
-                                        else {
-                                            parsedData.geometries[geometryType].forEach(function (parsedGeometryData) {
-                                                if (parsedGeometryData.id === parsedMesh.geometryId) {
-                                                    switch (geometryType) {
-                                                        case "boxes":
-                                                            BABYLON.Geometry.Primitives.Box.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "spheres":
-                                                            BABYLON.Geometry.Primitives.Sphere.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "cylinders":
-                                                            BABYLON.Geometry.Primitives.Cylinder.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "toruses":
-                                                            BABYLON.Geometry.Primitives.Torus.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "grounds":
-                                                            BABYLON.Geometry.Primitives.Ground.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "planes":
-                                                            BABYLON.Geometry.Primitives.Plane.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "torusKnots":
-                                                            BABYLON.Geometry.Primitives.TorusKnot.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "vertexData":
-                                                            BABYLON.Geometry.Parse(parsedGeometryData, scene, rootUrl);
-                                                            break;
+                    if (!meshesNames) {
+                        meshesNames = null;
+                    }
+                    else if (!Array.isArray(meshesNames)) {
+                        meshesNames = [meshesNames];
+                    }
+                    if (parsedData.meshes !== undefined && parsedData.meshes !== null) {
+                        var loadedSkeletonsIds = [];
+                        var loadedMaterialsIds = [];
+                        var hierarchyIds = [];
+                        var index;
+                        var cache;
+                        for (index = 0, cache = parsedData.meshes.length; index < cache; index++) {
+                            var parsedMesh = parsedData.meshes[index];
+                            if (meshesNames === null || isDescendantOf(parsedMesh, meshesNames, hierarchyIds)) {
+                                if (meshesNames !== null) {
+                                    // Remove found mesh name from list.
+                                    delete meshesNames[meshesNames.indexOf(parsedMesh.name)];
+                                }
+                                //Geometry?
+                                if (parsedMesh.geometryId !== undefined && parsedMesh.geometryId !== null) {
+                                    //does the file contain geometries?
+                                    if (parsedData.geometries !== undefined && parsedData.geometries !== null) {
+                                        //find the correct geometry and add it to the scene
+                                        var found = false;
+                                        ["boxes", "spheres", "cylinders", "toruses", "grounds", "planes", "torusKnots", "vertexData"].forEach(function (geometryType) {
+                                            if (found === true || !parsedData.geometries[geometryType] || !(Array.isArray(parsedData.geometries[geometryType]))) {
+                                                return;
+                                            }
+                                            else {
+                                                parsedData.geometries[geometryType].forEach(function (parsedGeometryData) {
+                                                    if (parsedGeometryData.id === parsedMesh.geometryId) {
+                                                        switch (geometryType) {
+                                                            case "boxes":
+                                                                BABYLON.Geometry.Primitives.Box.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "spheres":
+                                                                BABYLON.Geometry.Primitives.Sphere.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "cylinders":
+                                                                BABYLON.Geometry.Primitives.Cylinder.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "toruses":
+                                                                BABYLON.Geometry.Primitives.Torus.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "grounds":
+                                                                BABYLON.Geometry.Primitives.Ground.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "planes":
+                                                                BABYLON.Geometry.Primitives.Plane.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "torusKnots":
+                                                                BABYLON.Geometry.Primitives.TorusKnot.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "vertexData":
+                                                                BABYLON.Geometry.Parse(parsedGeometryData, scene, rootUrl);
+                                                                break;
+                                                        }
+                                                        found = true;
                                                     }
-                                                    found = true;
-                                                }
-                                            });
+                                                });
+                                            }
+                                        });
+                                        if (found === false) {
+                                            BABYLON.Tools.Warn("Geometry not found for mesh " + parsedMesh.id);
                                         }
-                                    });
-                                    if (!found) {
-                                        BABYLON.Tools.Warn("Geometry not found for mesh " + parsedMesh.id);
                                     }
                                 }
-                            }
-                            // Material ?
-                            if (parsedMesh.materialId) {
-                                var materialFound = (loadedMaterialsIds.indexOf(parsedMesh.materialId) !== -1);
-                                if (!materialFound && parsedData.multiMaterials) {
-                                    for (var multimatIndex = 0, multimatCache = parsedData.multiMaterials.length; multimatIndex < multimatCache; multimatIndex++) {
-                                        var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
-                                        if (parsedMultiMaterial.id === parsedMesh.materialId) {
-                                            for (var matIndex = 0, matCache = parsedMultiMaterial.materials.length; matIndex < matCache; matIndex++) {
-                                                var subMatId = parsedMultiMaterial.materials[matIndex];
-                                                loadedMaterialsIds.push(subMatId);
-                                                var mat = parseMaterialById(subMatId, parsedData, scene, rootUrl);
-                                                log += "\n\tMaterial " + mat.toString(fullDetails);
+                                // Material ?
+                                if (parsedMesh.materialId) {
+                                    var materialFound = (loadedMaterialsIds.indexOf(parsedMesh.materialId) !== -1);
+                                    if (materialFound === false && parsedData.multiMaterials !== undefined && parsedData.multiMaterials !== null) {
+                                        for (var multimatIndex = 0, multimatCache = parsedData.multiMaterials.length; multimatIndex < multimatCache; multimatIndex++) {
+                                            var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
+                                            if (parsedMultiMaterial.id === parsedMesh.materialId) {
+                                                for (var matIndex = 0, matCache = parsedMultiMaterial.materials.length; matIndex < matCache; matIndex++) {
+                                                    var subMatId = parsedMultiMaterial.materials[matIndex];
+                                                    loadedMaterialsIds.push(subMatId);
+                                                    var mat = parseMaterialById(subMatId, parsedData, scene, rootUrl);
+                                                    log += "\n\tMaterial " + mat.toString(fullDetails);
+                                                }
+                                                loadedMaterialsIds.push(parsedMultiMaterial.id);
+                                                var mmat = BABYLON.Material.ParseMultiMaterial(parsedMultiMaterial, scene);
+                                                materialFound = true;
+                                                log += "\n\tMulti-Material " + mmat.toString(fullDetails);
+                                                break;
                                             }
-                                            loadedMaterialsIds.push(parsedMultiMaterial.id);
-                                            var mmat = BABYLON.Material.ParseMultiMaterial(parsedMultiMaterial, scene);
-                                            materialFound = true;
-                                            log += "\n\tMulti-Material " + mmat.toString(fullDetails);
-                                            break;
                                         }
                                     }
-                                }
-                                if (!materialFound) {
-                                    loadedMaterialsIds.push(parsedMesh.materialId);
-                                    var mat = parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
-                                    if (!mat) {
-                                        BABYLON.Tools.Warn("Material not found for mesh " + parsedMesh.id);
-                                    }
-                                    else {
-                                        log += "\n\tMaterial " + mat.toString(fullDetails);
+                                    if (materialFound === false) {
+                                        loadedMaterialsIds.push(parsedMesh.materialId);
+                                        var mat = parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
+                                        if (!mat) {
+                                            BABYLON.Tools.Warn("Material not found for mesh " + parsedMesh.id);
+                                        }
+                                        else {
+                                            log += "\n\tMaterial " + mat.toString(fullDetails);
+                                        }
                                     }
                                 }
-                            }
-                            // Skeleton ?
-                            if (parsedMesh.skeletonId > -1 && scene.skeletons) {
-                                var skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
-                                if (!skeletonAlreadyLoaded) {
-                                    for (var skeletonIndex = 0, skeletonCache = parsedData.skeletons.length; skeletonIndex < skeletonCache; skeletonIndex++) {
-                                        var parsedSkeleton = parsedData.skeletons[skeletonIndex];
-                                        if (parsedSkeleton.id === parsedMesh.skeletonId) {
-                                            var skeleton = BABYLON.Skeleton.Parse(parsedSkeleton, scene);
-                                            skeletons.push(skeleton);
-                                            loadedSkeletonsIds.push(parsedSkeleton.id);
-                                            log += "\n\tSkeleton " + skeleton.toString(fullDetails);
+                                // Skeleton ?
+                                if (parsedMesh.skeletonId > -1 && parsedData.skeletons !== undefined && parsedData.skeletons !== null) {
+                                    var skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
+                                    if (skeletonAlreadyLoaded === false) {
+                                        for (var skeletonIndex = 0, skeletonCache = parsedData.skeletons.length; skeletonIndex < skeletonCache; skeletonIndex++) {
+                                            var parsedSkeleton = parsedData.skeletons[skeletonIndex];
+                                            if (parsedSkeleton.id === parsedMesh.skeletonId) {
+                                                var skeleton = BABYLON.Skeleton.Parse(parsedSkeleton, scene);
+                                                skeletons.push(skeleton);
+                                                loadedSkeletonsIds.push(parsedSkeleton.id);
+                                                log += "\n\tSkeleton " + skeleton.toString(fullDetails);
+                                            }
                                         }
                                     }
                                 }
+                                var mesh = BABYLON.Mesh.Parse(parsedMesh, scene, rootUrl);
+                                meshes.push(mesh);
+                                log += "\n\tMesh " + mesh.toString(fullDetails);
                             }
-                            var mesh = BABYLON.Mesh.Parse(parsedMesh, scene, rootUrl);
-                            meshes.push(mesh);
-                            log += "\n\tMesh " + mesh.toString(fullDetails);
                         }
-                    }
-                    // Connecting parents
-                    var currentMesh;
-                    for (index = 0, cache = scene.meshes.length; index < cache; index++) {
-                        currentMesh = scene.meshes[index];
-                        if (currentMesh._waitingParentId) {
-                            currentMesh.parent = scene.getLastEntryByID(currentMesh._waitingParentId);
-                            currentMesh._waitingParentId = undefined;
-                        }
-                    }
-                    // freeze and compute world matrix application
-                    for (index = 0, cache = scene.meshes.length; index < cache; index++) {
-                        currentMesh = scene.meshes[index];
-                        if (currentMesh._waitingFreezeWorldMatrix) {
-                            currentMesh.freezeWorldMatrix();
-                            currentMesh._waitingFreezeWorldMatrix = undefined;
+                        // Connecting parents
+                        var currentMesh;
+                        for (index = 0, cache = scene.meshes.length; index < cache; index++) {
+                            currentMesh = scene.meshes[index];
+                            if (currentMesh._waitingParentId) {
+                                currentMesh.parent = scene.getLastEntryByID(currentMesh._waitingParentId);
+                                currentMesh._waitingParentId = undefined;
+                            }
                         }
-                        else {
-                            currentMesh.computeWorldMatrix(true);
+                        // freeze and compute world matrix application
+                        for (index = 0, cache = scene.meshes.length; index < cache; index++) {
+                            currentMesh = scene.meshes[index];
+                            if (currentMesh._waitingFreezeWorldMatrix) {
+                                currentMesh.freezeWorldMatrix();
+                                currentMesh._waitingFreezeWorldMatrix = undefined;
+                            }
+                            else {
+                                currentMesh.computeWorldMatrix(true);
+                            }
                         }
                     }
                     // Particles
-                    if (parsedData.particleSystems) {
+                    if (parsedData.particleSystems !== undefined && parsedData.particleSystems !== null) {
                         for (index = 0, cache = parsedData.particleSystems.length; index < cache; index++) {
                             var parsedParticleSystem = parsedData.particleSystems[index];
                             if (hierarchyIds.indexOf(parsedParticleSystem.emitterId) !== -1) {
@@ -47332,19 +47342,19 @@ var BABYLON;
                     log = "";
                     var fullDetails = BABYLON.SceneLoader.loggingLevel === BABYLON.SceneLoader.DETAILED_LOGGING;
                     // Scene
-                    if (parsedData.useDelayedTextureLoading !== undefined) {
+                    if (parsedData.useDelayedTextureLoading !== undefined && parsedData.useDelayedTextureLoading !== null) {
                         scene.useDelayedTextureLoading = parsedData.useDelayedTextureLoading && !BABYLON.SceneLoader.ForceFullSceneLoadingForIncremental;
                     }
-                    if (parsedData.autoClear !== undefined) {
+                    if (parsedData.autoClear !== undefined && parsedData.autoClear !== null) {
                         scene.autoClear = parsedData.autoClear;
                     }
-                    if (parsedData.clearColor !== undefined) {
+                    if (parsedData.clearColor !== undefined && parsedData.clearColor !== null) {
                         scene.clearColor = BABYLON.Color4.FromArray(parsedData.clearColor);
                     }
-                    if (parsedData.ambientColor !== undefined) {
+                    if (parsedData.ambientColor !== undefined && parsedData.ambientColor !== null) {
                         scene.ambientColor = BABYLON.Color3.FromArray(parsedData.ambientColor);
                     }
-                    if (parsedData.gravity !== undefined) {
+                    if (parsedData.gravity !== undefined && parsedData.gravity !== null) {
                         scene.gravity = BABYLON.Vector3.FromArray(parsedData.gravity);
                     }
                     // Fog
@@ -47383,18 +47393,18 @@ var BABYLON;
                         scene.enablePhysics(physicsGravity, physicsPlugin);
                     }
                     // Metadata
-                    if (parsedData.metadata !== undefined) {
+                    if (parsedData.metadata !== undefined && parsedData.metadata !== null) {
                         scene.metadata = parsedData.metadata;
                     }
                     //collisions, if defined. otherwise, default is true
-                    if (parsedData.collisionsEnabled !== undefined) {
+                    if (parsedData.collisionsEnabled !== undefined && parsedData.collisionsEnabled !== null) {
                         scene.collisionsEnabled = parsedData.collisionsEnabled;
                     }
                     scene.workerCollisions = !!parsedData.workerCollisions;
                     var index;
                     var cache;
                     // Lights
-                    if (parsedData.lights !== undefined) {
+                    if (parsedData.lights !== undefined && parsedData.lights !== null) {
                         for (index = 0, cache = parsedData.lights.length; index < cache; index++) {
                             var parsedLight = parsedData.lights[index];
                             var light = BABYLON.Light.Parse(parsedLight, scene);
@@ -47403,7 +47413,7 @@ var BABYLON;
                         }
                     }
                     // Animations
-                    if (parsedData.animations !== undefined) {
+                    if (parsedData.animations !== undefined && parsedData.animations !== null) {
                         for (index = 0, cache = parsedData.animations.length; index < cache; index++) {
                             var parsedAnimation = parsedData.animations[index];
                             var animation = BABYLON.Animation.Parse(parsedAnimation);
@@ -47416,7 +47426,7 @@ var BABYLON;
                         scene.beginAnimation(scene, parsedData.autoAnimateFrom, parsedData.autoAnimateTo, parsedData.autoAnimateLoop, parsedData.autoAnimateSpeed || 1.0);
                     }
                     // Materials
-                    if (parsedData.materials !== undefined) {
+                    if (parsedData.materials !== undefined && parsedData.materials !== null) {
                         for (index = 0, cache = parsedData.materials.length; index < cache; index++) {
                             var parsedMaterial = parsedData.materials[index];
                             var mat = BABYLON.Material.Parse(parsedMaterial, scene, rootUrl);
@@ -47424,7 +47434,7 @@ var BABYLON;
                             log += "\n\t\t" + mat.toString(fullDetails);
                         }
                     }
-                    if (parsedData.multiMaterials !== undefined) {
+                    if (parsedData.multiMaterials !== undefined && parsedData.multiMaterials !== null) {
                         for (index = 0, cache = parsedData.multiMaterials.length; index < cache; index++) {
                             var parsedMultiMaterial = parsedData.multiMaterials[index];
                             var mmat = BABYLON.Material.ParseMultiMaterial(parsedMultiMaterial, scene);
@@ -47433,14 +47443,14 @@ var BABYLON;
                         }
                     }
                     // Morph targets
-                    if (parsedData.morphTargetManagers !== undefined) {
+                    if (parsedData.morphTargetManagers !== undefined && parsedData.morphTargetManagers !== null) {
                         for (var _i = 0, _a = parsedData.morphTargetManagers; _i < _a.length; _i++) {
                             var managerData = _a[_i];
                             var parsedManager = BABYLON.MorphTargetManager.Parse(managerData, scene);
                         }
                     }
                     // Skeletons
-                    if (parsedData.skeletons !== undefined) {
+                    if (parsedData.skeletons !== undefined && parsedData.skeletons !== null) {
                         for (index = 0, cache = parsedData.skeletons.length; index < cache; index++) {
                             var parsedSkeleton = parsedData.skeletons[index];
                             var skeleton = BABYLON.Skeleton.Parse(parsedSkeleton, scene);
@@ -47450,10 +47460,10 @@ var BABYLON;
                     }
                     // Geometries
                     var geometries = parsedData.geometries;
-                    if (geometries !== undefined) {
+                    if (geometries !== undefined && geometries !== null) {
                         // Boxes
                         var boxes = geometries.boxes;
-                        if (boxes !== undefined) {
+                        if (boxes !== undefined && boxes !== null) {
                             for (index = 0, cache = boxes.length; index < cache; index++) {
                                 var parsedBox = boxes[index];
                                 BABYLON.Geometry.Primitives.Box.Parse(parsedBox, scene);
@@ -47461,7 +47471,7 @@ var BABYLON;
                         }
                         // Spheres
                         var spheres = geometries.spheres;
-                        if (spheres !== undefined) {
+                        if (spheres !== undefined && spheres !== null) {
                             for (index = 0, cache = spheres.length; index < cache; index++) {
                                 var parsedSphere = spheres[index];
                                 BABYLON.Geometry.Primitives.Sphere.Parse(parsedSphere, scene);
@@ -47469,7 +47479,7 @@ var BABYLON;
                         }
                         // Cylinders
                         var cylinders = geometries.cylinders;
-                        if (cylinders !== undefined) {
+                        if (cylinders !== undefined && cylinders !== null) {
                             for (index = 0, cache = cylinders.length; index < cache; index++) {
                                 var parsedCylinder = cylinders[index];
                                 BABYLON.Geometry.Primitives.Cylinder.Parse(parsedCylinder, scene);
@@ -47477,7 +47487,7 @@ var BABYLON;
                         }
                         // Toruses
                         var toruses = geometries.toruses;
-                        if (toruses !== undefined) {
+                        if (toruses !== undefined && toruses !== null) {
                             for (index = 0, cache = toruses.length; index < cache; index++) {
                                 var parsedTorus = toruses[index];
                                 BABYLON.Geometry.Primitives.Torus.Parse(parsedTorus, scene);
@@ -47485,7 +47495,7 @@ var BABYLON;
                         }
                         // Grounds
                         var grounds = geometries.grounds;
-                        if (grounds !== undefined) {
+                        if (grounds !== undefined && grounds !== null) {
                             for (index = 0, cache = grounds.length; index < cache; index++) {
                                 var parsedGround = grounds[index];
                                 BABYLON.Geometry.Primitives.Ground.Parse(parsedGround, scene);
@@ -47493,7 +47503,7 @@ var BABYLON;
                         }
                         // Planes
                         var planes = geometries.planes;
-                        if (planes !== undefined) {
+                        if (planes !== undefined && planes !== null) {
                             for (index = 0, cache = planes.length; index < cache; index++) {
                                 var parsedPlane = planes[index];
                                 BABYLON.Geometry.Primitives.Plane.Parse(parsedPlane, scene);
@@ -47501,7 +47511,7 @@ var BABYLON;
                         }
                         // TorusKnots
                         var torusKnots = geometries.torusKnots;
-                        if (torusKnots !== undefined) {
+                        if (torusKnots !== undefined && torusKnots !== null) {
                             for (index = 0, cache = torusKnots.length; index < cache; index++) {
                                 var parsedTorusKnot = torusKnots[index];
                                 BABYLON.Geometry.Primitives.TorusKnot.Parse(parsedTorusKnot, scene);
@@ -47509,7 +47519,7 @@ var BABYLON;
                         }
                         // VertexData
                         var vertexData = geometries.vertexData;
-                        if (vertexData !== undefined) {
+                        if (vertexData !== undefined && vertexData !== null) {
                             for (index = 0, cache = vertexData.length; index < cache; index++) {
                                 var parsedVertexData = vertexData[index];
                                 BABYLON.Geometry.Parse(parsedVertexData, scene, rootUrl);
@@ -47517,7 +47527,7 @@ var BABYLON;
                         }
                     }
                     // Meshes
-                    if (parsedData.meshes !== undefined) {
+                    if (parsedData.meshes !== undefined && parsedData.meshes !== null) {
                         for (index = 0, cache = parsedData.meshes.length; index < cache; index++) {
                             var parsedMesh = parsedData.meshes[index];
                             var mesh = BABYLON.Mesh.Parse(parsedMesh, scene, rootUrl);
@@ -47526,7 +47536,7 @@ var BABYLON;
                         }
                     }
                     // Cameras
-                    if (parsedData.cameras !== undefined) {
+                    if (parsedData.cameras !== undefined && parsedData.cameras !== null) {
                         for (index = 0, cache = parsedData.cameras.length; index < cache; index++) {
                             var parsedCamera = parsedData.cameras[index];
                             var camera = BABYLON.Camera.Parse(parsedCamera, scene);
@@ -47534,7 +47544,7 @@ var BABYLON;
                             log += "\n\t\t" + camera.toString(fullDetails);
                         }
                     }
-                    if (parsedData.activeCameraID !== undefined) {
+                    if (parsedData.activeCameraID !== undefined && parsedData.activeCameraID !== null) {
                         scene.setActiveCameraByID(parsedData.activeCameraID);
                     }
                     // Browsing all the graph to connect the dots
@@ -47555,7 +47565,7 @@ var BABYLON;
                     // Sounds
                     var loadedSounds = [];
                     var loadedSound;
-                    if (BABYLON.AudioEngine && parsedData.sounds !== undefined) {
+                    if (BABYLON.AudioEngine && parsedData.sounds !== undefined && parsedData.sounds !== null) {
                         for (index = 0, cache = parsedData.sounds.length; index < cache; index++) {
                             var parsedSound = parsedData.sounds[index];
                             if (BABYLON.Engine.audioEngine.canUseWebAudio) {
@@ -47599,21 +47609,21 @@ var BABYLON;
                         }
                     }
                     // Particles Systems
-                    if (parsedData.particleSystems !== undefined) {
+                    if (parsedData.particleSystems !== undefined && parsedData.particleSystems !== null) {
                         for (index = 0, cache = parsedData.particleSystems.length; index < cache; index++) {
                             var parsedParticleSystem = parsedData.particleSystems[index];
                             BABYLON.ParticleSystem.Parse(parsedParticleSystem, scene, rootUrl);
                         }
                     }
                     // Lens flares
-                    if (parsedData.lensFlareSystems !== undefined) {
+                    if (parsedData.lensFlareSystems !== undefined && parsedData.lensFlareSystems !== null) {
                         for (index = 0, cache = parsedData.lensFlareSystems.length; index < cache; index++) {
                             var parsedLensFlareSystem = parsedData.lensFlareSystems[index];
                             BABYLON.LensFlareSystem.Parse(parsedLensFlareSystem, scene, rootUrl);
                         }
                     }
                     // Shadows
-                    if (parsedData.shadowGenerators !== undefined) {
+                    if (parsedData.shadowGenerators !== undefined && parsedData.shadowGenerators !== null) {
                         for (index = 0, cache = parsedData.shadowGenerators.length; index < cache; index++) {
                             var parsedShadowGenerator = parsedData.shadowGenerators[index];
                             BABYLON.ShadowGenerator.Parse(parsedShadowGenerator, scene);
@@ -47644,7 +47654,7 @@ var BABYLON;
                         }
                     }
                     // Actions (scene)
-                    if (parsedData.actions !== undefined) {
+                    if (parsedData.actions !== undefined && parsedData.actions !== null) {
                         BABYLON.ActionManager.Parse(parsedData.actions, null, scene);
                     }
                     // Finish

dist/preview release/customConfigurations/minimalGLTFViewer/babylon.max.js

@@ -37615,8 +37615,8 @@ var BABYLON;
             if (this._emissiveTexture) {
                 activeTextures.push(this._emissiveTexture);
             }
-            if (this._reflectionTexture) {
-                activeTextures.push(this._reflectionTexture);
+            if (this._reflectivityTexture) {
+                activeTextures.push(this._reflectivityTexture);
             }
             if (this._metallicTexture) {
                 activeTextures.push(this._metallicTexture);
@@ -37651,6 +37651,9 @@ var BABYLON;
             if (this._reflectionTexture === texture) {
                 return true;
             }
+            if (this._reflectivityTexture === texture) {
+                return true;
+            }
             if (this._metallicTexture === texture) {
                 return true;
             }
@@ -48514,7 +48517,6 @@ var BABYLON;
             return null;
         };
         var isDescendantOf = function (mesh, names, hierarchyIds) {
-            names = (names instanceof Array) ? names : [names];
             for (var i in names) {
                 if (mesh.name === names[i]) {
                     hierarchyIds.push(mesh.id);
@@ -48549,141 +48551,149 @@ var BABYLON;
                     var parsedData = JSON.parse(data);
                     log = "";
                     var fullDetails = BABYLON.SceneLoader.loggingLevel === BABYLON.SceneLoader.DETAILED_LOGGING;
-                    var loadedSkeletonsIds = [];
-                    var loadedMaterialsIds = [];
-                    var hierarchyIds = [];
-                    var index;
-                    var cache;
-                    for (index = 0, cache = parsedData.meshes.length; index < cache; index++) {
-                        var parsedMesh = parsedData.meshes[index];
-                        if (!meshesNames || isDescendantOf(parsedMesh, meshesNames, hierarchyIds)) {
-                            if (meshesNames instanceof Array) {
-                                // Remove found mesh name from list.
-                                delete meshesNames[meshesNames.indexOf(parsedMesh.name)];
-                            }
-                            //Geometry?
-                            if (parsedMesh.geometryId) {
-                                //does the file contain geometries?
-                                if (parsedData.geometries) {
-                                    //find the correct geometry and add it to the scene
-                                    var found = false;
-                                    ["boxes", "spheres", "cylinders", "toruses", "grounds", "planes", "torusKnots", "vertexData"].forEach(function (geometryType) {
-                                        if (found || !parsedData.geometries[geometryType] || !(parsedData.geometries[geometryType] instanceof Array)) {
-                                            return;
-                                        }
-                                        else {
-                                            parsedData.geometries[geometryType].forEach(function (parsedGeometryData) {
-                                                if (parsedGeometryData.id === parsedMesh.geometryId) {
-                                                    switch (geometryType) {
-                                                        case "boxes":
-                                                            BABYLON.Geometry.Primitives.Box.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "spheres":
-                                                            BABYLON.Geometry.Primitives.Sphere.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "cylinders":
-                                                            BABYLON.Geometry.Primitives.Cylinder.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "toruses":
-                                                            BABYLON.Geometry.Primitives.Torus.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "grounds":
-                                                            BABYLON.Geometry.Primitives.Ground.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "planes":
-                                                            BABYLON.Geometry.Primitives.Plane.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "torusKnots":
-                                                            BABYLON.Geometry.Primitives.TorusKnot.Parse(parsedGeometryData, scene);
-                                                            break;
-                                                        case "vertexData":
-                                                            BABYLON.Geometry.Parse(parsedGeometryData, scene, rootUrl);
-                                                            break;
+                    if (!meshesNames) {
+                        meshesNames = null;
+                    }
+                    else if (!Array.isArray(meshesNames)) {
+                        meshesNames = [meshesNames];
+                    }
+                    if (parsedData.meshes !== undefined && parsedData.meshes !== null) {
+                        var loadedSkeletonsIds = [];
+                        var loadedMaterialsIds = [];
+                        var hierarchyIds = [];
+                        var index;
+                        var cache;
+                        for (index = 0, cache = parsedData.meshes.length; index < cache; index++) {
+                            var parsedMesh = parsedData.meshes[index];
+                            if (meshesNames === null || isDescendantOf(parsedMesh, meshesNames, hierarchyIds)) {
+                                if (meshesNames !== null) {
+                                    // Remove found mesh name from list.
+                                    delete meshesNames[meshesNames.indexOf(parsedMesh.name)];
+                                }
+                                //Geometry?
+                                if (parsedMesh.geometryId !== undefined && parsedMesh.geometryId !== null) {
+                                    //does the file contain geometries?
+                                    if (parsedData.geometries !== undefined && parsedData.geometries !== null) {
+                                        //find the correct geometry and add it to the scene
+                                        var found = false;
+                                        ["boxes", "spheres", "cylinders", "toruses", "grounds", "planes", "torusKnots", "vertexData"].forEach(function (geometryType) {
+                                            if (found === true || !parsedData.geometries[geometryType] || !(Array.isArray(parsedData.geometries[geometryType]))) {
+                                                return;
+                                            }
+                                            else {
+                                                parsedData.geometries[geometryType].forEach(function (parsedGeometryData) {
+                                                    if (parsedGeometryData.id === parsedMesh.geometryId) {
+                                                        switch (geometryType) {
+                                                            case "boxes":
+                                                                BABYLON.Geometry.Primitives.Box.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "spheres":
+                                                                BABYLON.Geometry.Primitives.Sphere.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "cylinders":
+                                                                BABYLON.Geometry.Primitives.Cylinder.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "toruses":
+                                                                BABYLON.Geometry.Primitives.Torus.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "grounds":
+                                                                BABYLON.Geometry.Primitives.Ground.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "planes":
+                                                                BABYLON.Geometry.Primitives.Plane.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "torusKnots":
+                                                                BABYLON.Geometry.Primitives.TorusKnot.Parse(parsedGeometryData, scene);
+                                                                break;
+                                                            case "vertexData":
+                                                                BABYLON.Geometry.Parse(parsedGeometryData, scene, rootUrl);
+                                                                break;
+                                                        }
+                                                        found = true;
                                                     }
-                                                    found = true;
-                                                }
-                                            });
+                                                });
+                                            }
+                                        });
+                                        if (found === false) {
+                                            BABYLON.Tools.Warn("Geometry not found for mesh " + parsedMesh.id);
                                         }
-                                    });
-                                    if (!found) {
-                                        BABYLON.Tools.Warn("Geometry not found for mesh " + parsedMesh.id);
                                     }
                                 }
-                            }
-                            // Material ?
-                            if (parsedMesh.materialId) {
-                                var materialFound = (loadedMaterialsIds.indexOf(parsedMesh.materialId) !== -1);
-                                if (!materialFound && parsedData.multiMaterials) {
-                                    for (var multimatIndex = 0, multimatCache = parsedData.multiMaterials.length; multimatIndex < multimatCache; multimatIndex++) {
-                                        var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
-                                        if (parsedMultiMaterial.id === parsedMesh.materialId) {
-                                            for (var matIndex = 0, matCache = parsedMultiMaterial.materials.length; matIndex < matCache; matIndex++) {
-                                                var subMatId = parsedMultiMaterial.materials[matIndex];
-                                                loadedMaterialsIds.push(subMatId);
-                                                var mat = parseMaterialById(subMatId, parsedData, scene, rootUrl);
-                                                log += "\n\tMaterial " + mat.toString(fullDetails);
+                                // Material ?
+                                if (parsedMesh.materialId) {
+                                    var materialFound = (loadedMaterialsIds.indexOf(parsedMesh.materialId) !== -1);
+                                    if (materialFound === false && parsedData.multiMaterials !== undefined && parsedData.multiMaterials !== null) {
+                                        for (var multimatIndex = 0, multimatCache = parsedData.multiMaterials.length; multimatIndex < multimatCache; multimatIndex++) {
+                                            var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
+                                            if (parsedMultiMaterial.id === parsedMesh.materialId) {
+                                                for (var matIndex = 0, matCache = parsedMultiMaterial.materials.length; matIndex < matCache; matIndex++) {
+                                                    var subMatId = parsedMultiMaterial.materials[matIndex];
+                                                    loadedMaterialsIds.push(subMatId);
+                                                    var mat = parseMaterialById(subMatId, parsedData, scene, rootUrl);
+                                                    log += "\n\tMaterial " + mat.toString(fullDetails);
+                                                }
+                                                loadedMaterialsIds.push(parsedMultiMaterial.id);
+                                                var mmat = BABYLON.Material.ParseMultiMaterial(parsedMultiMaterial, scene);
+                                                materialFound = true;
+                                                log += "\n\tMulti-Material " + mmat.toString(fullDetails);
+                                                break;
                                             }
-                                            loadedMaterialsIds.push(parsedMultiMaterial.id);
-                                            var mmat = BABYLON.Material.ParseMultiMaterial(parsedMultiMaterial, scene);
-                                            materialFound = true;
-                                            log += "\n\tMulti-Material " + mmat.toString(fullDetails);
-                                            break;
                                         }
                                     }
-                                }
-                                if (!materialFound) {
-                                    loadedMaterialsIds.push(parsedMesh.materialId);
-                                    var mat = parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
-                                    if (!mat) {
-                                        BABYLON.Tools.Warn("Material not found for mesh " + parsedMesh.id);
-                                    }
-                                    else {
-                                        log += "\n\tMaterial " + mat.toString(fullDetails);
+                                    if (materialFound === false) {
+                                        loadedMaterialsIds.push(parsedMesh.materialId);
+                                        var mat = parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
+                                        if (!mat) {
+                                            BABYLON.Tools.Warn("Material not found for mesh " + parsedMesh.id);
+                                        }
+                                        else {
+                                            log += "\n\tMaterial " + mat.toString(fullDetails);
+                                        }
                                     }
                                 }
-                            }
-                            // Skeleton ?
-                            if (parsedMesh.skeletonId > -1 && scene.skeletons) {
-                                var skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
-                                if (!skeletonAlreadyLoaded) {
-                                    for (var skeletonIndex = 0, skeletonCache = parsedData.skeletons.length; skeletonIndex < skeletonCache; skeletonIndex++) {
-                                        var parsedSkeleton = parsedData.skeletons[skeletonIndex];
-                                        if (parsedSkeleton.id === parsedMesh.skeletonId) {
-                                            var skeleton = BABYLON.Skeleton.Parse(parsedSkeleton, scene);
-                                            skeletons.push(skeleton);
-                                            loadedSkeletonsIds.push(parsedSkeleton.id);
-                                            log += "\n\tSkeleton " + skeleton.toString(fullDetails);
+                                // Skeleton ?
+                                if (parsedMesh.skeletonId > -1 && parsedData.skeletons !== undefined && parsedData.skeletons !== null) {
+                                    var skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
+                                    if (skeletonAlreadyLoaded === false) {
+                                        for (var skeletonIndex = 0, skeletonCache = parsedData.skeletons.length; skeletonIndex < skeletonCache; skeletonIndex++) {
+                                            var parsedSkeleton = parsedData.skeletons[skeletonIndex];
+                                            if (parsedSkeleton.id === parsedMesh.skeletonId) {
+                                                var skeleton = BABYLON.Skeleton.Parse(parsedSkeleton, scene);
+                                                skeletons.push(skeleton);
+                                                loadedSkeletonsIds.push(parsedSkeleton.id);
+                                                log += "\n\tSkeleton " + skeleton.toString(fullDetails);
+                                            }
                                         }
                                     }
                                 }
+                                var mesh = BABYLON.Mesh.Parse(parsedMesh, scene, rootUrl);
+                                meshes.push(mesh);
+                                log += "\n\tMesh " + mesh.toString(fullDetails);
                             }
-                            var mesh = BABYLON.Mesh.Parse(parsedMesh, scene, rootUrl);
-                            meshes.push(mesh);
-                            log += "\n\tMesh " + mesh.toString(fullDetails);
                         }
-                    }
-                    // Connecting parents
-                    var currentMesh;
-                    for (index = 0, cache = scene.meshes.length; index < cache; index++) {
-                        currentMesh = scene.meshes[index];
-                        if (currentMesh._waitingParentId) {
-                            currentMesh.parent = scene.getLastEntryByID(currentMesh._waitingParentId);
-                            currentMesh._waitingParentId = undefined;
-                        }
-                    }
-                    // freeze and compute world matrix application
-                    for (index = 0, cache = scene.meshes.length; index < cache; index++) {
-                        currentMesh = scene.meshes[index];
-                        if (currentMesh._waitingFreezeWorldMatrix) {
-                            currentMesh.freezeWorldMatrix();
-                            currentMesh._waitingFreezeWorldMatrix = undefined;
+                        // Connecting parents
+                        var currentMesh;
+                        for (index = 0, cache = scene.meshes.length; index < cache; index++) {
+                            currentMesh = scene.meshes[index];
+                            if (currentMesh._waitingParentId) {
+                                currentMesh.parent = scene.getLastEntryByID(currentMesh._waitingParentId);
+                                currentMesh._waitingParentId = undefined;
+                            }
                         }
-                        else {
-                            currentMesh.computeWorldMatrix(true);
+                        // freeze and compute world matrix application
+                        for (index = 0, cache = scene.meshes.length; index < cache; index++) {
+                            currentMesh = scene.meshes[index];
+                            if (currentMesh._waitingFreezeWorldMatrix) {
+                                currentMesh.freezeWorldMatrix();
+                                currentMesh._waitingFreezeWorldMatrix = undefined;
+                            }
+                            else {
+                                currentMesh.computeWorldMatrix(true);
+                            }
                         }
                     }
                     // Particles
-                    if (parsedData.particleSystems) {
+                    if (parsedData.particleSystems !== undefined && parsedData.particleSystems !== null) {
                         for (index = 0, cache = parsedData.particleSystems.length; index < cache; index++) {
                             var parsedParticleSystem = parsedData.particleSystems[index];
                             if (hierarchyIds.indexOf(parsedParticleSystem.emitterId) !== -1) {
@@ -48715,19 +48725,19 @@ var BABYLON;
                     log = "";
                     var fullDetails = BABYLON.SceneLoader.loggingLevel === BABYLON.SceneLoader.DETAILED_LOGGING;
                     // Scene
-                    if (parsedData.useDelayedTextureLoading !== undefined) {
+                    if (parsedData.useDelayedTextureLoading !== undefined && parsedData.useDelayedTextureLoading !== null) {
                         scene.useDelayedTextureLoading = parsedData.useDelayedTextureLoading && !BABYLON.SceneLoader.ForceFullSceneLoadingForIncremental;
                     }
-                    if (parsedData.autoClear !== undefined) {
+                    if (parsedData.autoClear !== undefined && parsedData.autoClear !== null) {
                         scene.autoClear = parsedData.autoClear;
                     }
-                    if (parsedData.clearColor !== undefined) {
+                    if (parsedData.clearColor !== undefined && parsedData.clearColor !== null) {
                         scene.clearColor = BABYLON.Color4.FromArray(parsedData.clearColor);
                     }
-                    if (parsedData.ambientColor !== undefined) {
+                    if (parsedData.ambientColor !== undefined && parsedData.ambientColor !== null) {
                         scene.ambientColor = BABYLON.Color3.FromArray(parsedData.ambientColor);
                     }
-                    if (parsedData.gravity !== undefined) {
+                    if (parsedData.gravity !== undefined && parsedData.gravity !== null) {
                         scene.gravity = BABYLON.Vector3.FromArray(parsedData.gravity);
                     }
                     // Fog
@@ -48766,18 +48776,18 @@ var BABYLON;
                         scene.enablePhysics(physicsGravity, physicsPlugin);
                     }
                     // Metadata
-                    if (parsedData.metadata !== undefined) {
+                    if (parsedData.metadata !== undefined && parsedData.metadata !== null) {
                         scene.metadata = parsedData.metadata;
                     }
                     //collisions, if defined. otherwise, default is true
-                    if (parsedData.collisionsEnabled !== undefined) {
+                    if (parsedData.collisionsEnabled !== undefined && parsedData.collisionsEnabled !== null) {
                         scene.collisionsEnabled = parsedData.collisionsEnabled;
                     }
                     scene.workerCollisions = !!parsedData.workerCollisions;
                     var index;
                     var cache;
                     // Lights
-                    if (parsedData.lights !== undefined) {
+                    if (parsedData.lights !== undefined && parsedData.lights !== null) {
                         for (index = 0, cache = parsedData.lights.length; index < cache; index++) {
                             var parsedLight = parsedData.lights[index];
                             var light = BABYLON.Light.Parse(parsedLight, scene);
@@ -48786,7 +48796,7 @@ var BABYLON;
                         }
                     }
                     // Animations
-                    if (parsedData.animations !== undefined) {
+                    if (parsedData.animations !== undefined && parsedData.animations !== null) {
                         for (index = 0, cache = parsedData.animations.length; index < cache; index++) {
                             var parsedAnimation = parsedData.animations[index];
                             var animation = BABYLON.Animation.Parse(parsedAnimation);
@@ -48799,7 +48809,7 @@ var BABYLON;
                         scene.beginAnimation(scene, parsedData.autoAnimateFrom, parsedData.autoAnimateTo, parsedData.autoAnimateLoop, parsedData.autoAnimateSpeed || 1.0);
                     }
                     // Materials
-                    if (parsedData.materials !== undefined) {
+                    if (parsedData.materials !== undefined && parsedData.materials !== null) {
                         for (index = 0, cache = parsedData.materials.length; index < cache; index++) {
                             var parsedMaterial = parsedData.materials[index];
                             var mat = BABYLON.Material.Parse(parsedMaterial, scene, rootUrl);
@@ -48807,7 +48817,7 @@ var BABYLON;
                             log += "\n\t\t" + mat.toString(fullDetails);
                         }
                     }
-                    if (parsedData.multiMaterials !== undefined) {
+                    if (parsedData.multiMaterials !== undefined && parsedData.multiMaterials !== null) {
                         for (index = 0, cache = parsedData.multiMaterials.length; index < cache; index++) {
                             var parsedMultiMaterial = parsedData.multiMaterials[index];
                             var mmat = BABYLON.Material.ParseMultiMaterial(parsedMultiMaterial, scene);
@@ -48816,14 +48826,14 @@ var BABYLON;
                         }
                     }
                     // Morph targets
-                    if (parsedData.morphTargetManagers !== undefined) {
+                    if (parsedData.morphTargetManagers !== undefined && parsedData.morphTargetManagers !== null) {
                         for (var _i = 0, _a = parsedData.morphTargetManagers; _i < _a.length; _i++) {
                             var managerData = _a[_i];
                             var parsedManager = BABYLON.MorphTargetManager.Parse(managerData, scene);
                         }
                     }
                     // Skeletons
-                    if (parsedData.skeletons !== undefined) {
+                    if (parsedData.skeletons !== undefined && parsedData.skeletons !== null) {
                         for (index = 0, cache = parsedData.skeletons.length; index < cache; index++) {
                             var parsedSkeleton = parsedData.skeletons[index];
                             var skeleton = BABYLON.Skeleton.Parse(parsedSkeleton, scene);
@@ -48833,10 +48843,10 @@ var BABYLON;
                     }
                     // Geometries
                     var geometries = parsedData.geometries;
-                    if (geometries !== undefined) {
+                    if (geometries !== undefined && geometries !== null) {
                         // Boxes
                         var boxes = geometries.boxes;
-                        if (boxes !== undefined) {
+                        if (boxes !== undefined && boxes !== null) {
                             for (index = 0, cache = boxes.length; index < cache; index++) {
                                 var parsedBox = boxes[index];
                                 BABYLON.Geometry.Primitives.Box.Parse(parsedBox, scene);
@@ -48844,7 +48854,7 @@ var BABYLON;
                         }
                         // Spheres
                         var spheres = geometries.spheres;
-                        if (spheres !== undefined) {
+                        if (spheres !== undefined && spheres !== null) {
                             for (index = 0, cache = spheres.length; index < cache; index++) {
                                 var parsedSphere = spheres[index];
                                 BABYLON.Geometry.Primitives.Sphere.Parse(parsedSphere, scene);
@@ -48852,7 +48862,7 @@ var BABYLON;
                         }
                         // Cylinders
                         var cylinders = geometries.cylinders;
-                        if (cylinders !== undefined) {
+                        if (cylinders !== undefined && cylinders !== null) {
                             for (index = 0, cache = cylinders.length; index < cache; index++) {
                                 var parsedCylinder = cylinders[index];
                                 BABYLON.Geometry.Primitives.Cylinder.Parse(parsedCylinder, scene);
@@ -48860,7 +48870,7 @@ var BABYLON;
                         }
                         // Toruses
                         var toruses = geometries.toruses;
-                        if (toruses !== undefined) {
+                        if (toruses !== undefined && toruses !== null) {
                             for (index = 0, cache = toruses.length; index < cache; index++) {
                                 var parsedTorus = toruses[index];
                                 BABYLON.Geometry.Primitives.Torus.Parse(parsedTorus, scene);
@@ -48868,7 +48878,7 @@ var BABYLON;
                         }
                         // Grounds
                         var grounds = geometries.grounds;
-                        if (grounds !== undefined) {
+                        if (grounds !== undefined && grounds !== null) {
                             for (index = 0, cache = grounds.length; index < cache; index++) {
                                 var parsedGround = grounds[index];
                                 BABYLON.Geometry.Primitives.Ground.Parse(parsedGround, scene);
@@ -48876,7 +48886,7 @@ var BABYLON;
                         }
                         // Planes
                         var planes = geometries.planes;
-                        if (planes !== undefined) {
+                        if (planes !== undefined && planes !== null) {
                             for (index = 0, cache = planes.length; index < cache; index++) {
                                 var parsedPlane = planes[index];
                                 BABYLON.Geometry.Primitives.Plane.Parse(parsedPlane, scene);
@@ -48884,7 +48894,7 @@ var BABYLON;
                         }
                         // TorusKnots
                         var torusKnots = geometries.torusKnots;
-                        if (torusKnots !== undefined) {
+                        if (torusKnots !== undefined && torusKnots !== null) {
                             for (index = 0, cache = torusKnots.length; index < cache; index++) {
                                 var parsedTorusKnot = torusKnots[index];
                                 BABYLON.Geometry.Primitives.TorusKnot.Parse(parsedTorusKnot, scene);
@@ -48892,7 +48902,7 @@ var BABYLON;
                         }
                         // VertexData
                         var vertexData = geometries.vertexData;
-                        if (vertexData !== undefined) {
+                        if (vertexData !== undefined && vertexData !== null) {
                             for (index = 0, cache = vertexData.length; index < cache; index++) {
                                 var parsedVertexData = vertexData[index];
                                 BABYLON.Geometry.Parse(parsedVertexData, scene, rootUrl);
@@ -48900,7 +48910,7 @@ var BABYLON;
                         }
                     }
                     // Meshes
-                    if (parsedData.meshes !== undefined) {
+                    if (parsedData.meshes !== undefined && parsedData.meshes !== null) {
                         for (index = 0, cache = parsedData.meshes.length; index < cache; index++) {
                             var parsedMesh = parsedData.meshes[index];
                             var mesh = BABYLON.Mesh.Parse(parsedMesh, scene, rootUrl);
@@ -48909,7 +48919,7 @@ var BABYLON;
                         }
                     }
                     // Cameras
-                    if (parsedData.cameras !== undefined) {
+                    if (parsedData.cameras !== undefined && parsedData.cameras !== null) {
                         for (index = 0, cache = parsedData.cameras.length; index < cache; index++) {
                             var parsedCamera = parsedData.cameras[index];
                             var camera = BABYLON.Camera.Parse(parsedCamera, scene);
@@ -48917,7 +48927,7 @@ var BABYLON;
                             log += "\n\t\t" + camera.toString(fullDetails);
                         }
                     }
-                    if (parsedData.activeCameraID !== undefined) {
+                    if (parsedData.activeCameraID !== undefined && parsedData.activeCameraID !== null) {
                         scene.setActiveCameraByID(parsedData.activeCameraID);
                     }
                     // Browsing all the graph to connect the dots
@@ -48938,7 +48948,7 @@ var BABYLON;
                     // Sounds
                     var loadedSounds = [];
                     var loadedSound;
-                    if (BABYLON.AudioEngine && parsedData.sounds !== undefined) {
+                    if (BABYLON.AudioEngine && parsedData.sounds !== undefined && parsedData.sounds !== null) {
                         for (index = 0, cache = parsedData.sounds.length; index < cache; index++) {
                             var parsedSound = parsedData.sounds[index];
                             if (BABYLON.Engine.audioEngine.canUseWebAudio) {
@@ -48982,21 +48992,21 @@ var BABYLON;
                         }
                     }
                     // Particles Systems
-                    if (parsedData.particleSystems !== undefined) {
+                    if (parsedData.particleSystems !== undefined && parsedData.particleSystems !== null) {
                         for (index = 0, cache = parsedData.particleSystems.length; index < cache; index++) {
                             var parsedParticleSystem = parsedData.particleSystems[index];
                             BABYLON.ParticleSystem.Parse(parsedParticleSystem, scene, rootUrl);
                         }
                     }
                     // Lens flares
-                    if (parsedData.lensFlareSystems !== undefined) {
+                    if (parsedData.lensFlareSystems !== undefined && parsedData.lensFlareSystems !== null) {
                         for (index = 0, cache = parsedData.lensFlareSystems.length; index < cache; index++) {
                             var parsedLensFlareSystem = parsedData.lensFlareSystems[index];
                             BABYLON.LensFlareSystem.Parse(parsedLensFlareSystem, scene, rootUrl);
                         }
                     }
                     // Shadows
-                    if (parsedData.shadowGenerators !== undefined) {
+                    if (parsedData.shadowGenerators !== undefined && parsedData.shadowGenerators !== null) {
                         for (index = 0, cache = parsedData.shadowGenerators.length; index < cache; index++) {
                             var parsedShadowGenerator = parsedData.shadowGenerators[index];
                             BABYLON.ShadowGenerator.Parse(parsedShadowGenerator, scene);
@@ -49027,7 +49037,7 @@ var BABYLON;
                         }
                     }
                     // Actions (scene)
-                    if (parsedData.actions !== undefined) {
+                    if (parsedData.actions !== undefined && parsedData.actions !== null) {
                         BABYLON.ActionManager.Parse(parsedData.actions, null, scene);
                     }
                     // Finish

src/Materials/PBR/babylon.pbrMaterial.ts

@@ -572,8 +572,8 @@
                 activeTextures.push(this._emissiveTexture);
             }
 
-            if (this._reflectionTexture) {
-                activeTextures.push(this._reflectionTexture);
+            if (this._reflectivityTexture) {
+                activeTextures.push(this._reflectivityTexture);
             }
 
             if (this._metallicTexture) {
@@ -620,6 +620,10 @@
                 return true;
             }     
 
+            if (this._reflectivityTexture === texture) {
+                return true;
+            }                
+
             if (this._metallicTexture === texture) {
                 return true;
             }