Fixing issues due to folder renaming

src/Loading/Plugins/babylon.babylonFileLoader.js

@@ -1055,6 +1055,9 @@ var BABYLON;
                                         });
                                     }
                                 });
+                                if (!found) {
+                                    BABYLON.Tools.Warn("Geometry not found for mesh " + parsedMesh.id);
+                                }
                             }
                         }
                         // Material ?
@@ -1078,7 +1081,9 @@ var BABYLON;
                             }
                             if (!materialFound) {
                                 loadedMaterialsIds.push(parsedMesh.materialId);
-                                parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
+                                if (!parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl)) {
+                                    BABYLON.Tools.Warn("Material not found for mesh " + parsedMesh.id);
+                                }
                             }
                         }
                         // Skeleton ?

src/Loading/Plugins/babylon.babylonFileLoader.ts

@@ -1003,7 +1003,7 @@
             playbackRate: parsedSound.playbackRate
         };
 
-        var newSound = new BABYLON.Sound(soundName, soundUrl, scene,() => { scene._removePendingData(newSound); }, options);
+        var newSound = new BABYLON.Sound(soundName, soundUrl, scene, () => { scene._removePendingData(newSound); }, options);
         scene._addPendingData(newSound);
 
         if (parsedSound.position) {
@@ -1290,9 +1290,12 @@
                                             found = true;
                                         }
                                     });
-                                    
+
                                 }
                             });
+                            if (!found) {
+                                Tools.Warn("Geometry not found for mesh " + parsedMesh.id);
+                            }
                         }
                     }
 
@@ -1320,7 +1323,9 @@
 
                         if (!materialFound) {
                             loadedMaterialsIds.push(parsedMesh.materialId);
-                            parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
+                            if (!parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl)) {
+                                Tools.Warn("Material not found for mesh " + parsedMesh.id);
+                            }
                         }
                     }
 
@@ -1584,4 +1589,4 @@
             return true;
         }
     });
-}
+}

src/Materials/Textures/babylon.rawTexture.ts

@@ -11,7 +11,7 @@
 
         public update(data: ArrayBufferView): void {
             this.getScene().getEngine().updateRawTexture(this._texture, data, this.format, this._invertY);
-        };
+        }
 
         // Statics
         public static CreateLuminanceTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps: boolean = true, invertY: boolean = false, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE): RawTexture {

src/Mesh/babylon.mesh.js

@@ -795,7 +795,10 @@ var BABYLON;
             this.scaling.copyFromFloats(1, 1, 1);
             this.position.copyFromFloats(0, 0, 0);
             this.rotation.copyFromFloats(0, 0, 0);
-            this.rotationQuaternion = BABYLON.Quaternion.Identity();
+            //only if quaternion is already set
+            if (this.rotationQuaternion) {
+                this.rotationQuaternion = BABYLON.Quaternion.Identity();
+            }
             this._worldMatrix = BABYLON.Matrix.Identity();
         };
         // Cache

src/Mesh/babylon.mesh.ts

@@ -921,7 +921,10 @@
             this.scaling.copyFromFloats(1, 1, 1);
             this.position.copyFromFloats(0, 0, 0);
             this.rotation.copyFromFloats(0, 0, 0);
-            this.rotationQuaternion = Quaternion.Identity();
+            //only if quaternion is already set
+            if (this.rotationQuaternion) {
+                this.rotationQuaternion = Quaternion.Identity();
+            }
             this._worldMatrix = Matrix.Identity();
         }
 

src/PostProcess/babylon.hdrRenderingPipeline.js

@@ -174,8 +174,8 @@ var BABYLON;
                 }
                 _this._hdrOutputLuminance = BABYLON.Tools.Clamp(_this._hdrOutputLuminance, _this.minimumLuminance, _this.maximumLuminance);
                 hdrLastLuminance += scene.getEngine().getDeltaTime();
