Merge pull request #609 from RaananW/serializeMesh-array

Array input for SerializeMesh

dist/preview release - alpha/what's new.md

@@ -19,7 +19,7 @@
     - Added some utility functions to Vector2/3/4 [PR](https://github.com/BabylonJS/Babylon.js/pull/578) [jahow](https://github.com/jahow)
     - New rawTexture.update function [robgdl](https://github.com/robgdl)
     - Changes to meshes transform baking and added flipFaces [PR](https://github.com/BabylonJS/Babylon.js/pull/579) [jahow](https://github.com/jahow)
-    - SerializeMesh serializes a single mesh to be imported with the loader's ImportMesh. [PR](https://github.com/BabylonJS/Babylon.js/pull/583) [RaananW](https://github.com/RaananW)
+    - SerializeMesh serializes a mesh or array of meshes to be imported with the loader's ImportMesh. [PR](https://github.com/BabylonJS/Babylon.js/pull/583) [PR2](https://github.com/BabylonJS/Babylon.js/pull/609) [RaananW](https://github.com/RaananW)
 	- onCollide callback for meshes calling moveWithCollisions. [PR](https://github.com/BabylonJS/Babylon.js/pull/585) [RaananW](https://github.com/RaananW)
   - **Bug fixes**
     - Fixing bug with rig cameras positioning [deltakosh](https://github.com/deltakosh)

src/Tools/babylon.sceneSerializer.js

@@ -396,7 +396,7 @@ var BABYLON;
             serializationGeometries.torusKnots.push(serializeTorusKnot(geometry));
         }
         else if (geometry instanceof BABYLON.Geometry.Primitives._Primitive) {
-            throw new Error("Unknow primitive type");
+            throw new Error("Unknown primitive type");
         }
         else {
             serializationGeometries.vertexData.push(serializeVertexData(geometry));
@@ -599,6 +599,46 @@ var BABYLON;
         serializationObject.layerMask = mesh.layerMask;
         return serializationObject;
     };
+    var finalizeSingleMesh = function (mesh, 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 || [];
+                    serializationObject.materials.push(serializeMaterial(mesh.material));
+                }
+                else if (mesh.material instanceof BABYLON.MultiMaterial) {
+                    serializationObject.multiMaterials = serializationObject.multiMaterials || [];
+                    serializationObject.multiMaterials.push(serializeMultiMaterial(mesh.material));
+                }
+            }
+            //serialize geometry
+            var geometry = mesh._geometry;
+            if (geometry) {
+                if (!serializationObject.geometries) {
+                    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 || [];
+                serializationObject.skeletons.push(serializeSkeleton(mesh.skeleton));
+            }
+            //serialize the actual mesh
+            serializationObject.meshes = serializationObject.meshes || [];
+            serializationObject.meshes.push(serializeMesh(mesh, serializationObject));
+        }
+    };
     var SceneSerializer = (function () {
         function SceneSerializer() {
         }
@@ -699,48 +739,23 @@ var BABYLON;
             }
             return serializationObject;
         };
-        SceneSerializer.SerializeMesh = function (mesh) {
+        SceneSerializer.SerializeMesh = function (toSerialize /* Mesh || Mesh[] */, withParents) {
+            if (withParents === void 0) { withParents = false; }
             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));
+            toSerialize = (toSerialize instanceof Array) ? toSerialize : [toSerialize];
+            if (withParents) {
+                for (var i = 0; i < toSerialize.length; ++i) {
+                    if (toSerialize[i].parent) {
+                        toSerialize.push(toSerialize[i].parent);
                     }
-                    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));
             }
+            toSerialize.forEach(function (mesh) {
+                finalizeSingleMesh(mesh, serializationObject);
+            });
             return serializationObject;
         };
         return SceneSerializer;
     })();
     BABYLON.SceneSerializer = SceneSerializer;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.sceneSerializer.js.map

src/Tools/babylon.sceneSerializer.ts

@@ -472,7 +472,7 @@
             serializationGeometries.torusKnots.push(serializeTorusKnot(<Geometry.Primitives.TorusKnot>geometry));
         }
         else if (geometry instanceof Geometry.Primitives._Primitive) {
-            throw new Error("Unknow primitive type");
+            throw new Error("Unknown primitive type");
         }
         else {
             serializationGeometries.vertexData.push(serializeVertexData(geometry));
@@ -741,6 +741,49 @@
         return serializationObject;
     };
 
+    var finalizeSingleMesh = function (mesh: Mesh, 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 || [];
+                    serializationObject.materials.push(serializeMaterial(<StandardMaterial>mesh.material));
+                } else if (mesh.material instanceof MultiMaterial) {
+                    serializationObject.multiMaterials = serializationObject.multiMaterials || [];
+                    serializationObject.multiMaterials.push(serializeMultiMaterial(<MultiMaterial>mesh.material));
+                }
+            }
+            //serialize geometry
+            var geometry = mesh._geometry;
+            if (geometry) {
+                if (!serializationObject.geometries) {
+                    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 || [];
+                serializationObject.skeletons.push(serializeSkeleton(mesh.skeleton));
+            }
+
+            //serialize the actual mesh
+            serializationObject.meshes = serializationObject.meshes || [];
+            serializationObject.meshes.push(serializeMesh(mesh, serializationObject));
+        }
+    }
+
 
     export class SceneSerializer {
         public static Serialize(scene: Scene): any {
@@ -860,48 +903,24 @@
             return serializationObject;
         }
 
-        public static SerializeMesh(mesh: Mesh): any {
+        public static SerializeMesh(toSerialize: any /* Mesh || Mesh[] */, withParents : boolean = false): 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 = {};
+            toSerialize = (toSerialize instanceof Array) ? toSerialize : [toSerialize];
 
-                    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));
+            if (withParents) {
+                //deliberate for loop! not for each, appended should be processed as well.
+                for (var i = 0; i < toSerialize.length; ++i) {
+                    if (toSerialize[i].parent) {
+                        toSerialize.push(toSerialize[i].parent);
+                    }
                 }
-
-                //serialize the actual mesh
-                serializationObject.meshes = [];
-                serializationObject.meshes.push(serializeMesh(mesh, serializationObject));
             }
 
+            toSerialize.forEach(function (mesh: Mesh) {
+                finalizeSingleMesh(mesh, serializationObject);
+            });
+
             return serializationObject;
         }
     }