-                effect.setTextureFromPostProcess("textureSampler", _this._originalPostProcess);
-                effect.setTextureFromPostProcess("otherSampler", _this._textureAdderPostProcess);
+                effect.setTextureFromPostProcess("textureSampler", _this._textureAdderPostProcess);
+                effect.setTextureFromPostProcess("otherSampler", _this._originalPostProcess);
                 effect.setFloat("exposure", _this.exposure);
                 effect.setFloat("avgLuminance", _this._hdrOutputLuminance);
                 _this._needUpdate = false;

src/PostProcess/babylon.hdrRenderingPipeline.ts

@@ -222,8 +222,8 @@
                 this._hdrOutputLuminance = Tools.Clamp(this._hdrOutputLuminance, this.minimumLuminance, this.maximumLuminance);
                 hdrLastLuminance += scene.getEngine().getDeltaTime();
 
-                effect.setTextureFromPostProcess("textureSampler", this._originalPostProcess);
-                effect.setTextureFromPostProcess("otherSampler", this._textureAdderPostProcess);
+                effect.setTextureFromPostProcess("textureSampler", this._textureAdderPostProcess);
+                effect.setTextureFromPostProcess("otherSampler", this._originalPostProcess);
                 effect.setFloat("exposure", this.exposure);
                 effect.setFloat("avgLuminance", this._hdrOutputLuminance);
 

src/Tools/babylon.sceneSerializer.js

@@ -524,7 +524,7 @@ var BABYLON;
             var geometryId = geometry.id;
             serializationObject.geometryId = geometryId;
             if (!mesh.getScene().getGeometryByID(geometryId)) {
-                // geometry was in the memory but not added to the scene, nevertheless it's better to serialize too be able to reload the mesh with its geometry
+                // geometry was in the memory but not added to the scene, nevertheless it's better to serialize to be able to reload the mesh with its geometry
                 serializeGeometry(geometry, serializationScene.geometries);
             }
             // SubMeshes
@@ -686,6 +686,46 @@ var BABYLON;
             }
             return serializationObject;
         };
+        SceneSerializer.SerializeMesh = function (mesh) {
+            var serializationObject = {};
+            //only works if the mesh is already loaded
+            if (mesh.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADED || mesh.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_NONE) {
+                //serialize material
+                if (mesh.material) {
+                    if (mesh.material instanceof BABYLON.StandardMaterial) {
+                        serializationObject.materials = [];
+                        serializationObject.materials.push(serializeMaterial(mesh.material));
+                    }
+                    else if (mesh.material instanceof BABYLON.MultiMaterial) {
+                        serializationObject.multiMaterials = [];
+                        serializationObject.multiMaterials.push(serializeMultiMaterial(mesh.material));
+                    }
+                }
+                //serialize geometry
+                var geometry = mesh._geometry;
+                if (geometry) {
+                    serializationObject.geometries = {};
+                    serializationObject.geometries.boxes = [];
+                    serializationObject.geometries.spheres = [];
+                    serializationObject.geometries.cylinders = [];
+                    serializationObject.geometries.toruses = [];
+                    serializationObject.geometries.grounds = [];
+                    serializationObject.geometries.planes = [];
+                    serializationObject.geometries.torusKnots = [];
+                    serializationObject.geometries.vertexData = [];
+                    serializeGeometry(geometry, serializationObject.geometries);
+                }
+                // Skeletons
+                if (mesh.skeleton) {
+                    serializationObject.skeletons = [];
+                    serializationObject.skeletons.push(serializeSkeleton(mesh.skeleton));
+                }
+                //serialize the actual mesh
+                serializationObject.meshes = [];
+                serializationObject.meshes.push(serializeMesh(mesh, serializationObject));
+            }
+            return serializationObject;
+        };
         return SceneSerializer;
     })();
     BABYLON.SceneSerializer = SceneSerializer;

src/Tools/babylon.sceneSerializer.ts

@@ -651,7 +651,7 @@
             serializationObject.geometryId = geometryId;
 
             if (!mesh.getScene().getGeometryByID(geometryId)) {
-                // geometry was in the memory but not added to the scene, nevertheless it's better to serialize too be able to reload the mesh with its geometry
+                // geometry was in the memory but not added to the scene, nevertheless it's better to serialize to be able to reload the mesh with its geometry
                 serializeGeometry(geometry, serializationScene.geometries);
             }
 
@@ -842,5 +842,50 @@
 
             return serializationObject;
         }
+
+        public static SerializeMesh(mesh: Mesh): any {
+            var serializationObject: any = {};
+			
+            //only works if the mesh is already loaded
+            if (mesh.delayLoadState === Engine.DELAYLOADSTATE_LOADED || mesh.delayLoadState === Engine.DELAYLOADSTATE_NONE) {
+                //serialize material
+                if (mesh.material) {
+                    if (mesh.material instanceof StandardMaterial) {
+                        serializationObject.materials = [];
+                        serializationObject.materials.push(serializeMaterial(<StandardMaterial>mesh.material));
+                    } else if (mesh.material instanceof MultiMaterial) {
+                        serializationObject.multiMaterials = [];
+                        serializationObject.multiMaterials.push(serializeMultiMaterial(<MultiMaterial>mesh.material));
+                    }
+                }
+                //serialize geometry
+                var geometry = mesh._geometry;
+                if (geometry) {
+                    serializationObject.geometries = {};
+
+                    serializationObject.geometries.boxes = [];
+                    serializationObject.geometries.spheres = [];
+                    serializationObject.geometries.cylinders = [];
+                    serializationObject.geometries.toruses = [];
+                    serializationObject.geometries.grounds = [];
+                    serializationObject.geometries.planes = [];
+                    serializationObject.geometries.torusKnots = [];
+                    serializationObject.geometries.vertexData = [];
+
+                    serializeGeometry(geometry, serializationObject.geometries);
+                }
+                // Skeletons
+                if (mesh.skeleton) {
+                    serializationObject.skeletons = [];
+                    serializationObject.skeletons.push(serializeSkeleton(mesh.skeleton));
+                }
+				
+                //serialize the actual mesh
+                serializationObject.meshes = [];
+                serializationObject.meshes.push(serializeMesh(mesh, serializationObject));
+            }
+
+            return serializationObject;
+        }
     }
-}
+}

src/babylon.engine.js

@@ -1381,7 +1381,6 @@ var BABYLON;
             this._activeTexturesCache = [];
             texture.isReady = true;
         };
-        ;
         Engine.prototype.createRawTexture = function (data, width, height, format, generateMipMaps, invertY, samplingMode) {
             var texture = this._gl.createTexture();
             texture._baseWidth = width;
@@ -1943,8 +1942,8 @@ var BABYLON;
         // Updatable statics so stick with vars here
         Engine.Epsilon = 0.001;
         Engine.CollisionsEpsilon = 0.001;
-        Engine.CodeRepository = "Babylon/";
-        Engine.ShadersRepository = "Babylon/Shaders/";
+        Engine.CodeRepository = "src/";
+        Engine.ShadersRepository = "src/Shaders/";
         return Engine;
     })();
     BABYLON.Engine = Engine;

src/babylon.engine.ts

@@ -467,8 +467,8 @@
         // Updatable statics so stick with vars here
         public static Epsilon = 0.001;
         public static CollisionsEpsilon = 0.001;
-        public static CodeRepository = "Babylon/";
-        public static ShadersRepository = "Babylon/Shaders/";
+        public static CodeRepository = "src/";
+        public static ShadersRepository = "src/Shaders/";
 
         // Public members
         public isFullscreen = false;
@@ -1648,7 +1648,7 @@
             this._gl.bindTexture(this._gl.TEXTURE_2D, null);
             this._activeTexturesCache = [];
             texture.isReady = true;
-        };
+        }
 
         public createRawTexture(data: ArrayBufferView, width: number, height: number, format: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number): WebGLTexture {
             var texture = this._gl.createTexture();